@taquito/wallet-connect 20.2.0-beta.0

package/dist/lib/taquito-wallet-connect.js

@@ -0,0 +1,530 @@
+"use strict";
+/**
+ * @packageDocumentation
+ * @module @taquito/wallet-connect
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletConnect = void 0;
+const sign_client_1 = require("@walletconnect/sign-client");
+const legacy_modal_1 = require("@walletconnect/legacy-modal");
+const taquito_1 = require("@taquito/taquito");
+const utils_1 = require("@walletconnect/utils");
+const types_1 = require("./types");
+const errors_1 = require("./errors");
+__exportStar(require("./errors"), exports);
+__exportStar(require("./types"), exports);
+const TEZOS_PLACEHOLDER = 'tezos';
+/**
+ * @description The `WalletConnect` class implements the `WalletProvider` interface, providing an alternative to `BeaconWallet`.
+ * This package enables dapps built with Taquito to connect to wallets via the WalletConnect/Reown protocol.
+ * @note Currently, a QR code is displayed to establish a connection with a wallet. As more Tezos wallets integrate with WalletConnect,
+ * we plan showing a list of available wallets alongside the QR code.
+ */
+class WalletConnect {
+    constructor(signClient) {
+        this.signClient = signClient;
+        this.signClient.on('session_delete', ({ topic }) => {
+            var _a;
+            if (((_a = this.session) === null || _a === void 0 ? void 0 : _a.topic) === topic) {
+                this.session = undefined;
+            }
+        });
+        this.signClient.on('session_expire', ({ topic }) => {
+            var _a;
+            if (((_a = this.session) === null || _a === void 0 ? void 0 : _a.topic) === topic) {
+                this.session = undefined;
+            }
+        });
+        this.signClient.on('session_update', ({ params, topic }) => {
+            var _a;
+            if (((_a = this.session) === null || _a === void 0 ? void 0 : _a.topic) === topic) {
+                this.session.namespaces = params.namespaces;
+                // TODO determine if we need validation on the namespace here
+            }
+        });
+        this.signClient.on('session_event', () => {
+            // TODO Do we need to handle other session events, such as "chainChanged", "accountsChanged", etc.
+        });
+    }
+    /**
+     * @description Initialize a WalletConnect provider
+     * (Initialize a WalletConnect client with persisted storage and a network connection)
+     *
+     * @example
+     * ```
+     * await WalletConnect.init({
+     *  projectId: "YOUR_PROJECT_ID", // can get YOUR_PROJECT_ID from [Reown Cloud](https://cloud.reown.com)
+     *  metadata: {
+     *    name: "YOUR_DAPP_NAME",
+     *    description: "YOUR_DAPP_DESCRIPTION",
+     *    icons: ["ICON_URL"],
+     *    url: "DAPP_URL",
+     *  },
+     * });
+     * ```
+     */
+    static init(initParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield sign_client_1.default.init(initParams);
+            return new WalletConnect(client);
+        });
+    }
+    /**
+     * @description Request permission for a new session and establish a connection.
+     *
+     * @param connectParams.permissionScope The networks, methods, and events that will be granted permission
+     * @param connectParams.pairingTopic Option to connect to an existing active pairing. If pairingTopic is defined, a prompt will appear in the corresponding wallet to accept or decline the session proposal. If no pairingTopic, a QR code modal will open in the dapp, allowing to connect to a wallet.
+     * @param connectParams.registryUrl Optional registry of wallet deep links to show in the Modal
+     * @error ConnectionFailed is thrown if no connection can be established with a wallet
+     */
+    requestPermissions(connectParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // TODO when Tezos wallets will officially support wallet connect, we need to provide a default value for registryUrl
+            try {
+                const { uri, approval } = yield this.signClient.connect({
+                    requiredNamespaces: {
+                        [TEZOS_PLACEHOLDER]: {
+                            chains: connectParams.permissionScope.networks.map((network) => `${TEZOS_PLACEHOLDER}:${network}`),
+                            methods: connectParams.permissionScope.methods,
+                            events: (_a = connectParams.permissionScope.events) !== null && _a !== void 0 ? _a : [],
+                        },
+                    },
+                    pairingTopic: connectParams.pairingTopic,
+                });
+                if (uri) {
+                    legacy_modal_1.default.open(uri, () => { }, { registryUrl: connectParams.registryUrl });
+                }
+                this.session = yield approval();
+            }
+            catch (error) {
+                throw new errors_1.ConnectionFailed(error);
+            }
+            finally {
+                legacy_modal_1.default.close();
+            }
+            this.validateReceivedNamespace(connectParams.permissionScope, this.session.namespaces);
+            this.setDefaultAccountAndNetwork();
+        });
+    }
+    /**
+     * @description Access all existing active pairings
+     */
+    getAvailablePairing() {
+        return this.signClient.pairing.getAll({ active: true });
+    }
+    /**
+     * @description Access all existing sessions
+     * @return an array of strings which represent the session keys
+     */
+    getAllExistingSessionKeys() {
+        return this.signClient.session.keys;
+    }
+    /**
+     * @description Configure the Client with an existing session.
+     * The session is immediately restored without a prompt on the wallet to accept/decline it.
+     * @error InvalidSessionKey is thrown if the provided session key doesn't exist
+     */
+    configureWithExistingSessionKey(key) {
+        const sessions = this.getAllExistingSessionKeys();
+        if (!sessions.includes(key)) {
+            throw new errors_1.InvalidSessionKey(key);
+        }
+        this.session = this.signClient.session.get(key);
+        this.setDefaultAccountAndNetwork();
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.session) {
+                yield this.signClient.disconnect({
+                    topic: this.session.topic,
+                    reason: (0, utils_1.getSdkError)('USER_DISCONNECTED'),
+                });
+                this.clearState();
+            }
+        });
+    }
+    getPeerMetadata() {
+        return this.getSession().peer.metadata;
+    }
+    /**
+     * @description Once the session is establish, send Tezos operations to be approved, signed and inject by the wallet.
+     * @error MissingRequiredScope is thrown if permission to send operation was not granted
+     */
+    sendOperations(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.getSession();
+            if (!this.getPermittedMethods().includes(types_1.PermissionScopeMethods.TEZOS_SEND)) {
+                throw new errors_1.MissingRequiredScope(types_1.PermissionScopeMethods.TEZOS_SEND);
+            }
+            const network = this.getActiveNetwork();
+            const account = yield this.getPKH();
+            this.validateNetworkAndAccount(network, account);
+            const { operationHash } = yield this.signClient.request({
+                topic: session.topic,
+                chainId: `${TEZOS_PLACEHOLDER}:${network}`,
+                request: {
+                    method: types_1.PermissionScopeMethods.TEZOS_SEND,
+                    params: {
+                        account,
+                        operations: params,
+                    },
+                },
+            });
+            return operationHash;
+        });
+    }
+    /**
+     * @description Once the session is establish, send payload to be signed by the wallet.
+     * @error MissingRequiredScope is thrown if permission to sign payload was not granted
+     */
+    sign(bytes, watermark) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.getSession();
+            if (!this.getPermittedMethods().includes(types_1.PermissionScopeMethods.TEZOS_SIGN)) {
+                throw new errors_1.MissingRequiredScope(types_1.PermissionScopeMethods.TEZOS_SIGN);
+            }
+            const network = this.getActiveNetwork();
+            const account = yield this.getPKH();
+            this.validateNetworkAndAccount(network, account);
+            let expression = bytes;
+            if (watermark) {
+                expression =
+                    Array.from(watermark, (byte) => byte.toString(16).padStart(2, '0')).join('') + expression;
+            }
+            const { signature } = yield this.signClient.request({
+                topic: session.topic,
+                chainId: `${TEZOS_PLACEHOLDER}:${network}`,
+                request: {
+                    method: types_1.PermissionScopeMethods.TEZOS_SIGN,
+                    params: {
+                        account: yield this.getPKH(),
+                        payload: expression,
+                    },
+                },
+            });
+            return signature;
+        });
+    }
+    /**
+     * @description Return all connected accounts from the active session
+     * @error NotConnected if no active session
+     */
+    getAccounts() {
+        return this.getTezosNamespace().accounts.map((account) => account.split(':')[2]);
+    }
+    /**
+     * @description Set the active account.
+     * Must be called if there are multiple accounts in the session and every time the active account is switched
+     * @param pkh public key hash of the selected account
+     * @error InvalidAccount thrown if the pkh is not part of the active accounts in the session
+     */
+    setActiveAccount(pkh) {
+        if (!this.getAccounts().includes(pkh)) {
+            throw new errors_1.InvalidAccount(pkh);
+        }
+        this.activeAccount = pkh;
+    }
+    /**
+     * @description Access the public key hash of the active account
+     * @error ActiveAccountUnspecified thrown when there are multiple Tezos account in the session and none is set as the active one
+     */
+    getPKH() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccount) {
+                this.getSession();
+                throw new errors_1.ActiveAccountUnspecified();
+            }
+            return this.activeAccount;
+        });
+    }
+    /**
+     * @description Access the public key of the active account
+     * @error ActiveAccountUnspecified thrown when there are multiple Tezos account in the session and none is set as the active one
+     * @error MissingRequiredScope is thrown if permission to get accounts was not granted
+     * @error PublicKeyRetrievalError is thrown if the public key is not found
+     */
+    getPK() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.getSession();
+            if (!this.getPermittedMethods().includes(types_1.PermissionScopeMethods.TEZOS_GET_ACCOUNTS)) {
+                throw new errors_1.MissingRequiredScope(types_1.PermissionScopeMethods.TEZOS_GET_ACCOUNTS);
+            }
+            const network = this.getActiveNetwork();
+            const account = yield this.getPKH();
+            const accounts = yield this.signClient.request({
+                topic: session.topic,
+                chainId: `${TEZOS_PLACEHOLDER}:${network}`,
+                request: {
+                    method: types_1.PermissionScopeMethods.TEZOS_GET_ACCOUNTS,
+                    params: {},
+                },
+            });
+            const selectedAccount = accounts.find((acc) => acc.address === account);
+            if (!selectedAccount) {
+                throw new errors_1.PublicKeyRetrievalError();
+            }
+            return selectedAccount.pubkey;
+        });
+    }
+    /**
+     * @description Return all networks from the namespace of the active session
+     * @error NotConnected if no active session
+     */
+    getNetworks() {
+        return this.getPermittedNetwork();
+    }
+    /**
+     * @description Set the active network.
+     * Must be called if there are multiple network in the session and every time the active network is switched
+     * @param network selected network
+     * @error InvalidNetwork thrown if the network is not part of the active networks in the session
+     */
+    setActiveNetwork(network) {
+        if (!this.getNetworks().includes(network)) {
+            throw new errors_1.InvalidNetwork(network);
+        }
+        this.activeNetwork = network;
+    }
+    /**
+     * @description Access the active network
+     * @error ActiveNetworkUnspecified thorwn when there are multiple Tezos netwroks in the session and none is set as the active one
+     */
+    getActiveNetwork() {
+        if (!this.activeNetwork) {
+            this.getSession();
+            throw new errors_1.ActiveNetworkUnspecified();
+        }
+        return this.activeNetwork;
+    }
+    setDefaultAccountAndNetwork() {
+        const activeAccount = this.getAccounts();
+        if (activeAccount.length === 1) {
+            this.activeAccount = activeAccount[0];
+        }
+        const activeNetwork = this.getNetworks();
+        if (activeNetwork.length === 1) {
+            this.activeNetwork = activeNetwork[0];
+        }
+    }
+    clearState() {
+        this.session = undefined;
+        this.activeAccount = undefined;
+        this.activeNetwork = undefined;
+    }
+    getSession() {
+        if (!this.session) {
+            throw new errors_1.NotConnected();
+        }
+        return this.session;
+    }
+    isActiveSession() {
+        return this.session ? true : false;
+    }
+    ping() {
+        this.signClient.ping({ topic: this.getSession().topic });
+    }
+    // https://docs.reown.com/api/sign/wallet-usage#namespaces
+    // TODO: add validations related to Namespaces extensions and related unit tests:
+    validateReceivedNamespace(scope, receivedNamespaces) {
+        if (receivedNamespaces[TEZOS_PLACEHOLDER]) {
+            this.validateMethods(scope.methods, receivedNamespaces[TEZOS_PLACEHOLDER].methods);
+            if (scope.events) {
+                this.validateEvents(scope.events, receivedNamespaces['tezos'].events);
+            }
+            this.validateAccounts(scope.networks, receivedNamespaces[TEZOS_PLACEHOLDER].accounts);
+        }
+        else {
+            this.clearState();
+            throw new errors_1.InvalidReceivedSessionNamespace('All namespaces must be approved', (0, utils_1.getSdkError)('USER_REJECTED').code, 'incomplete', 'tezos');
+        }
+    }
+    validateMethods(requiredMethods, receivedMethods) {
+        const missingMethods = [];
+        requiredMethods.forEach((method) => {
+            if (!receivedMethods.includes(method)) {
+                missingMethods.push(method);
+            }
+        });
+        if (missingMethods.length > 0) {
+            this.clearState();
+            throw new errors_1.InvalidReceivedSessionNamespace('All methods must be approved', (0, utils_1.getSdkError)('USER_REJECTED_METHODS').code, 'incomplete', missingMethods);
+        }
+    }
+    validateEvents(requiredEvents, receivedEvents) {
+        const missingEvents = [];
+        requiredEvents.forEach((method) => {
+            if (!receivedEvents.includes(method)) {
+                missingEvents.push(method);
+            }
+        });
+        if (missingEvents.length > 0) {
+            this.clearState();
+            throw new errors_1.InvalidReceivedSessionNamespace('All events must be approved', (0, utils_1.getSdkError)('USER_REJECTED_EVENTS').code, 'incomplete', missingEvents);
+        }
+    }
+    validateAccounts(requiredNetwork, receivedAccounts) {
+        if (receivedAccounts.length === 0) {
+            this.clearState();
+            throw new errors_1.InvalidReceivedSessionNamespace('Accounts must not be empty', (0, utils_1.getSdkError)('USER_REJECTED_CHAINS').code, 'incomplete');
+        }
+        const receivedChains = [];
+        const invalidChains = [];
+        const missingChains = [];
+        const invalidChainsNamespace = [];
+        receivedAccounts.forEach((chain) => {
+            const accountId = chain.split(':');
+            if (accountId.length !== 3) {
+                invalidChains.push(chain);
+            }
+            if (accountId[0] !== TEZOS_PLACEHOLDER) {
+                invalidChainsNamespace.push(chain);
+            }
+            const network = accountId[1];
+            if (!receivedChains.includes(network)) {
+                receivedChains.push(network);
+            }
+        });
+        if (invalidChains.length > 0) {
+            this.clearState();
+            throw new errors_1.InvalidReceivedSessionNamespace('Accounts must be CAIP-10 compliant', (0, utils_1.getSdkError)('USER_REJECTED_CHAINS').code, 'invalid', invalidChains);
+        }
+        if (invalidChainsNamespace.length > 0) {
+            this.clearState();
+            throw new errors_1.InvalidReceivedSessionNamespace('Accounts must be defined in matching namespace', (0, utils_1.getSdkError)('UNSUPPORTED_ACCOUNTS').code, 'invalid', invalidChainsNamespace);
+        }
+        requiredNetwork.forEach((network) => {
+            if (!receivedChains.includes(network)) {
+                missingChains.push(network);
+            }
+        });
+        if (missingChains.length > 0) {
+            this.clearState();
+            throw new errors_1.InvalidReceivedSessionNamespace('All chains must have at least one account', (0, utils_1.getSdkError)('USER_REJECTED_CHAINS').code, 'incomplete', missingChains);
+        }
+    }
+    getTezosNamespace() {
+        if (TEZOS_PLACEHOLDER in this.getSession().namespaces) {
+            return this.getSession().namespaces[TEZOS_PLACEHOLDER];
+        }
+        else {
+            throw new errors_1.InvalidSession('Tezos not found in namespaces');
+        }
+    }
+    getTezosRequiredNamespace() {
+        if (TEZOS_PLACEHOLDER in this.getSession().requiredNamespaces) {
+            return this.getSession().requiredNamespaces[TEZOS_PLACEHOLDER];
+        }
+        else {
+            throw new errors_1.InvalidSession('Tezos not found in requiredNamespaces');
+        }
+    }
+    validateNetworkAndAccount(network, account) {
+        if (!this.getTezosNamespace().accounts.includes(`${TEZOS_PLACEHOLDER}:${network}:${account}`)) {
+            throw new errors_1.InvalidNetworkOrAccount(network, account);
+        }
+    }
+    getPermittedMethods() {
+        return this.getTezosRequiredNamespace().methods;
+    }
+    getPermittedNetwork() {
+        return this.getTezosRequiredNamespace().chains.map((chain) => chain.split(':')[1]);
+    }
+    formatParameters(params) {
+        const formatedParams = params;
+        if (typeof params.fee !== 'undefined') {
+            formatedParams.fee = params.fee.toString();
+        }
+        if (typeof params.storageLimit !== 'undefined') {
+            formatedParams.storageLimit = params.storageLimit.toString();
+        }
+        if (typeof params.gasLimit !== 'undefined') {
+            formatedParams.gasLimit = params.gasLimit.toString();
+        }
+        return formatedParams;
+    }
+    removeDefaultLimits(params, operatedParams) {
+        if (typeof params.fee === 'undefined') {
+            delete operatedParams.fee;
+        }
+        if (typeof params.storageLimit === 'undefined') {
+            delete operatedParams.storage_limit;
+        }
+        if (typeof params.gasLimit === 'undefined') {
+            delete operatedParams.gas_limit;
+        }
+        return operatedParams;
+    }
+    mapTransferParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletParams = yield params();
+            return this.removeDefaultLimits(walletParams, yield (0, taquito_1.createTransferOperation)(this.formatParameters(walletParams)));
+        });
+    }
+    mapTransferTicketParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletParams = yield params();
+            return this.removeDefaultLimits(walletParams, yield (0, taquito_1.createTransferTicketOperation)(this.formatParameters(walletParams)));
+        });
+    }
+    mapStakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletParams = yield params();
+            return this.removeDefaultLimits(walletParams, yield (0, taquito_1.createTransferOperation)(this.formatParameters(walletParams)));
+        });
+    }
+    mapUnstakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletParams = yield params();
+            return this.removeDefaultLimits(walletParams, yield (0, taquito_1.createTransferOperation)(this.formatParameters(walletParams)));
+        });
+    }
+    mapFinalizeUnstakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletParams = yield params();
+            return this.removeDefaultLimits(walletParams, yield (0, taquito_1.createTransferOperation)(this.formatParameters(walletParams)));
+        });
+    }
+    mapOriginateParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletParams = yield params();
+            return this.removeDefaultLimits(walletParams, yield (0, taquito_1.createOriginationOperation)(this.formatParameters(walletParams)));
+        });
+    }
+    mapDelegateParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletParams = yield params();
+            return this.removeDefaultLimits(walletParams, yield (0, taquito_1.createSetDelegateOperation)(this.formatParameters(walletParams)));
+        });
+    }
+    mapIncreasePaidStorageWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletParams = yield params();
+            return this.removeDefaultLimits(walletParams, yield (0, taquito_1.createIncreasePaidStorageOperation)(this.formatParameters(walletParams)));
+        });
+    }
+}
+exports.WalletConnect = WalletConnect;

