@taquito/rpc 24.2.0 → 24.3.0-beta.0

package/dist/taquito-rpc.es6.js

@@ -3,50 +3,6 @@ import BigNumber from 'bignumber.js';
 import { validateAddress, ValidationResult, validateContractAddress, validateProtocol, InvalidProtocolHashError } from '@taquito/utils';
 import { InvalidAddressError, InvalidContractAddressError } from '@taquito/core';
 
-/******************************************************************************
-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 __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-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;
-};
-
 const defaultChain = 'main';
 const defaultRPCOptions = { block: 'head' };
 var RPCMethodName;
@@ -101,6 +57,7 @@ var RPCMethodName;
     RPCMethodName["GET_ALL_TICKET_BALANCES"] = "getAllTicketBalances";
     RPCMethodName["GET_ADAPTIVE_ISSUANCE_LAUNCH_CYCLE"] = "getAdaptiveIssuanceLaunchCycle";
     RPCMethodName["GET_PENDING_OPERATIONS"] = "getPendingOperations";
+    RPCMethodName["GET_MEMPOOL_FILTER"] = "getMempoolFilter";
     RPCMethodName["GET_DESTINATION_INDEX"] = "getDestinationIndex";
 })(RPCMethodName || (RPCMethodName = {}));
 
@@ -135,7 +92,7 @@ function castToBigNumber(data, keys) {
 
 const defaultTtl = 1000;
 /***
- * @description RpcClientCache acts as a decorator over the RpcClient instance by caching responses for the period defined by the ttl.
+ * RpcClientCache acts as a decorator over the RpcClient instance by caching responses for the period defined by the ttl.
  */
 class RpcClientCache {
     /**
@@ -154,7 +111,7 @@ class RpcClientCache {
         return this._cache;
     }
     /**
-     * @description Remove all the data in the cache.
+     * Remove all the data in the cache.
      *
      */
     deleteAllCachedData() {
@@ -205,819 +162,737 @@ class RpcClientCache {
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Get the block's hash, its unique identifier.
+     * Get the block's hash, its unique identifier.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-hash
      */
-    getBlockHash() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BLOCK_HASH, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBlockHash({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBlockHash({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BLOCK_HASH, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBlockHash({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description List the ancestors of the given block which, if referred to as the branch in an operation header, are recent enough for that operation to be included in the current block.
+     * List the ancestors of the given block which, if referred to as the branch in an operation header, are recent enough for that operation to be included in the current block.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-live-blocks
      */
-    getLiveBlocks() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_LIVE_BLOCKS, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getLiveBlocks({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getLiveBlocks({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_LIVE_BLOCKS, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getLiveBlocks({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve the spendable balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'spendable' RPC.
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'spendable' RPC.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-balance
      */
-    getBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BALANCE, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBalance(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BALANCE, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBalance(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve the balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'balance' RPC.
-     */
-    getSpendable(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SPENDABLE, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getSpendable(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'balance' RPC.
+     */
+    async getSpendable(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SPENDABLE, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getSpendable(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve balance and frozen bonds
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds to the contract's full balance from which staked funds and unstake requests have been excluded. Identical to the 'spendable_and_frozen_bonds' RPC.
+     * The sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds to the contract's full balance from which staked funds and unstake requests have been excluded. Identical to the 'spendable_and_frozen_bonds' RPC.
      */
-    getBalanceAndFrozenBonds(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BALANCE_AND_FROZEN_BONDS, [block, address]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBalanceAndFrozenBonds(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBalanceAndFrozenBonds(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BALANCE_AND_FROZEN_BONDS, [block, address]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBalanceAndFrozenBonds(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve spendable and frozen bonds
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds to the contract's full balance from which staked funds and unstake requests have been excluded. Identical to the 'balance_and_frozen_bonds' RPC.
+     * The sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds to the contract's full balance from which staked funds and unstake requests have been excluded. Identical to the 'balance_and_frozen_bonds' RPC.
      */
-    getSpendableAndFrozenBonds(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SPENDABLE_AND_FROZEN_BONDS, [block, address]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getSpendableAndFrozenBonds(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getSpendableAndFrozenBonds(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SPENDABLE_AND_FROZEN_BONDS, [block, address]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getSpendableAndFrozenBonds(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve the full balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the full balance of a contract, including frozen bonds and stake.
+     * Access the full balance of a contract, including frozen bonds and stake.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-full-balance
      */
-    getFullBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_FULL_BALANCE, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getFullBalance(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getFullBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_FULL_BALANCE, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getFullBalance(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve the staked balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the staked balance of a contract. Returns None if the contract is originated, or neither delegated nor a delegate.
+     * Access the staked balance of a contract. Returns None if the contract is originated, or neither delegated nor a delegate.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-staked-balance
      */
-    getStakedBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_STAKED_BALANCE, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getStakedBalance(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getStakedBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_STAKED_BALANCE, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getStakedBalance(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve the unstaked finalizable balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the balance of a contract that was requested for an unstake operation, and is no longer frozen, which means it will appear in the spendable balance of the contract after any stake/unstake/finalize_unstake operation. Returns None if the contract is originated.
+     * Access the balance of a contract that was requested for an unstake operation, and is no longer frozen, which means it will appear in the spendable balance of the contract after any stake/unstake/finalize_unstake operation. Returns None if the contract is originated.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-unstaked-finalizable-balance
      */
-    getUnstakedFinalizableBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_UNSTAKED_FINALIZABLE_BALANCE, [block, address]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getUnstakedFinalizableBalance(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getUnstakedFinalizableBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_UNSTAKED_FINALIZABLE_BALANCE, [block, address]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getUnstakedFinalizableBalance(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve the unstaked frozen balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the balance of a contract that was requested for an unstake operation, but is still frozen for the duration of the slashing period. Returns None if the contract is originated.
+     * Access the balance of a contract that was requested for an unstake operation, but is still frozen for the duration of the slashing period. Returns None if the contract is originated.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-unstaked-frozen-balance
      */
-    getUnstakedFrozenBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_UNSTAKED_FROZEN_BALANCE, [block, address]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getUnstakedFrozenBalance(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getUnstakedFrozenBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_UNSTAKED_FROZEN_BALANCE, [block, address]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getUnstakedFrozenBalance(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address address from which we want to retrieve the unstake requests
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the unstake requests of the contract. The requests that appear in the finalizable field can be finalized, which means that the contract can transfer these (no longer frozen) funds to their spendable balance with a [finalize_unstake] operation call. Returns null if there is no unstake request pending.
+     * Access the unstake requests of the contract. The requests that appear in the finalizable field can be finalized, which means that the contract can transfer these (no longer frozen) funds to their spendable balance with a [finalize_unstake] operation call. Returns null if there is no unstake request pending.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-unstake-requests
      */
-    getUnstakeRequests(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_UNSTAKE_REQUESTS, [block, address]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getUnstakeRequests(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getUnstakeRequests(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_UNSTAKE_REQUESTS, [block, address]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getUnstakeRequests(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address contract address from which we want to retrieve the storage
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the data of the contract.
+     * Access the data of the contract.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-storage
      */
-    getStorage(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateContract(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_STORAGE, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getStorage(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getStorage(address, { block } = defaultRPCOptions) {
+        this.validateContract(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_STORAGE, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getStorage(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address contract address from which we want to retrieve the script
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the code and data of the contract.
+     * Access the code and data of the contract.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-script
      */
-    getScript(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateContract(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SCRIPT, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getScript(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getScript(address, { block } = defaultRPCOptions) {
+        this.validateContract(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SCRIPT, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getScript(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address contract address from which we want to retrieve the script
      * @param unparsingMode default is { unparsing_mode: "Readable" }
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the script of the contract and normalize it using the requested unparsing mode.
+     * Access the script of the contract and normalize it using the requested unparsing mode.
      */
-    getNormalizedScript(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, unparsingMode = { unparsing_mode: 'Readable' }, { block } = defaultRPCOptions) {
-            this.validateContract(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_NORMALIZED_SCRIPT, [block, address], unparsingMode);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getNormalizedScript(address, unparsingMode, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getNormalizedScript(address, unparsingMode = { unparsing_mode: 'Readable' }, { block } = defaultRPCOptions) {
+        this.validateContract(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_NORMALIZED_SCRIPT, [block, address], unparsingMode);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getNormalizedScript(address, unparsingMode, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address contract address from which we want to retrieve
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the complete status of a contract.
+     * Access the complete status of a contract.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id
      */
-    getContract(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CONTRACT, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getContract(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getContract(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CONTRACT, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getContract(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address contract address from which we want to retrieve the manager
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the manager of an implicit contract
+     * Access the manager of an implicit contract
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-manager-key
      */
-    getManagerKey(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_MANAGER_KEY, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getManagerKey(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getManagerKey(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_MANAGER_KEY, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getManagerKey(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address contract address from which we want to retrieve the delegate (baker)
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the delegate of a contract, if any
+     * Access the delegate of a contract, if any
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-delegate
      */
-    getDelegate(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_DELEGATE, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getDelegate(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getDelegate(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_DELEGATE, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getDelegate(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param id Big Map ID
      * @param expr Expression hash to query (A b58check encoded Blake2b hash of the expression (The expression can be packed using the pack_data method))
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the value associated with a key in a big map.
+     * Access the value associated with a key in a big map.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-big-maps-big-map-id-script-expr
      */
-    getBigMapExpr(id_1, expr_1) {
-        return __awaiter(this, arguments, void 0, function* (id, expr, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BIG_MAP_EXPR, [
-                block,
-                id,
-                expr,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBigMapExpr(id, expr, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBigMapExpr(id, expr, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BIG_MAP_EXPR, [
+            block,
+            id,
+            expr,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBigMapExpr(id, expr, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param args contains optional query arguments (active, inactive, with_minimal_stake, without_minimal_stake)
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Lists all registered delegates by default with query arguments to filter unneeded values.
+     * Lists all registered delegates by default with query arguments to filter unneeded values.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh
      */
-    getAllDelegates() {
-        return __awaiter(this, arguments, void 0, function* (args = {}, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ALL_DELEGATES, [
-                block,
-                args,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getAllDelegates(args, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getAllDelegates(args = {}, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ALL_DELEGATES, [
+            block,
+            args,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getAllDelegates(args, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address delegate address which we want to retrieve
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Everything about a delegate
+     * Everything about a delegate
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh
      */
-    getDelegates(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_DELEGATES, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getDelegates(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getDelegates(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_DELEGATES, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getDelegates(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param address delegate address which we want to retrieve
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the delegate info (e.g. voting power) found in the listings of the current voting period
+     * Returns the delegate info (e.g. voting power) found in the listings of the current voting period
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh-voting-info
      */
-    getVotingInfo(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_VOTING_INFO, [
-                block,
-                address,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getVotingInfo(address, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getVotingInfo(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_VOTING_INFO, [
+            block,
+            address,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getVotingInfo(address, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description All constants
+     * All constants
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-constants
      */
-    getConstants() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CONSTANTS, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getConstants({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getConstants({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CONSTANTS, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getConstants({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head) and version.
-     * @description All the information about a block
+     * All the information about a block
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id
      * @example getBlock() will default to `/main/chains/block/head?version=1`
      * @example getBlock({ block: 'head~2') will return an offset of 2 from head blocks
      * @example getBlock({ block: 'BL8fTiWcSxWCjiMVnDkbh6EuhqVPZzgWheJ2dqwrxYRm9AephXh~2' }) will return an offset of 2 blocks from given block hash..
      */
-    getBlock() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BLOCK, [block]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBlock({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBlock({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BLOCK, [block]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBlock({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The whole block header
+     * The whole block header
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-header
      */
-    getBlockHeader() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BLOCK_HEADER, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBlockHeader({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBlockHeader({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BLOCK_HEADER, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBlockHeader({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head) and version
-     * @description All the metadata associated to the block
+     * All the metadata associated to the block
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-metadata
      */
-    getBlockMetadata() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BLOCK_METADATA, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBlockMetadata({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBlockMetadata({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BLOCK_METADATA, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBlockMetadata({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param args contains optional query arguments (level, cycle, delegate, consensus_key, and max_round)
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Retrieves the list of delegates allowed to bake a block.
+     * Retrieves the list of delegates allowed to bake a block.
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getBakingRights() {
-        return __awaiter(this, arguments, void 0, function* (args = {}, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BAKING_RIGHTS, [
-                block,
-                args,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBakingRights(args, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBakingRights(args = {}, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BAKING_RIGHTS, [
+            block,
+            args,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBakingRights(args, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param args contains optional query arguments (level, cycle, delegate, and consensus_key)
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Retrieves the delegates allowed to attest a block
+     * Retrieves the delegates allowed to attest a block
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getAttestationRights() {
-        return __awaiter(this, arguments, void 0, function* (args = {}, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ATTESTATION_RIGHTS, [block, args]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getAttestationRights(args, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getAttestationRights(args = {}, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ATTESTATION_RIGHTS, [block, args]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getAttestationRights(args, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Ballots casted so far during a voting period
+     * Ballots casted so far during a voting period
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-ballot-list
      */
-    getBallotList() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BALLOT_LIST, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBallotList({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBallotList({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BALLOT_LIST, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBallotList({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Sum of ballots casted so far during a voting period
+     * Sum of ballots casted so far during a voting period
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-ballots
      */
-    getBallots() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BALLOTS, [block]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getBallots({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getBallots({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_BALLOTS, [block]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getBallots({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Current proposal under evaluation.
+     * Current proposal under evaluation.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-current-proposal
      */
-    getCurrentProposal() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CURRENT_PROPOSAL, [block]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getCurrentProposal({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getCurrentProposal({ block, } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CURRENT_PROPOSAL, [block]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getCurrentProposal({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Current expected quorum.
+     * Current expected quorum.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-current-quorum
      */
-    getCurrentQuorum() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CURRENT_QUORUM, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getCurrentQuorum({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getCurrentQuorum({ block, } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CURRENT_QUORUM, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getCurrentQuorum({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description List of delegates with their voting power
+     * List of delegates with their voting power
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-listings
      */
-    getVotesListings() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_VOTES_LISTINGS, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getVotesListings({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getVotesListings({ block, } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_VOTES_LISTINGS, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getVotesListings({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description List of proposals with number of supporters
+     * List of proposals with number of supporters
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-proposals
      */
-    getProposals() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PROPOSALS, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getProposals({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getProposals({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PROPOSALS, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getProposals({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param data operation contents to forge
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Forge an operation returning the unsigned bytes
+     * Forge an operation returning the unsigned bytes
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    forgeOperations(data_1) {
-        return __awaiter(this, arguments, void 0, function* (data, { block } = defaultRPCOptions) {
-            return this.rpcClient.forgeOperations(data, { block });
-        });
+    async forgeOperations(data, { block } = defaultRPCOptions) {
+        return this.rpcClient.forgeOperations(data, { block });
     }
     /**
      * @param signedOpBytes signed bytes to inject
-     * @description Inject an operation in node and broadcast it and return the ID of the operation
+     * Inject an operation in node and broadcast it and return the ID of the operation
      * @see https://tezos.gitlab.io/shell/rpc.html#post-injection-operation
      */
-    injectOperation(signedOpBytes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpcClient.injectOperation(signedOpBytes);
-        });
+    async injectOperation(signedOpBytes) {
+        return this.rpcClient.injectOperation(signedOpBytes);
     }
     /**
      * @param ops Operations to apply
      * @param options contains generic configuration for rpc calls to specified block and version
-     * @description Simulate the application of the operations with the context of the given block and return the result of each operation application
+     * Simulate the application of the operations with the context of the given block and return the result of each operation application
      * @see https://tezos.gitlab.io/active/rpc.html#post-block-id-helpers-preapply-operations
      */
-    preapplyOperations(ops_1) {
-        return __awaiter(this, arguments, void 0, function* (ops, { block } = defaultRPCOptions) {
-            return this.rpcClient.preapplyOperations(ops, { block });
-        });
+    async preapplyOperations(ops, { block } = defaultRPCOptions) {
+        return this.rpcClient.preapplyOperations(ops, { block });
     }
     /**
      * @param contract address of the contract we want to get the entrypoints of
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Return the list of entrypoints of the contract
+     * Return the list of entrypoints of the contract
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-entrypoints
-     * @version 005_PsBABY5H
-     */
-    getEntrypoints(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            this.validateContract(contract);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ENTRYPOINTS, [
-                block,
-                contract,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getEntrypoints(contract, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+     * @remarks version 005_PsBABY5H
+     */
+    async getEntrypoints(contract, { block } = defaultRPCOptions) {
+        this.validateContract(contract);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ENTRYPOINTS, [
+            block,
+            contract,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getEntrypoints(contract, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param op Operation to simulate
      * @param options contains generic configuration for rpc calls to specified block and version
-     * @description Simulate running an operation at some future moment (based on the number of blocks given in the `latency` argument), and return the operation application result.
+     * Simulate running an operation at some future moment (based on the number of blocks given in the `latency` argument), and return the operation application result.
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    simulateOperation(op_1) {
-        return __awaiter(this, arguments, void 0, function* (op, { block } = defaultRPCOptions) {
-            return this.rpcClient.simulateOperation(op, { block });
-        });
+    async simulateOperation(op, { block } = defaultRPCOptions) {
+        return this.rpcClient.simulateOperation(op, { block });
     }
     /**
      * @param code Code to run
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Run a Michelson script in the current context
+     * Run a Michelson script in the current context
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    runCode(code_1) {
-        return __awaiter(this, arguments, void 0, function* (code, { block } = defaultRPCOptions) {
-            return this.rpcClient.runCode(code, { block });
-        });
+    async runCode(code, { block } = defaultRPCOptions) {
+        return this.rpcClient.runCode(code, { block });
     }
     /**
      * @param viewScriptParams Parameters of the script view to run
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Simulate a call to a michelson view
+     * Simulate a call to a michelson view
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    runScriptView(_a, _b) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var { unparsing_mode = 'Readable' } = _a, rest = __rest(_a, ["unparsing_mode"]);
-            var _c = _b === void 0 ? defaultRPCOptions : _b, block = _c.block;
-            return this.rpcClient.runScriptView(Object.assign({ unparsing_mode }, rest), { block });
-        });
+    async runScriptView({ unparsing_mode = 'Readable', ...rest }, { block } = defaultRPCOptions) {
+        return this.rpcClient.runScriptView({
+            unparsing_mode,
+            ...rest,
+        }, { block });
     }
     /**
      * @param viewParams Parameters of the view to run
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Simulate a call to a view following the TZIP-4 standard.
+     * Simulate a call to a view following the TZIP-4 standard.
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    runView(_a, _b) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var { unparsing_mode = 'Readable' } = _a, rest = __rest(_a, ["unparsing_mode"]);
-            var _c = _b === void 0 ? defaultRPCOptions : _b, block = _c.block;
-            return this.rpcClient.runView(Object.assign({ unparsing_mode }, rest), { block });
-        });
+    async runView({ unparsing_mode = 'Readable', ...rest }, { block } = defaultRPCOptions) {
+        return this.rpcClient.runView({
+            unparsing_mode,
+            ...rest,
+        }, { block });
     }
-    getChainId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CHAIN_ID, []);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getChainId();
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getChainId() {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CHAIN_ID, []);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getChainId();
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param data Data to pack
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Computes the serialized version of a data expression using the same algorithm as script instruction PACK
+     * Computes the serialized version of a data expression using the same algorithm as script instruction PACK
      * Note: You should always verify the packed bytes before signing or requesting that they be signed when using the RPC to pack.
      * This precaution helps protect you and your applications users from RPC nodes that have been compromised.
      * A node that is operated by a bad actor, or compromised by a bad actor could return a fully formed operation that does not correspond to the input provided to the RPC endpoint.
@@ -1025,319 +900,304 @@ class RpcClientCache {
      * @example packData({ data: { string: "test" }, type: { prim: "string" } })
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    packData(data_1) {
-        return __awaiter(this, arguments, void 0, function* (data, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.PACK_DATA, [block], data);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.packData(data, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async packData(data, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.PACK_DATA, [block], data);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.packData(data, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      *
-     * @description Return rpc root url
+     * Return rpc root url
      */
     getRpcUrl() {
         return this.rpcClient.getRpcUrl();
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the voting period (index, kind, starting position) and related information (position, remaining) of the interrogated block
+     * Returns the voting period (index, kind, starting position) and related information (position, remaining) of the interrogated block
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-current-period
      */
-    getCurrentPeriod() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CURRENT_PERIOD, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getCurrentPeriod({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getCurrentPeriod({ block, } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_CURRENT_PERIOD, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getCurrentPeriod({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the voting period (index, kind, starting position) and related information (position, remaining) of the next block.Useful to craft operations that will be valid in the next block
+     * Returns the voting period (index, kind, starting position) and related information (position, remaining) of the next block.Useful to craft operations that will be valid in the next block
      * @example getSuccessorPeriod() will default to successor voting period for /main/chains/block/head.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-successor-period
      */
-    getSuccessorPeriod() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SUCCESSOR_PERIOD, [block]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getSuccessorPeriod({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getSuccessorPeriod({ block, } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SUCCESSOR_PERIOD, [block]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getSuccessorPeriod({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param id Sapling state ID
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the root and a diff of a state starting from an optional offset which is zero by default
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-sapling-sapling-state-id-get-diff
-     */
-    getSaplingDiffById(id_1) {
-        return __awaiter(this, arguments, void 0, function* (id, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SAPLING_DIFF_BY_ID, [block, id]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getSaplingDiffById(id, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+     * Returns the root and a diff of a state starting from an optional offset which is zero by default
+     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-sapling-sapling-state-id-get-diff
+     */
+    async getSaplingDiffById(id, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SAPLING_DIFF_BY_ID, [block, id]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getSaplingDiffById(id, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param contract address of the contract we want to get the sapling diff
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the root and a diff of a state starting from an optional offset which is zero by default
+     * Returns the root and a diff of a state starting from an optional offset which is zero by default
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-single-sapling-get-diff
      */
-    getSaplingDiffByContract(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SAPLING_DIFF_BY_CONTRACT, [block, contract]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getSaplingDiffByContract(contract, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getSaplingDiffByContract(contract, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_SAPLING_DIFF_BY_CONTRACT, [block, contract]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getSaplingDiffByContract(contract, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description get current and next protocol
+     * get current and next protocol
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-protocols
      */
-    getProtocols() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PROTOCOLS, [
-                block,
-            ]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getProtocols({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getProtocols({ block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PROTOCOLS, [
+            block,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getProtocols({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
-     * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description get current and next protocol
+     * @param protocol the protocol hash to look up (default to empty string)
+     * get current and next protocol
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-protocols
      */
-    getProtocolActivations() {
-        return __awaiter(this, arguments, void 0, function* (protocol = '') {
-            if (protocol) {
-                const protocolValidation = validateProtocol(protocol);
-                if (protocolValidation !== ValidationResult.VALID) {
-                    throw new InvalidProtocolHashError(protocol, protocolValidation);
-                }
+    async getProtocolActivations(protocol = '') {
+        if (protocol) {
+            const protocolValidation = validateProtocol(protocol);
+            if (protocolValidation !== ValidationResult.VALID) {
+                throw new InvalidProtocolHashError(protocol, protocolValidation);
             }
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PROTOCOL_ACTIVATIONS, [protocol]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getProtocolActivations(protocol);
-                this.put(key, response);
-                return response;
-            }
-        });
+        }
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PROTOCOL_ACTIVATIONS, [protocol]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getProtocolActivations(protocol);
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param contract address of the contract we want to retrieve storage information of
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the used storage space of the contract
+     * Access the used storage space of the contract
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getStorageUsedSpace(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_STORAGE_USED_SPACE, [block, contract]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getStorageUsedSpace(contract, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getStorageUsedSpace(contract, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_STORAGE_USED_SPACE, [block, contract]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getStorageUsedSpace(contract, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param contract address of the contract we want to retrieve storage information of
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-  =   * @description Access the paid storage space of the contract
+  =   * Access the paid storage space of the contract
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getStoragePaidSpace(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_STORAGE_PAID_SPACE, [block, contract]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getStoragePaidSpace(contract, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getStoragePaidSpace(contract, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_STORAGE_PAID_SPACE, [block, contract]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getStoragePaidSpace(contract, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param contract implicit or originated address we want to retrieve ticket balance of
      * @param ticket object to specify a ticket by ticketer, content type and content
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the contract's balance of ticket with specified ticketer, content type, and content.
+     * Access the contract's balance of ticket with specified ticketer, content type, and content.
      * @example ticket { ticketer: 'address', content_type: { prim: "string" }, content: { string: 'ticket1' } }
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getTicketBalance(contract_1, ticket_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, ticket, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_TICKET_BALANCE, [block, contract], ticket);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getTicketBalance(contract, ticket, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getTicketBalance(contract, ticket, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_TICKET_BALANCE, [block, contract], ticket);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getTicketBalance(contract, ticket, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param contract originated address we want to retrieve ticket balances of
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the complete list of tickets owned by the given contract by scanning the contract's storage.
+     * Access the complete list of tickets owned by the given contract by scanning the contract's storage.
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getAllTicketBalances(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ALL_TICKET_BALANCES, [block, contract]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getAllTicketBalances(contract, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getAllTicketBalances(contract, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ALL_TICKET_BALANCES, [block, contract]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getAllTicketBalances(contract, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
-     * @description Returns the cycle at which the launch of the Adaptive Issuance feature is set to happen. A result of null means that the feature is not yet set to launch.
+     * Returns the cycle at which the launch of the Adaptive Issuance feature is set to happen. A result of null means that the feature is not yet set to launch.
      * @param options contains generic configuration for rpc calls to specified block (default to head)
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-adaptive-issuance-launch-cycle
      */
-    getAdaptiveIssuanceLaunchCycle() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ADAPTIVE_ISSUANCE_LAUNCH_CYCLE, [block]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getAdaptiveIssuanceLaunchCycle({ block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getAdaptiveIssuanceLaunchCycle({ block, } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ADAPTIVE_ISSUANCE_LAUNCH_CYCLE, [block]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getAdaptiveIssuanceLaunchCycle({ block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
-     * @description List the prevalidated operations in mempool (accessibility of mempool depends on each rpc endpoint)
+     * List the prevalidated operations in mempool (accessibility of mempool depends on each rpc endpoint)
      * @param args has 5 optional properties
      * @default args { version: '2', validated: true, refused: true, outdated, true, branchRefused: true, branchDelayed: true, validationPass: undefined }
      */
-    getPendingOperations() {
-        return __awaiter(this, arguments, void 0, function* (args = {}) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PENDING_OPERATIONS, [args]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getPendingOperations(args);
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getPendingOperations(args = {}) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PENDING_OPERATIONS, [args]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getPendingOperations(args);
+            this.put(key, response);
+            return response;
+        }
+    }
+    /**
+     * Returns the current mempool fee filter configuration.
+     * @param args optional query arguments for the mempool/filter endpoint
+     */
+    async getMempoolFilter(args = {}) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_MEMPOOL_FILTER, [
+            args,
+        ]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getMempoolFilter(args);
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param delegate delegate address which we want to retrieve active staking parameters
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the currently active staking parameters for the given delegate
+     * Returns the currently active staking parameters for the given delegate
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh-active-staking-parameters
      */
-    getActiveStakingParameters(delegate_1) {
-        return __awaiter(this, arguments, void 0, function* (delegate, { block } = defaultRPCOptions) {
-            this.validateAddress(delegate);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ACTIVE_STAKING_PARAMETERS, [block, delegate]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getActiveStakingParameters(delegate, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getActiveStakingParameters(delegate, { block } = defaultRPCOptions) {
+        this.validateAddress(delegate);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_ACTIVE_STAKING_PARAMETERS, [block, delegate]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getActiveStakingParameters(delegate, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param delegate delegate address which we want to retrieve pending staking parameters
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the pending values for the given delegate's staking parameters
+     * Returns the pending values for the given delegate's staking parameters
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh-pending-staking-parameters
      */
-    getPendingStakingParameters(delegate_1) {
-        return __awaiter(this, arguments, void 0, function* (delegate, { block } = defaultRPCOptions) {
-            this.validateAddress(delegate);
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PENDING_STAKING_PARAMETERS, [block, delegate]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getPendingStakingParameters(delegate, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getPendingStakingParameters(delegate, { block } = defaultRPCOptions) {
+        this.validateAddress(delegate);
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_PENDING_STAKING_PARAMETERS, [block, delegate]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getPendingStakingParameters(delegate, { block });
+            this.put(key, response);
+            return response;
+        }
     }
     /**
      * @param destination address to retrieve the index for
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the index assigned to the address if it was indexed by the opcode INDEX_ADDRESS, otherwise returns null
+     * Returns the index assigned to the address if it was indexed by the opcode INDEX_ADDRESS, otherwise returns null
      * @see https://octez.tezos.com/docs/alpha/rpc.html#get-block-id-context-destination-destination-id-index
      */
-    getDestinationIndex(destination_1) {
-        return __awaiter(this, arguments, void 0, function* (destination, { block } = defaultRPCOptions) {
-            const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_DESTINATION_INDEX, [block, destination]);
-            if (this.has(key)) {
-                return this.get(key);
-            }
-            else {
-                const response = this.rpcClient.getDestinationIndex(destination, { block });
-                this.put(key, response);
-                return response;
-            }
-        });
+    async getDestinationIndex(destination, { block } = defaultRPCOptions) {
+        const key = this.formatCacheKey(this.rpcClient.getRpcUrl(), RPCMethodName.GET_DESTINATION_INDEX, [block, destination]);
+        if (this.has(key)) {
+            return this.get(key);
+        }
+        else {
+            const response = this.rpcClient.getDestinationIndex(destination, { block });
+            this.put(key, response);
+            return response;
+        }
     }
 }
 
@@ -1502,12 +1362,16 @@ var OpKind;
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 const VERSION = {
-    "commitHash": "105a7b15cfb862a0732c204e0e9741098d697775",
-    "version": "24.2.0"
+    "commitHash": "27675679db6515e8b092195ef5c58c2c0ea5f5c8",
+    "version": "24.3.0-beta.0"
 };
 
+/**
+ * @packageDocumentation
+ * @module @taquito/rpc
+ */
 /***
- * @description RpcClient allows interaction with Tezos network through an rpc node
+ * RpcClient allows interaction with Tezos network through an rpc node
  */
 class RpcClient {
     /**
@@ -1548,743 +1412,681 @@ class RpcClient {
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Get the block's hash, its unique identifier.
+     * Get the block's hash, its unique identifier.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-hash
      */
-    getBlockHash() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const hash = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/hash`),
-                method: 'GET',
-            });
-            return hash;
+    async getBlockHash({ block } = defaultRPCOptions) {
+        const hash = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/hash`),
+            method: 'GET',
         });
+        return hash;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description List the ancestors of the given block which, if referred to as the branch in an operation header, are recent enough for that operation to be included in the current block.
+     * List the ancestors of the given block which, if referred to as the branch in an operation header, are recent enough for that operation to be included in the current block.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-live-blocks
      */
-    getLiveBlocks() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const blocks = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/live_blocks`),
-                method: 'GET',
-            });
-            return blocks;
+    async getLiveBlocks({ block } = defaultRPCOptions) {
+        const blocks = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/live_blocks`),
+            method: 'GET',
         });
+        return blocks;
     }
     /**
      * @param address address from which we want to retrieve the spendable balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'spendable' RPC.
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'spendable' RPC.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-balance
      */
-    getBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const balance = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/balance`),
-                method: 'GET',
-            });
-            return new BigNumber(balance);
+    async getBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const balance = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/balance`),
+            method: 'GET',
         });
+        return new BigNumber(balance);
     }
     /**
      * @param address address from which we want to retrieve the spendable balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'balance' RPC.
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'balance' RPC.
      */
-    getSpendable(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const balance = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/spendable`),
-                method: 'GET',
-            });
-            return new BigNumber(balance);
+    async getSpendable(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const balance = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/spendable`),
+            method: 'GET',
         });
+        return new BigNumber(balance);
     }
     /**
      * @param address address from which we want to retrieve balance and frozen bonds
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds to the contract's full balance from which staked funds and unstake requests have been excluded. Identical to the 'spendable_and_frozen_bonds' RPC.
+     * The sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds to the contract's full balance from which staked funds and unstake requests have been excluded. Identical to the 'spendable_and_frozen_bonds' RPC.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-full-balance
      */
-    getBalanceAndFrozenBonds(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const balance = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/balance_and_frozen_bonds`),
-                method: 'GET',
-            });
-            return new BigNumber(balance);
+    async getBalanceAndFrozenBonds(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const balance = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/balance_and_frozen_bonds`),
+            method: 'GET',
         });
+        return new BigNumber(balance);
     }
     /**
      * @param address address from which we want to retrieve spendable and frozen bonds
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds to the contract's full balance from which staked funds and unstake requests have been excluded. Identical to the 'balance_and_frozen_bonds' RPC.
+     * The sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds to the contract's full balance from which staked funds and unstake requests have been excluded. Identical to the 'balance_and_frozen_bonds' RPC.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-full-balance
      */
-    getSpendableAndFrozenBonds(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const balance = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/spendable_and_frozen_bonds`),
-                method: 'GET',
-            });
-            return new BigNumber(balance);
+    async getSpendableAndFrozenBonds(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const balance = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/spendable_and_frozen_bonds`),
+            method: 'GET',
         });
+        return new BigNumber(balance);
     }
     /**
      * @param address address from which we want to retrieve the full balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the full balance of a contract, including frozen bonds and stake.
+     * Access the full balance of a contract, including frozen bonds and stake.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-full-balance
      */
-    getFullBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const balance = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/full_balance`),
-                method: 'GET',
-            });
-            return new BigNumber(balance);
+    async getFullBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const balance = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/full_balance`),
+            method: 'GET',
         });
+        return new BigNumber(balance);
     }
     /**
      * @param address address from which we want to retrieve the staked balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the staked balance of a contract. Returns None if the contract is originated, or neither delegated nor a delegate.
+     * Access the staked balance of a contract. Returns None if the contract is originated, or neither delegated nor a delegate.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-staked-balance
      */
-    getStakedBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const balance = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/staked_balance`),
-                method: 'GET',
-            });
-            return new BigNumber(balance);
+    async getStakedBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const balance = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/staked_balance`),
+            method: 'GET',
         });
+        return new BigNumber(balance);
     }
     /**
      * @param address address from which we want to retrieve the unstaked finalizable balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the balance of a contract that was requested for an unstake operation, and is no longer frozen, which means it will appear in the spendable balance of the contract after any stake/unstake/finalize_unstake operation. Returns None if the contract is originated.
+     * Access the balance of a contract that was requested for an unstake operation, and is no longer frozen, which means it will appear in the spendable balance of the contract after any stake/unstake/finalize_unstake operation. Returns None if the contract is originated.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-unstaked-finalizable-balance
      */
-    getUnstakedFinalizableBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const balance = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/unstaked_finalizable_balance`),
-                method: 'GET',
-            });
-            return new BigNumber(balance);
+    async getUnstakedFinalizableBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const balance = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/unstaked_finalizable_balance`),
+            method: 'GET',
         });
+        return new BigNumber(balance);
     }
     /**
      * @param address address from which we want to retrieve the unstaked frozen balance
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the balance of a contract that was requested for an unstake operation, but is still frozen for the duration of the slashing period. Returns None if the contract is originated.
+     * Access the balance of a contract that was requested for an unstake operation, but is still frozen for the duration of the slashing period. Returns None if the contract is originated.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-unstaked-frozen-balance
      */
-    getUnstakedFrozenBalance(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const balance = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/unstaked_frozen_balance`),
-                method: 'GET',
-            });
-            return new BigNumber(balance);
+    async getUnstakedFrozenBalance(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const balance = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/unstaked_frozen_balance`),
+            method: 'GET',
         });
+        return new BigNumber(balance);
     }
     /**
      * @param address address from which we want to retrieve the unstaked requests
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the unstake requests of the contract. The requests that appear in the finalizable field can be finalized, which means that the contract can transfer these (no longer frozen) funds to their spendable balance with a [finalize_unstake] operation call. Returns null if there is no unstake request pending.
+     * Access the unstake requests of the contract. The requests that appear in the finalizable field can be finalized, which means that the contract can transfer these (no longer frozen) funds to their spendable balance with a [finalize_unstake] operation call. Returns null if there is no unstake request pending.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-unstake-requests
      */
-    getUnstakeRequests(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/unstake_requests`),
-                method: 'GET',
-            });
-            return response === null
-                ? null
-                : {
-                    finalizable: response.finalizable.map((_a) => {
-                        var { amount } = _a, rest = __rest(_a, ["amount"]);
+    async getUnstakeRequests(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/unstake_requests`),
+            method: 'GET',
+        });
+        return response === null
+            ? null
+            : {
+                finalizable: response.finalizable.map(({ amount, ...rest }) => {
+                    const castedToBigNumber = castToBigNumber({ amount }, ['amount']);
+                    return {
+                        ...rest,
+                        amount: castedToBigNumber.amount,
+                    };
+                }),
+                unfinalizable: {
+                    delegate: response.unfinalizable.delegate,
+                    requests: response.unfinalizable.requests.map(({ amount, cycle }) => {
                         const castedToBigNumber = castToBigNumber({ amount }, ['amount']);
-                        return Object.assign(Object.assign({}, rest), { amount: castedToBigNumber.amount });
+                        return {
+                            cycle,
+                            amount: castedToBigNumber.amount,
+                        };
                     }),
-                    unfinalizable: {
-                        delegate: response.unfinalizable.delegate,
-                        requests: response.unfinalizable.requests.map(({ amount, cycle }) => {
-                            const castedToBigNumber = castToBigNumber({ amount }, ['amount']);
-                            return {
-                                cycle,
-                                amount: castedToBigNumber.amount,
-                            };
-                        }),
-                    },
-                };
-        });
+                },
+            };
     }
     /**
      * @param address contract address from which we want to retrieve the storage
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the data of the contract.
+     * Access the data of the contract.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-storage
      */
-    getStorage(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateContract(address);
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/storage`),
-                method: 'GET',
-            });
+    async getStorage(address, { block } = defaultRPCOptions) {
+        this.validateContract(address);
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/storage`),
+            method: 'GET',
         });
     }
     /**
      * @param address contract address from which we want to retrieve the script
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the code and data of the contract.
+     * Access the code and data of the contract.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-script
      */
-    getScript(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateContract(address);
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/script`),
-                method: 'GET',
-            });
+    async getScript(address, { block } = defaultRPCOptions) {
+        this.validateContract(address);
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/script`),
+            method: 'GET',
         });
     }
     /**
      * @param address contract address from which we want to retrieve the script
      * @param unparsingMode default is { unparsing_mode: "Readable" }
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the script of the contract and normalize it using the requested unparsing mode.
+     * Access the script of the contract and normalize it using the requested unparsing mode.
      */
-    getNormalizedScript(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, unparsingMode = { unparsing_mode: 'Readable' }, { block } = defaultRPCOptions) {
-            this.validateContract(address);
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/script/normalized`),
-                method: 'POST',
-            }, unparsingMode);
-        });
+    async getNormalizedScript(address, unparsingMode = { unparsing_mode: 'Readable' }, { block } = defaultRPCOptions) {
+        this.validateContract(address);
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/script/normalized`),
+            method: 'POST',
+        }, unparsingMode);
     }
     /**
      * @param address contract address from which we want to retrieve
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the complete status of a contract.
+     * Access the complete status of a contract.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id
      */
-    getContract(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const contractResponse = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}`),
-                method: 'GET',
-            });
-            return Object.assign(Object.assign({}, contractResponse), { balance: new BigNumber(contractResponse.balance) });
+    async getContract(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const contractResponse = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}`),
+            method: 'GET',
         });
+        return {
+            ...contractResponse,
+            balance: new BigNumber(contractResponse.balance),
+        };
     }
     /**
      * @param address contract address from which we want to retrieve the manager
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the manager of an implicit contract
+     * Access the manager of an implicit contract
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-manager-key
      */
-    getManagerKey(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/manager_key`),
-                method: 'GET',
-            });
+    async getManagerKey(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/manager_key`),
+            method: 'GET',
         });
     }
     /**
      * @param address contract address from which we want to retrieve the delegate (baker)
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the delegate of a contract, if any
+     * Access the delegate of a contract, if any
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-delegate
      */
-    getDelegate(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            let delegate;
-            try {
-                delegate = yield this.httpBackend.createRequest({
-                    url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/delegate`),
-                    method: 'GET',
-                });
+    async getDelegate(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        let delegate;
+        try {
+            delegate = await this.httpBackend.createRequest({
+                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${address}/delegate`),
+                method: 'GET',
+            });
+        }
+        catch (ex) {
+            if (ex instanceof HttpResponseError && ex.status === STATUS_CODE.NOT_FOUND) {
+                delegate = null;
             }
-            catch (ex) {
-                if (ex instanceof HttpResponseError && ex.status === STATUS_CODE.NOT_FOUND) {
-                    delegate = null;
-                }
-                else {
-                    throw ex;
-                }
+            else {
+                throw ex;
             }
-            return delegate;
-        });
+        }
+        return delegate;
     }
     /**
      * @param id Big Map ID
      * @param expr Expression hash to query (A b58check encoded Blake2b hash of the expression (The expression can be packed using the pack_data method))
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the value associated with a key in a big map.
+     * Access the value associated with a key in a big map.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-big-maps-big-map-id-script-expr
      */
-    getBigMapExpr(id_1, expr_1) {
-        return __awaiter(this, arguments, void 0, function* (id, expr, { block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/big_maps/${id}/${expr}`),
-                method: 'GET',
-            });
+    async getBigMapExpr(id, expr, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/big_maps/${id}/${expr}`),
+            method: 'GET',
         });
     }
     /**
      * @param args contains optional query arguments (active, inactive, with_minimal_stake, without_minimal_stake)
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Lists all registered delegates by default with query arguments to filter unneeded values.
+     * Lists all registered delegates by default with query arguments to filter unneeded values.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh
      */
-    getAllDelegates() {
-        return __awaiter(this, arguments, void 0, function* (args = {}, { block } = defaultRPCOptions) {
-            return yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates`),
-                method: 'GET',
-                query: args,
-            });
+    async getAllDelegates(args = {}, { block } = defaultRPCOptions) {
+        return await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates`),
+            method: 'GET',
+            query: args,
         });
     }
     /**
      * @param address delegate address which we want to retrieve
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Everything about a delegate
+     * Everything about a delegate
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh
      */
-    getDelegates(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates/${address}`),
-                method: 'GET',
-            });
-            const castedResponse = castToBigNumber(response, [
-                'balance',
-                'full_balance',
-                'current_frozen_deposits',
-                'frozen_deposits',
-                'frozen_balance',
-                'frozen_deposits_limit',
-                'staking_balance',
-                'delegated_balance',
-                'voting_power',
-                'total_delegated_stake',
-                'staking_denominator',
-            ]);
-            if (response.frozen_balance_by_cycle) {
-                return Object.assign(Object.assign(Object.assign({}, response), castedResponse), { frozen_balance_by_cycle: response.frozen_balance_by_cycle.map((_a) => {
-                        var { deposit, deposits, fees, rewards } = _a, rest = __rest(_a, ["deposit", "deposits", "fees", "rewards"]);
-                        const castedToBigNumber = castToBigNumber({ deposit, deposits, fees, rewards }, [
-                            'deposit',
-                            'deposits',
-                            'fees',
-                            'rewards',
-                        ]);
-                        return Object.assign(Object.assign({}, rest), { deposit: castedToBigNumber.deposit, deposits: castedToBigNumber.deposits, fees: castedToBigNumber.fees, rewards: castedToBigNumber.rewards });
-                    }) });
-            }
-            else {
-                return Object.assign(Object.assign({}, response), castedResponse);
-            }
-        });
+    async getDelegates(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates/${address}`),
+            method: 'GET',
+        });
+        const castedResponse = castToBigNumber(response, [
+            'balance',
+            'full_balance',
+            'current_frozen_deposits',
+            'frozen_deposits',
+            'frozen_balance',
+            'frozen_deposits_limit',
+            'staking_balance',
+            'delegated_balance',
+            'voting_power',
+            'total_delegated_stake',
+            'staking_denominator',
+        ]);
+        if (response.frozen_balance_by_cycle) {
+            return {
+                ...response,
+                ...castedResponse,
+                frozen_balance_by_cycle: response.frozen_balance_by_cycle.map(({ deposit, deposits, fees, rewards, ...rest }) => {
+                    const castedToBigNumber = castToBigNumber({ deposit, deposits, fees, rewards }, [
+                        'deposit',
+                        'deposits',
+                        'fees',
+                        'rewards',
+                    ]);
+                    return {
+                        ...rest,
+                        deposit: castedToBigNumber.deposit,
+                        deposits: castedToBigNumber.deposits,
+                        fees: castedToBigNumber.fees,
+                        rewards: castedToBigNumber.rewards,
+                    };
+                }),
+            };
+        }
+        else {
+            return {
+                ...response,
+                ...castedResponse,
+            };
+        }
     }
     /**
      * @param address delegate address which we want to retrieve
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the delegate info (e.g. voting power) found in the listings of the current voting period
+     * Returns the delegate info (e.g. voting power) found in the listings of the current voting period
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh-voting-info
      */
-    getVotingInfo(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, { block } = defaultRPCOptions) {
-            this.validateAddress(address);
-            return yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates/${address}/voting_info`),
-                method: 'GET',
-            });
+    async getVotingInfo(address, { block } = defaultRPCOptions) {
+        this.validateAddress(address);
+        return await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates/${address}/voting_info`),
+            method: 'GET',
         });
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description All constants
+     * All constants
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-constants
      */
-    getConstants() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/constants`),
-                method: 'GET',
-            });
-            const castedResponse = castToBigNumber(response, [
-                'time_between_blocks',
-                'hard_gas_limit_per_operation',
-                'hard_gas_limit_per_block',
-                'proof_of_work_threshold',
-                'tokens_per_roll',
-                'seed_nonce_revelation_tip',
-                'block_security_deposit',
-                'endorsement_security_deposit',
-                'block_reward',
-                'endorsement_reward',
-                'cost_per_byte',
-                'hard_storage_limit_per_operation',
-                'test_chain_duration',
-                'baking_reward_per_endorsement',
-                'delay_per_missing_endorsement',
-                'minimal_block_delay',
-                'liquidity_baking_subsidy',
-                'cache_layout',
-                'baking_reward_fixed_portion',
-                'baking_reward_bonus_per_slot',
-                'endorsing_reward_per_slot',
-                'double_baking_punishment',
-                'delay_increment_per_round',
-                'tx_rollup_commitment_bond',
-                'vdf_difficulty',
-                'sc_rollup_stake_amount',
-                'minimal_stake',
-            ]);
-            return Object.assign(Object.assign({}, response), castedResponse);
-        });
+    async getConstants({ block } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/constants`),
+            method: 'GET',
+        });
+        const castedResponse = castToBigNumber(response, [
+            'time_between_blocks',
+            'hard_gas_limit_per_operation',
+            'hard_gas_limit_per_block',
+            'proof_of_work_threshold',
+            'tokens_per_roll',
+            'seed_nonce_revelation_tip',
+            'block_security_deposit',
+            'endorsement_security_deposit',
+            'block_reward',
+            'endorsement_reward',
+            'cost_per_byte',
+            'hard_storage_limit_per_operation',
+            'test_chain_duration',
+            'baking_reward_per_endorsement',
+            'delay_per_missing_endorsement',
+            'minimal_block_delay',
+            'liquidity_baking_subsidy',
+            'cache_layout',
+            'baking_reward_fixed_portion',
+            'baking_reward_bonus_per_slot',
+            'endorsing_reward_per_slot',
+            'double_baking_punishment',
+            'delay_increment_per_round',
+            'tx_rollup_commitment_bond',
+            'vdf_difficulty',
+            'sc_rollup_stake_amount',
+            'minimal_stake',
+        ]);
+        return {
+            ...response,
+            ...castedResponse,
+        };
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head) and version.
-     * @description All the information about a block
+     * All the information about a block
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id
      * @example getBlock() will default to `/main/chains/block/head?version=1`
      * @example getBlock({ block: 'head~2' }) will return an offset of 2 from head blocks
      * @example getBlock({ block: 'BL8fTiWcSxWCjiMVnDkbh6EuhqVPZzgWheJ2dqwrxYRm9AephXh~2' }) will return an offset of 2 blocks from given block hash..
      */
-    getBlock() {
-        return __awaiter(this, arguments, void 0, function* ({ block, version } = defaultRPCOptions) {
-            const requestOptions = {
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}`),
-                method: 'GET',
-            };
-            if (version !== undefined) {
-                requestOptions.query = { version };
-            }
-            return yield this.httpBackend.createRequest(requestOptions);
-        });
+    async getBlock({ block, version } = defaultRPCOptions) {
+        const requestOptions = {
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}`),
+            method: 'GET',
+        };
+        if (version !== undefined) {
+            requestOptions.query = { version };
+        }
+        return await this.httpBackend.createRequest(requestOptions);
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description The whole block header
+     * The whole block header
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-header
      */
-    getBlockHeader() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/header`),
-                method: 'GET',
-            });
-            return response;
+    async getBlockHeader({ block } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/header`),
+            method: 'GET',
         });
+        return response;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head) and version
-     * @description All the metadata associated to the block
+     * All the metadata associated to the block
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-metadata
      */
-    getBlockMetadata() {
-        return __awaiter(this, arguments, void 0, function* ({ block, version, } = defaultRPCOptions) {
-            const requestOptions = {
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/metadata`),
-                method: 'GET',
-            };
-            if (version !== undefined) {
-                requestOptions.query = { version };
-            }
-            return yield this.httpBackend.createRequest(requestOptions);
-        });
+    async getBlockMetadata({ block, version, } = defaultRPCOptions) {
+        const requestOptions = {
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/metadata`),
+            method: 'GET',
+        };
+        if (version !== undefined) {
+            requestOptions.query = { version };
+        }
+        return await this.httpBackend.createRequest(requestOptions);
     }
     /**
      * @param args contains optional query arguments (level, cycle, delegate, consensus_key, and max_round)
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Retrieves the list of delegates allowed to bake a block.
+     * Retrieves the list of delegates allowed to bake a block.
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getBakingRights() {
-        return __awaiter(this, arguments, void 0, function* (args = {}, { block } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/baking_rights`),
-                method: 'GET',
-                query: args,
-            });
-            return response;
+    async getBakingRights(args = {}, { block } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/baking_rights`),
+            method: 'GET',
+            query: args,
         });
+        return response;
     }
     /**
      * @param args contains optional query arguments (level, cycle, delegate, and consensus_key)
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Retrieves the delegates allowed to attest a block
+     * Retrieves the delegates allowed to attest a block
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getAttestationRights() {
-        return __awaiter(this, arguments, void 0, function* (args = {}, { block } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/attestation_rights`),
-                method: 'GET',
-                query: args,
-            });
-            return response;
+    async getAttestationRights(args = {}, { block } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/attestation_rights`),
+            method: 'GET',
+            query: args,
         });
+        return response;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Ballots casted so far during a voting period
+     * Ballots casted so far during a voting period
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-ballot-list
      */
-    getBallotList() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/ballot_list`),
-                method: 'GET',
-            });
-            return response;
+    async getBallotList({ block } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/ballot_list`),
+            method: 'GET',
         });
+        return response;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Sum of ballots casted so far during a voting period
+     * Sum of ballots casted so far during a voting period
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-ballots
      */
-    getBallots() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/ballots`),
-                method: 'GET',
-            });
-            const casted = castToBigNumber(response, ['yay', 'nay', 'pass']);
-            return casted;
+    async getBallots({ block } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/ballots`),
+            method: 'GET',
         });
+        const casted = castToBigNumber(response, ['yay', 'nay', 'pass']);
+        return casted;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Current proposal under evaluation.
+     * Current proposal under evaluation.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-current-proposal
      */
-    getCurrentProposal() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/current_proposal`),
-                method: 'GET',
-            });
-            return response;
+    async getCurrentProposal({ block, } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/current_proposal`),
+            method: 'GET',
         });
+        return response;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Current expected quorum.
+     * Current expected quorum.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-current-quorum
      */
-    getCurrentQuorum() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/current_quorum`),
-                method: 'GET',
-            });
-            return response;
+    async getCurrentQuorum({ block, } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/current_quorum`),
+            method: 'GET',
         });
+        return response;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description List of delegates with their voting power
+     * List of delegates with their voting power
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-listings
      */
-    getVotesListings() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/listings`),
-                method: 'GET',
-            });
-            response.map((item) => {
-                if (item.voting_power) {
-                    item.voting_power = new BigNumber(item.voting_power);
-                }
-                return item;
-            });
-            return response;
+    async getVotesListings({ block, } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/listings`),
+            method: 'GET',
+        });
+        response.map((item) => {
+            if (item.voting_power) {
+                item.voting_power = new BigNumber(item.voting_power);
+            }
+            return item;
         });
+        return response;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description List of proposals with number of supporters
+     * List of proposals with number of supporters
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-proposals
      */
-    getProposals() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/proposals`),
-                method: 'GET',
-            });
-            response.map((item) => {
-                return (item[1] = new BigNumber(item[1]));
-            });
-            return response;
+    async getProposals({ block } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/proposals`),
+            method: 'GET',
+        });
+        response.map((item) => {
+            return (item[1] = new BigNumber(item[1]));
         });
+        return response;
     }
     /**
      * @param data operation contents to forge
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Forge an operation returning the unsigned bytes
+     * Forge an operation returning the unsigned bytes
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    forgeOperations(data_1) {
-        return __awaiter(this, arguments, void 0, function* (data, { block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/forge/operations`),
-                method: 'POST',
-            }, data);
-        });
+    async forgeOperations(data, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/forge/operations`),
+            method: 'POST',
+        }, data);
     }
     /**
      * @param signedOpBytes signed bytes to inject
-     * @description Inject an operation in node and broadcast it and return the ID of the operation
+     * Inject an operation in node and broadcast it and return the ID of the operation
      * @see https://tezos.gitlab.io/shell/rpc.html#post-injection-operation
      */
-    injectOperation(signedOpBytes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/injection/operation`),
-                method: 'POST',
-            }, signedOpBytes);
-        });
+    async injectOperation(signedOpBytes) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/injection/operation`),
+            method: 'POST',
+        }, signedOpBytes);
     }
     /**
      * @param ops Operations to apply
      * @param options contains generic configuration for rpc calls to specified block and version
-     * @description Simulate the application of the operations with the context of the given block and return the result of each operation application
+     * Simulate the application of the operations with the context of the given block and return the result of each operation application
      * @see https://tezos.gitlab.io/active/rpc.html#post-block-id-helpers-preapply-operations
      */
-    preapplyOperations(ops_1) {
-        return __awaiter(this, arguments, void 0, function* (ops, { block, version } = defaultRPCOptions) {
-            const requestOptions = {
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/preapply/operations`),
-                method: 'POST',
-            };
-            if (version !== undefined) {
-                requestOptions.query = { version };
-            }
-            return yield this.httpBackend.createRequest(requestOptions, ops);
-        });
+    async preapplyOperations(ops, { block, version } = defaultRPCOptions) {
+        const requestOptions = {
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/preapply/operations`),
+            method: 'POST',
+        };
+        if (version !== undefined) {
+            requestOptions.query = { version };
+        }
+        return await this.httpBackend.createRequest(requestOptions, ops);
     }
     /**
      * @param contract address of the contract we want to get the entrypoints of
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Return the list of entrypoints of the contract
+     * Return the list of entrypoints of the contract
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-entrypoints
-     * @version 005_PsBABY5H
+     * @remarks version 005_PsBABY5H
      */
-    getEntrypoints(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            this.validateContract(contract);
-            const contractResponse = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/entrypoints`),
-                method: 'GET',
-            });
-            return contractResponse;
+    async getEntrypoints(contract, { block } = defaultRPCOptions) {
+        this.validateContract(contract);
+        const contractResponse = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/entrypoints`),
+            method: 'GET',
         });
+        return contractResponse;
     }
     /**
      * @param op Operation to simulate
      * @param options contains generic configuration for rpc calls to specified block and version
-     * @description Simulate running an operation at some future moment (based on the number of blocks given in the `latency` argument), and return the operation application result.
+     * Simulate running an operation at some future moment (based on the number of blocks given in the `latency` argument), and return the operation application result.
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    simulateOperation(op_1) {
-        return __awaiter(this, arguments, void 0, function* (op, { block, version } = defaultRPCOptions) {
-            const requestOptions = {
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/simulate_operation`),
-                method: 'POST',
-            };
-            if (version !== undefined) {
-                requestOptions.query = { version };
-            }
-            return yield this.httpBackend.createRequest(requestOptions, op);
-        });
+    async simulateOperation(op, { block, version } = defaultRPCOptions) {
+        const requestOptions = {
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/simulate_operation`),
+            method: 'POST',
+        };
+        if (version !== undefined) {
+            requestOptions.query = { version };
+        }
+        return await this.httpBackend.createRequest(requestOptions, op);
     }
     /**
      * @param code Code to run
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Run a Michelson script in the current context
+     * Run a Michelson script in the current context
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    runCode(code_1) {
-        return __awaiter(this, arguments, void 0, function* (code, { block } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/run_code`),
-                method: 'POST',
-            }, code);
-            return response;
-        });
+    async runCode(code, { block } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/run_code`),
+            method: 'POST',
+        }, code);
+        return response;
     }
     /**
      * @param viewScriptParams Parameters of the script view to run
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Simulate a call to a michelson view
+     * Simulate a call to a michelson view
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    runScriptView(_a, _b) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var { unparsing_mode = 'Readable' } = _a, rest = __rest(_a, ["unparsing_mode"]);
-            var _c = _b === void 0 ? defaultRPCOptions : _b, block = _c.block;
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/run_script_view`),
-                method: 'POST',
-            }, Object.assign({ unparsing_mode }, rest));
+    async runScriptView({ unparsing_mode = 'Readable', ...rest }, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/run_script_view`),
+            method: 'POST',
+        }, {
+            unparsing_mode,
+            ...rest,
         });
     }
     /**
      * @param viewParams Parameters of the view to run
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Simulate a call to a view following the TZIP-4 standard.
+     * Simulate a call to a view following the TZIP-4 standard.
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    runView(_a, _b) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var { unparsing_mode = 'Readable' } = _a, rest = __rest(_a, ["unparsing_mode"]);
-            var _c = _b === void 0 ? defaultRPCOptions : _b, block = _c.block;
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/run_view`),
-                method: 'POST',
-            }, Object.assign({ unparsing_mode }, rest));
+    async runView({ unparsing_mode = 'Readable', ...rest }, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/run_view`),
+            method: 'POST',
+        }, {
+            unparsing_mode,
+            ...rest,
         });
     }
-    getChainId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/chain_id`),
-                method: 'GET',
-            });
+    async getChainId() {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/chain_id`),
+            method: 'GET',
         });
     }
     /**
      * @param data Data to pack
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Computes the serialized version of a data expression using the same algorithm as script instruction PACK
+     * Computes the serialized version of a data expression using the same algorithm as script instruction PACK
      * Note: You should always verify the packed bytes before signing or requesting that they be signed when using the RPC to pack.
      * This precaution helps protect you and your applications users from RPC nodes that have been compromised.
      * A node that is operated by a bad actor, or compromised by a bad actor could return a fully formed operation that does not correspond to the input provided to the RPC endpoint.
@@ -2292,242 +2094,226 @@ class RpcClient {
      * @example packData({ data: { string: "test" }, type: { prim: "string" } })
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    packData(data_1) {
-        return __awaiter(this, arguments, void 0, function* (data, { block } = defaultRPCOptions) {
-            const _a = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/pack_data`),
-                method: 'POST',
-            }, data), { gas } = _a, rest = __rest(_a, ["gas"]);
-            let formattedGas = gas;
-            const tryBigNumber = new BigNumber(gas || '');
-            if (!tryBigNumber.isNaN()) {
-                formattedGas = tryBigNumber;
-            }
-            return Object.assign({ gas: formattedGas }, rest);
-        });
+    async packData(data, { block } = defaultRPCOptions) {
+        const { gas, ...rest } = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/pack_data`),
+            method: 'POST',
+        }, data);
+        let formattedGas = gas;
+        const tryBigNumber = new BigNumber(gas || '');
+        if (!tryBigNumber.isNaN()) {
+            formattedGas = tryBigNumber;
+        }
+        return { gas: formattedGas, ...rest };
     }
     /**
      *
-     * @description Return rpc root url
+     * Return rpc root url
      */
     getRpcUrl() {
         return this.url;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the voting period (index, kind, starting position) and related information (position, remaining) of the interrogated block
+     * Returns the voting period (index, kind, starting position) and related information (position, remaining) of the interrogated block
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-current-period
      */
-    getCurrentPeriod() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/current_period`),
-                method: 'GET',
-            });
-            return response;
+    async getCurrentPeriod({ block, } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/current_period`),
+            method: 'GET',
         });
+        return response;
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the voting period (index, kind, starting position) and related information (position, remaining) of the next block.Useful to craft operations that will be valid in the next block
+     * Returns the voting period (index, kind, starting position) and related information (position, remaining) of the next block.Useful to craft operations that will be valid in the next block
      * @example getSuccessorPeriod() will default to successor voting period for /main/chains/block/head.
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-successor-period
      */
-    getSuccessorPeriod() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            const response = yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/successor_period`),
-                method: 'GET',
-            });
-            return response;
+    async getSuccessorPeriod({ block, } = defaultRPCOptions) {
+        const response = await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/successor_period`),
+            method: 'GET',
         });
+        return response;
     }
     /**
      * @param id Sapling state ID
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the root and a diff of a state starting from an optional offset which is zero by default
+     * Returns the root and a diff of a state starting from an optional offset which is zero by default
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-sapling-sapling-state-id-get-diff
      */
-    getSaplingDiffById(id_1) {
-        return __awaiter(this, arguments, void 0, function* (id, { block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/sapling/${id}/get_diff`),
-                method: 'GET',
-            });
+    async getSaplingDiffById(id, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/sapling/${id}/get_diff`),
+            method: 'GET',
         });
     }
     /**
      * @param contract address of the contract we want to get the sapling diff
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the root and a diff of a state starting from an optional offset which is zero by default
+     * Returns the root and a diff of a state starting from an optional offset which is zero by default
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-single-sapling-get-diff
      */
-    getSaplingDiffByContract(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/single_sapling_get_diff`),
-                method: 'GET',
-            });
+    async getSaplingDiffByContract(contract, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/single_sapling_get_diff`),
+            method: 'GET',
         });
     }
     /**
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description get current and next protocol
+     * get current and next protocol
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-protocols
      */
-    getProtocols() {
-        return __awaiter(this, arguments, void 0, function* ({ block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/protocols`),
-                method: 'GET',
-            });
+    async getProtocols({ block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/protocols`),
+            method: 'GET',
         });
     }
     /**
-     * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description get current and next protocol
+     * @param protocol the protocol hash to look up (default to empty string)
+     * get current and next protocol
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-protocols
      */
-    getProtocolActivations() {
-        return __awaiter(this, arguments, void 0, function* (protocol = '') {
-            if (protocol) {
-                const protocolValidation = validateProtocol(protocol);
-                if (protocolValidation !== ValidationResult.VALID) {
-                    throw new InvalidProtocolHashError(protocol, protocolValidation);
-                }
+    async getProtocolActivations(protocol = '') {
+        if (protocol) {
+            const protocolValidation = validateProtocol(protocol);
+            if (protocolValidation !== ValidationResult.VALID) {
+                throw new InvalidProtocolHashError(protocol, protocolValidation);
             }
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/protocols/${protocol}`),
-                method: 'GET',
-            });
+        }
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/protocols/${protocol}`),
+            method: 'GET',
         });
     }
     /**
      * @param contract address of the contract we want to retrieve storage information of
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the used storage space of the contract
+     * Access the used storage space of the contract
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getStorageUsedSpace(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/storage/used_space`),
-                method: 'GET',
-            });
+    async getStorageUsedSpace(contract, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/storage/used_space`),
+            method: 'GET',
         });
     }
     /**
      * @param contract address of the contract we want to retrieve storage information of
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the paid storage space of the contract
+     * Access the paid storage space of the contract
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
      */
-    getStoragePaidSpace(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/storage/paid_space`),
-                method: 'GET',
-            });
+    async getStoragePaidSpace(contract, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/storage/paid_space`),
+            method: 'GET',
         });
     }
     /**
      * @param contract implicit or originated address we want to retrieve ticket balance of
      * @param ticket object to specify a ticket by ticketer, content type and content
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the contract's balance of ticket with specified ticketer, content type, and content.
+     * Access the contract's balance of ticket with specified ticketer, content type, and content.
      * @example ticket { ticketer: 'address', content_type: { prim: "string" }, content: { string: 'ticket1' } }
      * @see https://tezos.gitlab.io/protocols/016_mumbai.html#rpc-changes
      */
-    getTicketBalance(contract_1, ticket_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, ticket, { block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/ticket_balance`),
-                method: 'POST',
-            }, ticket);
-        });
+    async getTicketBalance(contract, ticket, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/ticket_balance`),
+            method: 'POST',
+        }, ticket);
     }
     /**
      * @param contract originated address we want to retrieve ticket balances of
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Access the complete list of tickets owned by the given contract by scanning the contract's storage.
+     * Access the complete list of tickets owned by the given contract by scanning the contract's storage.
      * @see https://tezos.gitlab.io/protocols/016_mumbai.html#rpc-changes
      */
-    getAllTicketBalances(contract_1) {
-        return __awaiter(this, arguments, void 0, function* (contract, { block } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/all_ticket_balances`),
-                method: 'GET',
-            });
+    async getAllTicketBalances(contract, { block } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/all_ticket_balances`),
+            method: 'GET',
         });
     }
     /**
-     * @description Returns the cycle at which the launch of the Adaptive Issuance feature is set to happen. A result of null means that the feature is not yet set to launch.
+     * Returns the cycle at which the launch of the Adaptive Issuance feature is set to happen. A result of null means that the feature is not yet set to launch.
      * @param options contains generic configuration for rpc calls to specified block (default to head)
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-adaptive-issuance-launch-cycle
      */
-    getAdaptiveIssuanceLaunchCycle() {
-        return __awaiter(this, arguments, void 0, function* ({ block, } = defaultRPCOptions) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/adaptive_issuance_launch_cycle`),
-                method: 'GET',
-            });
+    async getAdaptiveIssuanceLaunchCycle({ block, } = defaultRPCOptions) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/adaptive_issuance_launch_cycle`),
+            method: 'GET',
         });
     }
     /**
-     * @description List the prevalidated operations in mempool (accessibility of mempool depends on each rpc endpoint)
+     * List the prevalidated operations in mempool (accessibility of mempool depends on each rpc endpoint)
      * @param args has 5 optional properties
      * @default args { version: '2', validated: true, refused: true, outdated, true, branchRefused: true, branchDelayed: true, validationPass: undefined, source: undefined, operationHash: undefined }
      * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/tallinn-mempool-openapi-rc.json
      */
-    getPendingOperations() {
-        return __awaiter(this, arguments, void 0, function* (args = {}) {
-            return this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/mempool/pending_operations`),
-                method: 'GET',
-                query: args,
-            });
+    async getPendingOperations(args = {}) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/mempool/pending_operations`),
+            method: 'GET',
+            query: args,
+        });
+    }
+    /**
+     * Returns the current mempool fee filter configuration.
+     *
+     * On Tezos L1 these values commonly resemble the historical fee defaults used by clients.
+     * On Tezos X / Tezlink, the same fields are used for estimation but may differ materially,
+     * especially the byte fee and the gas-price component.
+     *
+     * @param args optional query arguments for the mempool/filter endpoint
+     */
+    async getMempoolFilter(args = {}) {
+        return this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/mempool/filter`),
+            method: 'GET',
+            query: args,
         });
     }
     /**
      * @param delegate delegate address which we want to retrieve active staking parameters
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the currently active staking parameters for the given delegate
+     * Returns the currently active staking parameters for the given delegate
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh-active-staking-parameters
      */
-    getActiveStakingParameters(delegate_1) {
-        return __awaiter(this, arguments, void 0, function* (delegate, { block } = defaultRPCOptions) {
-            return yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates/${delegate}/active_staking_parameters`),
-                method: 'GET',
-            });
+    async getActiveStakingParameters(delegate, { block } = defaultRPCOptions) {
+        return await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates/${delegate}/active_staking_parameters`),
+            method: 'GET',
         });
     }
     /**
      * @param delegate delegate address which we want to retrieve pending staking parameters
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the pending values for the given delegate's staking parameters
+     * Returns the pending values for the given delegate's staking parameters
      * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh-pending-staking-parameters
      */
-    getPendingStakingParameters(delegate_1) {
-        return __awaiter(this, arguments, void 0, function* (delegate, { block } = defaultRPCOptions) {
-            return yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates/${delegate}/pending_staking_parameters`),
-                method: 'GET',
-            });
+    async getPendingStakingParameters(delegate, { block } = defaultRPCOptions) {
+        return await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/delegates/${delegate}/pending_staking_parameters`),
+            method: 'GET',
         });
     }
     /**
      * @param destination address to retrieve the index for
      * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * @description Returns the index assigned to the address if it was indexed by the opcode INDEX_ADDRESS, otherwise returns null
+     * Returns the index assigned to the address if it was indexed by the opcode INDEX_ADDRESS, otherwise returns null
      * @see https://octez.tezos.com/docs/alpha/rpc.html#get-block-id-context-destination-destination-id-index
      */
-    getDestinationIndex(destination_1) {
-        return __awaiter(this, arguments, void 0, function* (destination, { block } = defaultRPCOptions) {
-            return yield this.httpBackend.createRequest({
-                url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/destination/${destination}/index`),
-                method: 'GET',
-            });
+    async getDestinationIndex(destination, { block } = defaultRPCOptions) {
+        return await this.httpBackend.createRequest({
+            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/destination/${destination}/index`),
+            method: 'GET',
         });
     }
 }