@taquito/wallet-connect 24.2.0 → 24.3.0-beta.0

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

@@ -1,728 +1,660 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@walletconnect/sign-client'), require('@walletconnect/modal'), require('@taquito/taquito'), require('@walletconnect/utils')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@walletconnect/sign-client', '@walletconnect/modal', '@taquito/taquito', '@walletconnect/utils'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoWalletConnect = {}, global.walletconnectSignClient, global.walletconnectModal, global.taquito, global.walletconnectUtils));
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@walletconnect/sign-client'), require('@walletconnect/modal'), require('@taquito/taquito'), require('@walletconnect/utils')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@walletconnect/sign-client', '@walletconnect/modal', '@taquito/taquito', '@walletconnect/utils'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoWalletConnect = {}, global.walletconnectSignClient, global.walletconnectModal, global.taquito, global.walletconnectUtils));
 })(this, (function (exports, Client, modal, taquito, utils) { 'use strict';
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-    function __awaiter(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());
-        });
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
+  exports.NetworkType = void 0;
+  (function (NetworkType) {
+      NetworkType["MAINNET"] = "mainnet";
+      NetworkType["GHOSTNET"] = "ghostnet";
+      NetworkType["SHADOWNET"] = "shadownet";
+      NetworkType["WEEKLYNET"] = "weeklynet";
+      NetworkType["TEZLINK_SHADOWNET"] = "tezlink_shadownet";
+      NetworkType["TALLINNNET"] = "tallinnnet";
+      NetworkType["CUSTOM"] = "custom";
+  })(exports.NetworkType || (exports.NetworkType = {}));
+  exports.PermissionScopeMethods = void 0;
+  (function (PermissionScopeMethods) {
+      PermissionScopeMethods["TEZOS_GET_ACCOUNTS"] = "tezos_getAccounts";
+      PermissionScopeMethods["TEZOS_SEND"] = "tezos_send";
+      PermissionScopeMethods["TEZOS_SIGN"] = "tezos_sign";
+  })(exports.PermissionScopeMethods || (exports.PermissionScopeMethods = {}));
+  exports.PermissionScopeEvents = void 0;
+  (function (PermissionScopeEvents) {
+      PermissionScopeEvents["CHAIN_CHANGED"] = "chainChanged";
+      PermissionScopeEvents["ACCOUNTS_CHANGED"] = "accountsChanged";
+  })(exports.PermissionScopeEvents || (exports.PermissionScopeEvents = {}));
+  exports.SigningType = void 0;
+  (function (SigningType) {
+      SigningType["RAW"] = "raw";
+      SigningType["OPERATION"] = "operation";
+      SigningType["MICHELINE"] = "micheline";
+  })(exports.SigningType || (exports.SigningType = {}));
 
-    exports.NetworkType = void 0;
-    (function (NetworkType) {
-        NetworkType["MAINNET"] = "mainnet";
-        NetworkType["GHOSTNET"] = "ghostnet";
-        NetworkType["SHADOWNET"] = "shadownet";
-        NetworkType["WEEKLYNET"] = "weeklynet";
-        NetworkType["TEZLINK_SHADOWNET"] = "tezlink_shadownet";
-        NetworkType["TALLINNNET"] = "tallinnnet";
-        NetworkType["CUSTOM"] = "custom";
-    })(exports.NetworkType || (exports.NetworkType = {}));
-    exports.PermissionScopeMethods = void 0;
-    (function (PermissionScopeMethods) {
-        PermissionScopeMethods["TEZOS_GET_ACCOUNTS"] = "tezos_getAccounts";
-        PermissionScopeMethods["TEZOS_SEND"] = "tezos_send";
-        PermissionScopeMethods["TEZOS_SIGN"] = "tezos_sign";
-    })(exports.PermissionScopeMethods || (exports.PermissionScopeMethods = {}));
-    exports.PermissionScopeEvents = void 0;
-    (function (PermissionScopeEvents) {
-        PermissionScopeEvents["CHAIN_CHANGED"] = "chainChanged";
-        PermissionScopeEvents["ACCOUNTS_CHANGED"] = "accountsChanged";
-    })(exports.PermissionScopeEvents || (exports.PermissionScopeEvents = {}));
-    exports.SigningType = void 0;
-    (function (SigningType) {
-        SigningType["RAW"] = "raw";
-        SigningType["OPERATION"] = "operation";
-        SigningType["MICHELINE"] = "micheline";
-    })(exports.SigningType || (exports.SigningType = {}));
+  /**
+   *  @category Error
+   *  Error that indicates missing required permission scopes
+   */
+  class MissingRequiredScope extends Error {
+      constructor(requiredScopes) {
+          super(`Required permission scope were not granted for "${requiredScopes}"`);
+          this.requiredScopes = requiredScopes;
+          this.name = 'MissingRequiredScope';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the wallet returned an invalid namespace
+   */
+  class InvalidReceivedSessionNamespace extends Error {
+      constructor(messageWc, codeWc, type, data) {
+          super();
+          this.messageWc = messageWc;
+          this.codeWc = codeWc;
+          this.data = data;
+          this.name = 'InvalidReceivedSessionNamespace';
+          const baseMessage = `${codeWc}: ${messageWc}.`;
+          this.message = data
+              ? type === 'incomplete'
+                  ? ` ${baseMessage} "${data}" is missing in the session namespace.`
+                  : ` ${baseMessage} "${data}" is invalid.`
+              : baseMessage;
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates an invalid session key being passed
+   */
+  class InvalidSessionKey extends Error {
+      constructor(key) {
+          super(`Invalid session key "${key}"`);
+          this.key = key;
+          this.name = 'InvalidSessionKey';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the pkh is not part of the active accounts in the session
+   */
+  class InvalidAccount extends Error {
+      constructor(pkh) {
+          super(`Invalid pkh "${pkh}"`);
+          this.pkh = pkh;
+          this.name = 'InvalidAccount';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the network is not part of the active networks in the session
+   */
+  class InvalidNetwork extends Error {
+      constructor(network) {
+          super(`Invalid network "${network}"`);
+          this.network = network;
+          this.name = 'InvalidNetwork';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the combinaison pkh-network is not part of the active session
+   */
+  class InvalidNetworkOrAccount extends Error {
+      constructor(network, pkh) {
+          super(`No permission. The combinaison "${network}" and "${pkh}" is not part of the active session.`);
+          this.network = network;
+          this.pkh = pkh;
+          this.name = 'InvalidNetworkOrAccount';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the connection could not be established
+   */
+  class ConnectionFailed extends Error {
+      constructor(originalError) {
+          super(`Unable to connect`);
+          this.originalError = originalError;
+          this.name = 'ConnectionFailed';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates there is no active session
+   */
+  class NotConnected extends Error {
+      constructor() {
+          super('Not connected, no active session');
+          this.name = 'NotConnected';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the active account is not specified
+   */
+  class ActiveAccountUnspecified extends Error {
+      constructor() {
+          super('Please specify the active account using the "setActiveAccount" method.');
+          this.name = 'ActiveAccountUnspecified';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the active network is not specified
+   */
+  class ActiveNetworkUnspecified extends Error {
+      constructor() {
+          super('Please specify the active network using the "setActiveNetwork" method.');
+          this.name = 'ActiveNetworkUnspecified';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the session is invalid
+   */
+  class InvalidSession extends Error {
+      constructor(message) {
+          super(message);
+          this.name = 'InvalidSession';
+      }
+  }
+  class PublicKeyRetrievalError extends Error {
+      constructor() {
+          super(`Unable to retrieve public key`);
+          this.name = 'PublicKeyRetrievalError';
+      }
+  }
 
-    /**
-     *  @category Error
-     *  @description Error that indicates missing required permission scopes
-     */
-    class MissingRequiredScope extends Error {
-        constructor(requiredScopes) {
-            super(`Required permission scope were not granted for "${requiredScopes}"`);
-            this.requiredScopes = requiredScopes;
-            this.name = 'MissingRequiredScope';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates the wallet returned an invalid namespace
-     */
-    class InvalidReceivedSessionNamespace extends Error {
-        constructor(messageWc, codeWc, type, data) {
-            super();
-            this.messageWc = messageWc;
-            this.codeWc = codeWc;
-            this.data = data;
-            this.name = 'InvalidReceivedSessionNamespace';
-            const baseMessage = `${codeWc}: ${messageWc}.`;
-            this.message = data
-                ? type === 'incomplete'
-                    ? ` ${baseMessage} "${data}" is missing in the session namespace.`
-                    : ` ${baseMessage} "${data}" is invalid.`
-                : baseMessage;
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates an invalid session key being passed
-     */
-    class InvalidSessionKey extends Error {
-        constructor(key) {
-            super(`Invalid session key "${key}"`);
-            this.key = key;
-            this.name = 'InvalidSessionKey';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates the pkh is not part of the active accounts in the session
-     */
-    class InvalidAccount extends Error {
-        constructor(pkh) {
-            super(`Invalid pkh "${pkh}"`);
-            this.pkh = pkh;
-            this.name = 'InvalidAccount';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates the network is not part of the active networks in the session
-     */
-    class InvalidNetwork extends Error {
-        constructor(network) {
-            super(`Invalid network "${network}"`);
-            this.network = network;
-            this.name = 'InvalidNetwork';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates the combinaison pkh-network is not part of the active session
-     */
-    class InvalidNetworkOrAccount extends Error {
-        constructor(network, pkh) {
-            super(`No permission. The combinaison "${network}" and "${pkh}" is not part of the active session.`);
-            this.network = network;
-            this.pkh = pkh;
-            this.name = 'InvalidNetworkOrAccount';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates the connection could not be established
-     */
-    class ConnectionFailed extends Error {
-        constructor(originalError) {
-            super(`Unable to connect`);
-            this.originalError = originalError;
-            this.name = 'ConnectionFailed';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates there is no active session
-     */
-    class NotConnected extends Error {
-        constructor() {
-            super('Not connected, no active session');
-            this.name = 'NotConnected';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates the active account is not specified
-     */
-    class ActiveAccountUnspecified extends Error {
-        constructor() {
-            super('Please specify the active account using the "setActiveAccount" method.');
-            this.name = 'ActiveAccountUnspecified';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates the active network is not specified
-     */
-    class ActiveNetworkUnspecified extends Error {
-        constructor() {
-            super('Please specify the active network using the "setActiveNetwork" method.');
-            this.name = 'ActiveNetworkUnspecified';
-        }
-    }
-    /**
-     *  @category Error
-     *  @description Error that indicates the session is invalid
-     */
-    class InvalidSession extends Error {
-        constructor(message) {
-            super(message);
-            this.name = 'InvalidSession';
-        }
-    }
-    class PublicKeyRetrievalError extends Error {
-        constructor() {
-            super(`Unable to retrieve public key`);
-            this.name = 'PublicKeyRetrievalError';
-        }
-    }
+  /**
+   * @packageDocumentation
+   * @module @taquito/wallet-connect
+   */
+  const TEZOS_PLACEHOLDER = 'tezos';
+  /**
+   * 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.
+   \* @remarks 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, WalletConnectModal) {
+          this.signClient = signClient;
+          this.walletConnectModal = WalletConnectModal;
+          this.signClient.on('session_delete', ({ topic }) => {
+              if (this.session?.topic === topic) {
+                  this.session = undefined;
+              }
+          });
+          this.signClient.on('session_expire', ({ topic }) => {
+              if (this.session?.topic === topic) {
+                  this.session = undefined;
+              }
+          });
+          this.signClient.on('session_update', ({ params, topic }) => {
+              if (this.session?.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.
+          });
+      }
+      /**
+       * 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 async init(initParams) {
+          if (!initParams.projectId) {
+              throw new Error('projectId is required');
+          }
+          const client = await Client.init(initParams);
+          const walletConnectModal = new modal.WalletConnectModal({
+              projectId: initParams.projectId,
+          });
+          return new WalletConnect(client, walletConnectModal);
+      }
+      /**
+       * 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
+       \* @throws ConnectionFailed is thrown if no connection can be established with a wallet
+       */
+      async requestPermissions(connectParams) {
+          // TODO when Tezos wallets will officially support wallet connect, we need to provide a default value for registryUrl
+          try {
+              const chains = connectParams.permissionScope.networks.map((network) => `${TEZOS_PLACEHOLDER}:${network}`);
+              const { uri, approval } = await this.signClient.connect({
+                  requiredNamespaces: {
+                      [TEZOS_PLACEHOLDER]: {
+                          chains,
+                          methods: connectParams.permissionScope.methods,
+                          events: connectParams.permissionScope.events ?? [],
+                      },
+                  },
+                  pairingTopic: connectParams.pairingTopic,
+              });
+              if (uri) {
+                  this.walletConnectModal.openModal({
+                      uri,
+                      chains,
+                  });
+              }
+              this.session = await approval();
+          }
+          catch (error) {
+              throw new ConnectionFailed(error);
+          }
+          finally {
+              this.walletConnectModal.closeModal();
+          }
+          this.validateReceivedNamespace(connectParams.permissionScope, this.session.namespaces);
+          this.setDefaultAccountAndNetwork();
+      }
+      /**
+       * Access all existing active pairings
+       */
+      getAvailablePairing() {
+          return this.signClient.pairing.getAll({ active: true });
+      }
+      /**
+       * Access all existing sessions
+       * @return an array of strings which represent the session keys
+       */
+      getAllExistingSessionKeys() {
+          return this.signClient.session.keys;
+      }
+      /**
+       * Configure the Client with an existing session.
+       * The session is immediately restored without a prompt on the wallet to accept/decline it.
+       \* @throws InvalidSessionKey is thrown if the provided session key doesn't exist
+       */
+      configureWithExistingSessionKey(key) {
+          const sessions = this.getAllExistingSessionKeys();
+          if (!sessions.includes(key)) {
+              throw new InvalidSessionKey(key);
+          }
+          this.session = this.signClient.session.get(key);
+          this.setDefaultAccountAndNetwork();
+      }
+      async disconnect() {
+          if (this.session) {
+              await this.signClient.disconnect({
+                  topic: this.session.topic,
+                  reason: utils.getSdkError('USER_DISCONNECTED'),
+              });
+              this.clearState();
+          }
+      }
+      getPeerMetadata() {
+          return this.getSession().peer.metadata;
+      }
+      /**
+       * Once the session is establish, send Tezos operations to be approved, signed and inject by the wallet.
+       \* @throws MissingRequiredScope is thrown if permission to send operation was not granted
+       */
+      async sendOperations(params) {
+          const session = this.getSession();
+          if (!this.getPermittedMethods().includes(exports.PermissionScopeMethods.TEZOS_SEND)) {
+              throw new MissingRequiredScope(exports.PermissionScopeMethods.TEZOS_SEND);
+          }
+          const network = this.getActiveNetwork();
+          const account = await this.getPKH();
+          this.validateNetworkAndAccount(network, account);
+          const { operationHash } = await this.signClient.request({
+              topic: session.topic,
+              chainId: `${TEZOS_PLACEHOLDER}:${network}`,
+              request: {
+                  method: exports.PermissionScopeMethods.TEZOS_SEND,
+                  params: {
+                      account,
+                      operations: params,
+                  },
+              },
+          });
+          return operationHash;
+      }
+      /**
+       * Once the session is establish, send payload to be signed by the wallet.
+       \* @throws MissingRequiredScope is thrown if permission to sign payload was not granted
+       */
+      async sign(bytes, watermark) {
+          const session = this.getSession();
+          if (!this.getPermittedMethods().includes(exports.PermissionScopeMethods.TEZOS_SIGN)) {
+              throw new MissingRequiredScope(exports.PermissionScopeMethods.TEZOS_SIGN);
+          }
+          const network = this.getActiveNetwork();
+          const account = await 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 } = await this.signClient.request({
+              topic: session.topic,
+              chainId: `${TEZOS_PLACEHOLDER}:${network}`,
+              request: {
+                  method: exports.PermissionScopeMethods.TEZOS_SIGN,
+                  params: {
+                      account: await this.getPKH(),
+                      payload: expression,
+                  },
+              },
+          });
+          return signature;
+      }
+      /**
+       * Return all connected accounts from the active session
+       \* @throws NotConnected if no active session
+       */
+      getAccounts() {
+          return this.getTezosNamespace().accounts.map((account) => account.split(':')[2]);
+      }
+      /**
+       * 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
+       \* @throws InvalidAccount thrown if the pkh is not part of the active accounts in the session
+       */
+      setActiveAccount(pkh) {
+          if (!this.getAccounts().includes(pkh)) {
+              throw new InvalidAccount(pkh);
+          }
+          this.activeAccount = pkh;
+      }
+      /**
+       * Access the public key hash of the active account
+       \* @throws ActiveAccountUnspecified thrown when there are multiple Tezos account in the session and none is set as the active one
+       */
+      async getPKH() {
+          if (!this.activeAccount) {
+              this.getSession();
+              throw new ActiveAccountUnspecified();
+          }
+          return this.activeAccount;
+      }
+      /**
+       * Access the public key of the active account
+       \* @throws ActiveAccountUnspecified thrown when there are multiple Tezos account in the session and none is set as the active one
+       \* @throws MissingRequiredScope is thrown if permission to get accounts was not granted
+       \* @throws PublicKeyRetrievalError is thrown if the public key is not found
+       */
+      async getPK() {
+          const session = this.getSession();
+          if (!this.getPermittedMethods().includes(exports.PermissionScopeMethods.TEZOS_GET_ACCOUNTS)) {
+              throw new MissingRequiredScope(exports.PermissionScopeMethods.TEZOS_GET_ACCOUNTS);
+          }
+          const network = this.getActiveNetwork();
+          const account = await this.getPKH();
+          const accounts = await this.signClient.request({
+              topic: session.topic,
+              chainId: `${TEZOS_PLACEHOLDER}:${network}`,
+              request: {
+                  method: exports.PermissionScopeMethods.TEZOS_GET_ACCOUNTS,
+                  params: {},
+              },
+          });
+          const selectedAccount = accounts.find((acc) => acc.address === account);
+          if (!selectedAccount) {
+              throw new PublicKeyRetrievalError();
+          }
+          return selectedAccount.pubkey;
+      }
+      /**
+       * Return all networks from the namespace of the active session
+       \* @throws NotConnected if no active session
+       */
+      getNetworks() {
+          return this.getPermittedNetwork();
+      }
+      /**
+       * 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
+       \* @throws InvalidNetwork thrown if the network is not part of the active networks in the session
+       */
+      setActiveNetwork(network) {
+          if (!this.getNetworks().includes(network)) {
+              throw new InvalidNetwork(network);
+          }
+          this.activeNetwork = network;
+      }
+      /**
+       * Access the active network
+       \* @throws 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 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 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 InvalidReceivedSessionNamespace('All namespaces must be approved', utils.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 InvalidReceivedSessionNamespace('All methods must be approved', utils.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 InvalidReceivedSessionNamespace('All events must be approved', utils.getSdkError('USER_REJECTED_EVENTS').code, 'incomplete', missingEvents);
+          }
+      }
+      validateAccounts(requiredNetwork, receivedAccounts) {
+          if (receivedAccounts.length === 0) {
+              this.clearState();
+              throw new InvalidReceivedSessionNamespace('Accounts must not be empty', utils.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 InvalidReceivedSessionNamespace('Accounts must be CAIP-10 compliant', utils.getSdkError('USER_REJECTED_CHAINS').code, 'invalid', invalidChains);
+          }
+          if (invalidChainsNamespace.length > 0) {
+              this.clearState();
+              throw new InvalidReceivedSessionNamespace('Accounts must be defined in matching namespace', utils.getSdkError('UNSUPPORTED_ACCOUNTS').code, 'invalid', invalidChainsNamespace);
+          }
+          requiredNetwork.forEach((network) => {
+              if (!receivedChains.includes(network)) {
+                  missingChains.push(network);
+              }
+          });
+          if (missingChains.length > 0) {
+              this.clearState();
+              throw new InvalidReceivedSessionNamespace('All chains must have at least one account', utils.getSdkError('USER_REJECTED_CHAINS').code, 'incomplete', missingChains);
+          }
+      }
+      getTezosNamespace() {
+          if (TEZOS_PLACEHOLDER in this.getSession().namespaces) {
+              return this.getSession().namespaces[TEZOS_PLACEHOLDER];
+          }
+          else {
+              throw new InvalidSession('Tezos not found in namespaces');
+          }
+      }
+      getTezosRequiredNamespace() {
+          if (TEZOS_PLACEHOLDER in this.getSession().requiredNamespaces) {
+              return this.getSession().requiredNamespaces[TEZOS_PLACEHOLDER];
+          }
+          else {
+              throw new InvalidSession('Tezos not found in requiredNamespaces');
+          }
+      }
+      validateNetworkAndAccount(network, account) {
+          if (!this.getTezosNamespace().accounts.includes(`${TEZOS_PLACEHOLDER}:${network}:${account}`)) {
+              throw new 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;
+      }
+      async mapTransferParamsToWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createTransferOperation(this.formatParameters(walletParams)));
+      }
+      async mapTransferTicketParamsToWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createTransferTicketOperation(this.formatParameters(walletParams)));
+      }
+      async mapStakeParamsToWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createTransferOperation(this.formatParameters(walletParams)));
+      }
+      async mapUnstakeParamsToWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createTransferOperation(this.formatParameters(walletParams)));
+      }
+      async mapFinalizeUnstakeParamsToWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createTransferOperation(this.formatParameters(walletParams)));
+      }
+      async mapOriginateParamsToWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createOriginationOperation(this.formatParameters(walletParams)));
+      }
+      async mapDelegateParamsToWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createSetDelegateOperation(this.formatParameters(walletParams)));
+      }
+      async mapIncreasePaidStorageWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createIncreasePaidStorageOperation(this.formatParameters(walletParams)));
+      }
+      async mapRegisterGlobalConstantParamsToWalletParams(params) {
+          const walletParams = await params();
+          return this.removeDefaultLimits(walletParams, await taquito.createRegisterGlobalConstantOperation(this.formatParameters(walletParams)));
+      }
+  }
 
-    /**
-     * @packageDocumentation
-     * @module @taquito/wallet-connect
-     */
-    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, WalletConnectModal) {
-            this.signClient = signClient;
-            this.walletConnectModal = WalletConnectModal;
-            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* () {
-                if (!initParams.projectId) {
-                    throw new Error('projectId is required');
-                }
-                const client = yield Client.init(initParams);
-                const walletConnectModal = new modal.WalletConnectModal({
-                    projectId: initParams.projectId,
-                });
-                return new WalletConnect(client, walletConnectModal);
-            });
-        }
-        /**
-         * @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 chains = connectParams.permissionScope.networks.map((network) => `${TEZOS_PLACEHOLDER}:${network}`);
-                    const { uri, approval } = yield this.signClient.connect({
-                        requiredNamespaces: {
-                            [TEZOS_PLACEHOLDER]: {
-                                chains,
-                                methods: connectParams.permissionScope.methods,
-                                events: (_a = connectParams.permissionScope.events) !== null && _a !== void 0 ? _a : [],
-                            },
-                        },
-                        pairingTopic: connectParams.pairingTopic,
-                    });
-                    if (uri) {
-                        this.walletConnectModal.openModal({
-                            uri,
-                            chains,
-                        });
-                    }
-                    this.session = yield approval();
-                }
-                catch (error) {
-                    throw new ConnectionFailed(error);
-                }
-                finally {
-                    this.walletConnectModal.closeModal();
-                }
-                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 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: utils.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(exports.PermissionScopeMethods.TEZOS_SEND)) {
-                    throw new MissingRequiredScope(exports.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: exports.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(exports.PermissionScopeMethods.TEZOS_SIGN)) {
-                    throw new MissingRequiredScope(exports.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: exports.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 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 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(exports.PermissionScopeMethods.TEZOS_GET_ACCOUNTS)) {
-                    throw new MissingRequiredScope(exports.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: exports.PermissionScopeMethods.TEZOS_GET_ACCOUNTS,
-                        params: {},
-                    },
-                });
-                const selectedAccount = accounts.find((acc) => acc.address === account);
-                if (!selectedAccount) {
-                    throw new 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 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 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 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 InvalidReceivedSessionNamespace('All namespaces must be approved', utils.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 InvalidReceivedSessionNamespace('All methods must be approved', utils.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 InvalidReceivedSessionNamespace('All events must be approved', utils.getSdkError('USER_REJECTED_EVENTS').code, 'incomplete', missingEvents);
-            }
-        }
-        validateAccounts(requiredNetwork, receivedAccounts) {
-            if (receivedAccounts.length === 0) {
-                this.clearState();
-                throw new InvalidReceivedSessionNamespace('Accounts must not be empty', utils.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 InvalidReceivedSessionNamespace('Accounts must be CAIP-10 compliant', utils.getSdkError('USER_REJECTED_CHAINS').code, 'invalid', invalidChains);
-            }
-            if (invalidChainsNamespace.length > 0) {
-                this.clearState();
-                throw new InvalidReceivedSessionNamespace('Accounts must be defined in matching namespace', utils.getSdkError('UNSUPPORTED_ACCOUNTS').code, 'invalid', invalidChainsNamespace);
-            }
-            requiredNetwork.forEach((network) => {
-                if (!receivedChains.includes(network)) {
-                    missingChains.push(network);
-                }
-            });
-            if (missingChains.length > 0) {
-                this.clearState();
-                throw new InvalidReceivedSessionNamespace('All chains must have at least one account', utils.getSdkError('USER_REJECTED_CHAINS').code, 'incomplete', missingChains);
-            }
-        }
-        getTezosNamespace() {
-            if (TEZOS_PLACEHOLDER in this.getSession().namespaces) {
-                return this.getSession().namespaces[TEZOS_PLACEHOLDER];
-            }
-            else {
-                throw new InvalidSession('Tezos not found in namespaces');
-            }
-        }
-        getTezosRequiredNamespace() {
-            if (TEZOS_PLACEHOLDER in this.getSession().requiredNamespaces) {
-                return this.getSession().requiredNamespaces[TEZOS_PLACEHOLDER];
-            }
-            else {
-                throw new InvalidSession('Tezos not found in requiredNamespaces');
-            }
-        }
-        validateNetworkAndAccount(network, account) {
-            if (!this.getTezosNamespace().accounts.includes(`${TEZOS_PLACEHOLDER}:${network}:${account}`)) {
-                throw new 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 taquito.createTransferOperation(this.formatParameters(walletParams)));
-            });
-        }
-        mapTransferTicketParamsToWalletParams(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const walletParams = yield params();
-                return this.removeDefaultLimits(walletParams, yield taquito.createTransferTicketOperation(this.formatParameters(walletParams)));
-            });
-        }
-        mapStakeParamsToWalletParams(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const walletParams = yield params();
-                return this.removeDefaultLimits(walletParams, yield taquito.createTransferOperation(this.formatParameters(walletParams)));
-            });
-        }
-        mapUnstakeParamsToWalletParams(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const walletParams = yield params();
-                return this.removeDefaultLimits(walletParams, yield taquito.createTransferOperation(this.formatParameters(walletParams)));
-            });
-        }
-        mapFinalizeUnstakeParamsToWalletParams(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const walletParams = yield params();
-                return this.removeDefaultLimits(walletParams, yield taquito.createTransferOperation(this.formatParameters(walletParams)));
-            });
-        }
-        mapOriginateParamsToWalletParams(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const walletParams = yield params();
-                return this.removeDefaultLimits(walletParams, yield taquito.createOriginationOperation(this.formatParameters(walletParams)));
-            });
-        }
-        mapDelegateParamsToWalletParams(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const walletParams = yield params();
-                return this.removeDefaultLimits(walletParams, yield taquito.createSetDelegateOperation(this.formatParameters(walletParams)));
-            });
-        }
-        mapIncreasePaidStorageWalletParams(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const walletParams = yield params();
-                return this.removeDefaultLimits(walletParams, yield taquito.createIncreasePaidStorageOperation(this.formatParameters(walletParams)));
-            });
-        }
-        mapRegisterGlobalConstantParamsToWalletParams(params) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const walletParams = yield params();
-                return this.removeDefaultLimits(walletParams, yield taquito.createRegisterGlobalConstantOperation(this.formatParameters(walletParams)));
-            });
-        }
-    }
-
-    exports.ActiveAccountUnspecified = ActiveAccountUnspecified;
-    exports.ActiveNetworkUnspecified = ActiveNetworkUnspecified;
-    exports.ConnectionFailed = ConnectionFailed;
-    exports.InvalidAccount = InvalidAccount;
-    exports.InvalidNetwork = InvalidNetwork;
-    exports.InvalidNetworkOrAccount = InvalidNetworkOrAccount;
-    exports.InvalidReceivedSessionNamespace = InvalidReceivedSessionNamespace;
-    exports.InvalidSession = InvalidSession;
-    exports.InvalidSessionKey = InvalidSessionKey;
-    exports.MissingRequiredScope = MissingRequiredScope;
-    exports.NotConnected = NotConnected;
-    exports.PublicKeyRetrievalError = PublicKeyRetrievalError;
-    exports.WalletConnect = WalletConnect;
+  exports.ActiveAccountUnspecified = ActiveAccountUnspecified;
+  exports.ActiveNetworkUnspecified = ActiveNetworkUnspecified;
+  exports.ConnectionFailed = ConnectionFailed;
+  exports.InvalidAccount = InvalidAccount;
+  exports.InvalidNetwork = InvalidNetwork;
+  exports.InvalidNetworkOrAccount = InvalidNetworkOrAccount;
+  exports.InvalidReceivedSessionNamespace = InvalidReceivedSessionNamespace;
+  exports.InvalidSession = InvalidSession;
+  exports.InvalidSessionKey = InvalidSessionKey;
+  exports.MissingRequiredScope = MissingRequiredScope;
+  exports.NotConnected = NotConnected;
+  exports.PublicKeyRetrievalError = PublicKeyRetrievalError;
+  exports.WalletConnect = WalletConnect;
 
 }));
 //# sourceMappingURL=taquito-wallet-connect.umd.js.map