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

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

@@ -3,38 +3,6 @@ import { WalletConnectModal } from '@walletconnect/modal';
 import { createTransferOperation, createTransferTicketOperation, createOriginationOperation, createSetDelegateOperation, createIncreasePaidStorageOperation, createRegisterGlobalConstantOperation } from '@taquito/taquito';
 import { getSdkError } from '@walletconnect/utils';
 
-/******************************************************************************
-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;
-};
-
 var NetworkType;
 (function (NetworkType) {
     NetworkType["MAINNET"] = "mainnet";
@@ -65,7 +33,7 @@ var SigningType;
 
 /**
  *  @category Error
- *  @description Error that indicates missing required permission scopes
+ *  Error that indicates missing required permission scopes
  */
 class MissingRequiredScope extends Error {
     constructor(requiredScopes) {
@@ -76,7 +44,7 @@ class MissingRequiredScope extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates the wallet returned an invalid namespace
+ *  Error that indicates the wallet returned an invalid namespace
  */
 class InvalidReceivedSessionNamespace extends Error {
     constructor(messageWc, codeWc, type, data) {
@@ -95,7 +63,7 @@ class InvalidReceivedSessionNamespace extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid session key being passed
+ *  Error that indicates an invalid session key being passed
  */
 class InvalidSessionKey extends Error {
     constructor(key) {
@@ -106,7 +74,7 @@ class InvalidSessionKey extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates the pkh is not part of the active accounts in the session
+ *  Error that indicates the pkh is not part of the active accounts in the session
  */
 class InvalidAccount extends Error {
     constructor(pkh) {
@@ -117,7 +85,7 @@ class InvalidAccount extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates the network is not part of the active networks in the session
+ *  Error that indicates the network is not part of the active networks in the session
  */
 class InvalidNetwork extends Error {
     constructor(network) {
@@ -128,7 +96,7 @@ class InvalidNetwork extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates the combinaison pkh-network is not part of the active session
+ *  Error that indicates the combinaison pkh-network is not part of the active session
  */
 class InvalidNetworkOrAccount extends Error {
     constructor(network, pkh) {
@@ -140,7 +108,7 @@ class InvalidNetworkOrAccount extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates the connection could not be established
+ *  Error that indicates the connection could not be established
  */
 class ConnectionFailed extends Error {
     constructor(originalError) {
@@ -151,7 +119,7 @@ class ConnectionFailed extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates there is no active session
+ *  Error that indicates there is no active session
  */
 class NotConnected extends Error {
     constructor() {
@@ -161,7 +129,7 @@ class NotConnected extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates the active account is not specified
+ *  Error that indicates the active account is not specified
  */
 class ActiveAccountUnspecified extends Error {
     constructor() {
@@ -171,7 +139,7 @@ class ActiveAccountUnspecified extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates the active network is not specified
+ *  Error that indicates the active network is not specified
  */
 class ActiveNetworkUnspecified extends Error {
     constructor() {
@@ -181,7 +149,7 @@ class ActiveNetworkUnspecified extends Error {
 }
 /**
  *  @category Error
- *  @description Error that indicates the session is invalid
+ *  Error that indicates the session is invalid
  */
 class InvalidSession extends Error {
     constructor(message) {
@@ -202,9 +170,9 @@ class PublicKeyRetrievalError extends Error {
  */
 const TEZOS_PLACEHOLDER = 'tezos';
 /**
- * @description The `WalletConnect` class implements the `WalletProvider` interface, providing an alternative to `BeaconWallet`.
+ * 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,
+ \* @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 {
@@ -212,20 +180,17 @@ class WalletConnect {
         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) {
+            if (this.session?.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) {
+            if (this.session?.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) {
+            if (this.session?.topic === topic) {
                 this.session.namespaces = params.namespaces;
                 // TODO determine if we need validation on the namespace here
             }
@@ -235,7 +200,7 @@ class WalletConnect {
         });
     }
     /**
-     * @description Initialize a WalletConnect provider
+     * Initialize a WalletConnect provider
      * (Initialize a WalletConnect client with persisted storage and a network connection)
      *
      * @example
@@ -251,77 +216,72 @@ class WalletConnect {
      * });
      * ```
      */
-    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 WalletConnectModal({
-                projectId: initParams.projectId,
-            });
-            return new WalletConnect(client, walletConnectModal);
+    static async init(initParams) {
+        if (!initParams.projectId) {
+            throw new Error('projectId is required');
+        }
+        const client = await Client.init(initParams);
+        const walletConnectModal = new WalletConnectModal({
+            projectId: initParams.projectId,
         });
+        return new WalletConnect(client, walletConnectModal);
     }
     /**
-     * @description Request permission for a new session and establish a connection.
+     * 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
+     \* @throws 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 : [],
-                        },
+    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,
+                },
+                pairingTopic: connectParams.pairingTopic,
+            });
+            if (uri) {
+                this.walletConnectModal.openModal({
+                    uri,
+                    chains,
                 });
-                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();
-        });
+            this.session = await 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
+     * Access all existing active pairings
      */
     getAvailablePairing() {
         return this.signClient.pairing.getAll({ active: true });
     }
     /**
-     * @description Access all existing sessions
+     * 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.
+     * 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
+     \* @throws InvalidSessionKey is thrown if the provided session key doesn't exist
      */
     configureWithExistingSessionKey(key) {
         const sessions = this.getAllExistingSessionKeys();
@@ -331,91 +291,85 @@ class WalletConnect {
         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: getSdkError('USER_DISCONNECTED'),
-                });
-                this.clearState();
-            }
-        });
+    async disconnect() {
+        if (this.session) {
+            await this.signClient.disconnect({
+                topic: this.session.topic,
+                reason: 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
+     * 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
      */
-    sendOperations(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const session = this.getSession();
-            if (!this.getPermittedMethods().includes(PermissionScopeMethods.TEZOS_SEND)) {
-                throw new MissingRequiredScope(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: PermissionScopeMethods.TEZOS_SEND,
-                    params: {
-                        account,
-                        operations: params,
-                    },
+    async sendOperations(params) {
+        const session = this.getSession();
+        if (!this.getPermittedMethods().includes(PermissionScopeMethods.TEZOS_SEND)) {
+            throw new MissingRequiredScope(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: PermissionScopeMethods.TEZOS_SEND,
+                params: {
+                    account,
+                    operations: params,
                 },
-            });
-            return operationHash;
+            },
         });
+        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
+     * 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
      */
-    sign(bytes, watermark) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const session = this.getSession();
-            if (!this.getPermittedMethods().includes(PermissionScopeMethods.TEZOS_SIGN)) {
-                throw new MissingRequiredScope(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: PermissionScopeMethods.TEZOS_SIGN,
-                    params: {
-                        account: yield this.getPKH(),
-                        payload: expression,
-                    },
+    async sign(bytes, watermark) {
+        const session = this.getSession();
+        if (!this.getPermittedMethods().includes(PermissionScopeMethods.TEZOS_SIGN)) {
+            throw new MissingRequiredScope(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: PermissionScopeMethods.TEZOS_SIGN,
+                params: {
+                    account: await this.getPKH(),
+                    payload: expression,
                 },
-            });
-            return signature;
+            },
         });
+        return signature;
     }
     /**
-     * @description Return all connected accounts from the active session
-     * @error NotConnected if no active session
+     * Return all connected accounts from the active session
+     \* @throws NotConnected if no active session
      */
     getAccounts() {
         return this.getTezosNamespace().accounts.map((account) => account.split(':')[2]);
     }
     /**
-     * @description Set the active account.
+     * 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
+     \* @throws InvalidAccount thrown if the pkh is not part of the active accounts in the session
      */
     setActiveAccount(pkh) {
         if (!this.getAccounts().includes(pkh)) {
@@ -424,59 +378,55 @@ class WalletConnect {
         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
+     * 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
      */
-    getPKH() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.activeAccount) {
-                this.getSession();
-                throw new ActiveAccountUnspecified();
-            }
-            return this.activeAccount;
-        });
+    async getPKH() {
+        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
+     * 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
      */
-    getPK() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const session = this.getSession();
-            if (!this.getPermittedMethods().includes(PermissionScopeMethods.TEZOS_GET_ACCOUNTS)) {
-                throw new MissingRequiredScope(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: PermissionScopeMethods.TEZOS_GET_ACCOUNTS,
-                    params: {},
-                },
-            });
-            const selectedAccount = accounts.find((acc) => acc.address === account);
-            if (!selectedAccount) {
-                throw new PublicKeyRetrievalError();
-            }
-            return selectedAccount.pubkey;
+    async getPK() {
+        const session = this.getSession();
+        if (!this.getPermittedMethods().includes(PermissionScopeMethods.TEZOS_GET_ACCOUNTS)) {
+            throw new MissingRequiredScope(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: 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
+     * Return all networks from the namespace of the active session
+     \* @throws NotConnected if no active session
      */
     getNetworks() {
         return this.getPermittedNetwork();
     }
     /**
-     * @description Set the active network.
+     * 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
+     \* @throws InvalidNetwork thrown if the network is not part of the active networks in the session
      */
     setActiveNetwork(network) {
         if (!this.getNetworks().includes(network)) {
@@ -485,8 +435,8 @@ class WalletConnect {
         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
+     * 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) {
@@ -653,59 +603,41 @@ class WalletConnect {
         }
         return operatedParams;
     }
-    mapTransferParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createTransferOperation(this.formatParameters(walletParams)));
-        });
+    async mapTransferParamsToWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createTransferOperation(this.formatParameters(walletParams)));
     }
-    mapTransferTicketParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createTransferTicketOperation(this.formatParameters(walletParams)));
-        });
+    async mapTransferTicketParamsToWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createTransferTicketOperation(this.formatParameters(walletParams)));
     }
-    mapStakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createTransferOperation(this.formatParameters(walletParams)));
-        });
+    async mapStakeParamsToWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createTransferOperation(this.formatParameters(walletParams)));
     }
-    mapUnstakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createTransferOperation(this.formatParameters(walletParams)));
-        });
+    async mapUnstakeParamsToWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createTransferOperation(this.formatParameters(walletParams)));
     }
-    mapFinalizeUnstakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createTransferOperation(this.formatParameters(walletParams)));
-        });
+    async mapFinalizeUnstakeParamsToWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createTransferOperation(this.formatParameters(walletParams)));
     }
-    mapOriginateParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createOriginationOperation(this.formatParameters(walletParams)));
-        });
+    async mapOriginateParamsToWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createOriginationOperation(this.formatParameters(walletParams)));
     }
-    mapDelegateParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createSetDelegateOperation(this.formatParameters(walletParams)));
-        });
+    async mapDelegateParamsToWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createSetDelegateOperation(this.formatParameters(walletParams)));
     }
-    mapIncreasePaidStorageWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createIncreasePaidStorageOperation(this.formatParameters(walletParams)));
-        });
+    async mapIncreasePaidStorageWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createIncreasePaidStorageOperation(this.formatParameters(walletParams)));
     }
-    mapRegisterGlobalConstantParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletParams = yield params();
-            return this.removeDefaultLimits(walletParams, yield createRegisterGlobalConstantOperation(this.formatParameters(walletParams)));
-        });
+    async mapRegisterGlobalConstantParamsToWalletParams(params) {
+        const walletParams = await params();
+        return this.removeDefaultLimits(walletParams, await createRegisterGlobalConstantOperation(this.formatParameters(walletParams)));
     }
 }
 

package/dist/taquito-wallet-connect.es6.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-wallet-connect.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-wallet-connect.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}