package/dist/lib/types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SigningType = exports.PermissionScopeEvents = exports.PermissionScopeMethods = exports.NetworkType = void 0;
+var NetworkType;
+(function (NetworkType) {
+    NetworkType["MAINNET"] = "mainnet";
+    NetworkType["GHOSTNET"] = "ghostnet";
+    NetworkType["WEEKLYNET"] = "weeklynet";
+    NetworkType["OXFORDNET"] = "oxfordnet";
+    NetworkType["PARISNET"] = "parisnet";
+    // QUEBECNET = 'quebecnet',
+})(NetworkType || (exports.NetworkType = NetworkType = {}));
+var PermissionScopeMethods;
+(function (PermissionScopeMethods) {
+    PermissionScopeMethods["TEZOS_GET_ACCOUNTS"] = "tezos_getAccounts";
+    PermissionScopeMethods["TEZOS_SEND"] = "tezos_send";
+    PermissionScopeMethods["TEZOS_SIGN"] = "tezos_sign";
+})(PermissionScopeMethods || (exports.PermissionScopeMethods = PermissionScopeMethods = {}));
+var PermissionScopeEvents;
+(function (PermissionScopeEvents) {
+    PermissionScopeEvents["CHAIN_CHANGED"] = "chainChanged";
+    PermissionScopeEvents["ACCOUNTS_CHANGED"] = "accountsChanged";
+})(PermissionScopeEvents || (exports.PermissionScopeEvents = PermissionScopeEvents = {}));
+var SigningType;
+(function (SigningType) {
+    SigningType["RAW"] = "raw";
+    SigningType["OPERATION"] = "operation";
+    SigningType["MICHELINE"] = "micheline";
+})(SigningType || (exports.SigningType = SigningType = {}));

package/dist/lib/version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
+exports.VERSION = {
+    "commitHash": "3e5b607831fe4d2e3ec023b1648b84a890c0035e",
+    "version": "20.2.0-beta.0"
+};