@coinbase/wallet-sdk/dist/CoinbaseWalletProvider.js

Coinbase Wallet JavaScript SDK

var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
import { createSigner, fetchSignerType, loadSignerType, storeSignerType } from './sign/util.js';
import { Communicator } from './core/communicator/Communicator.js';
import { CB_WALLET_RPC_URL } from './core/constants.js';
import { standardErrorCodes } from './core/error/constants.js';
import { standardErrors } from './core/error/errors.js';
import { serializeError } from './core/error/serialize.js';
import { ProviderEventEmitter, } from './core/provider/interface.js';
import { ScopedLocalStorage } from './core/storage/ScopedLocalStorage.js';
import { hexStringFromNumber } from './core/type/util.js';
import { checkErrorForInvalidRequestArgs, fetchRPCRequest } from './util/provider.js';
export class CoinbaseWalletProvider extends ProviderEventEmitter {
    constructor(_a) {
        var { metadata } = _a, _b = _a.preference, { keysUrl } = _b, preference = __rest(_b, ["keysUrl"]);
        super();
        this.signer = null;
        this.isCoinbaseWallet = true;
        this.metadata = metadata;
        this.preference = preference;
        this.communicator = new Communicator({
            url: keysUrl,
            metadata,
            preference,
        });
        const signerType = loadSignerType();
        if (signerType) {
            this.signer = this.initSigner(signerType);
        }
    }
    async request(args) {
        try {
            checkErrorForInvalidRequestArgs(args);
            if (!this.signer) {
                switch (args.method) {
                    case 'eth_requestAccounts': {
                        const signerType = await this.requestSignerSelection(args);
                        const signer = this.initSigner(signerType);
                        await signer.handshake(args);
                        this.signer = signer;
                        storeSignerType(signerType);
                        break;
                    }
                    case 'wallet_sendCalls': {
                        const ephemeralSigner = this.initSigner('scw');
                        await ephemeralSigner.handshake({ method: 'handshake' }); // exchange session keys
                        const result = await ephemeralSigner.request(args); // send diffie-hellman encrypted request
                        await ephemeralSigner.cleanup(); // clean up (rotate) the ephemeral session keys
                        return result;
                    }
                    case 'wallet_getCallsStatus':
                        return fetchRPCRequest(args, CB_WALLET_RPC_URL);
                    case 'net_version':
                        return 1; // default value
                    case 'eth_chainId':
                        return hexStringFromNumber(1); // default value
                    default: {
                        throw standardErrors.provider.unauthorized("Must call 'eth_requestAccounts' before other methods");
                    }
                }
            }
            return await this.signer.request(args);
        }
        catch (error) {
            const { code } = error;
            if (code === standardErrorCodes.provider.unauthorized)
                this.disconnect();
            return Promise.reject(serializeError(error));
        }
    }
    /** @deprecated Use `.request({ method: 'eth_requestAccounts' })` instead. */
    async enable() {
        console.warn(`.enable() has been deprecated. Please use .request({ method: "eth_requestAccounts" }) instead.`);
        return await this.request({
            method: 'eth_requestAccounts',
        });
    }
    async disconnect() {
        var _a;
        await ((_a = this.signer) === null || _a === void 0 ? void 0 : _a.cleanup());
        this.signer = null;
        ScopedLocalStorage.clearAll();
        this.emit('disconnect', standardErrors.provider.disconnected('User initiated disconnection'));
    }
    requestSignerSelection(handshakeRequest) {
        return fetchSignerType({
            communicator: this.communicator,
            preference: this.preference,
            metadata: this.metadata,
            handshakeRequest,
            callback: this.emit.bind(this),
        });
    }
    initSigner(signerType) {
        return createSigner({
            signerType,
            metadata: this.metadata,
            communicator: this.communicator,
            callback: this.emit.bind(this),
        });
    }
}
//# sourceMappingURL=CoinbaseWalletProvider.js.map