@taquito/wallet-connect 24.3.0-beta.2 → 24.3.0-beta.3

package/dist/lib/taquito-rpc/src/taquito-rpc.js

@@ -1,990 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcClient = exports.VERSION = exports.OpKind = exports.RpcClientCache = exports.defaultRPCOptions = exports.defaultChain = exports.castToBigNumber = void 0;
-/**
- * @packageDocumentation
- * @module @taquito/rpc
- */
-const http_utils_1 = require("@taquito/http-utils");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const rpc_client_interface_1 = require("./rpc-client-interface");
-const utils_1 = require("./utils/utils");
-const utils_2 = require("@taquito/utils");
-const core_1 = require("@taquito/core");
-var utils_3 = require("./utils/utils");
-Object.defineProperty(exports, "castToBigNumber", { enumerable: true, get: function () { return utils_3.castToBigNumber; } });
-var rpc_client_interface_2 = require("./rpc-client-interface");
-Object.defineProperty(exports, "defaultChain", { enumerable: true, get: function () { return rpc_client_interface_2.defaultChain; } });
-Object.defineProperty(exports, "defaultRPCOptions", { enumerable: true, get: function () { return rpc_client_interface_2.defaultRPCOptions; } });
-var rpc_cache_1 = require("./rpc-client-modules/rpc-cache");
-Object.defineProperty(exports, "RpcClientCache", { enumerable: true, get: function () { return rpc_cache_1.RpcClientCache; } });
-__exportStar(require("./types"), exports);
-var opkind_1 = require("./opkind");
-Object.defineProperty(exports, "OpKind", { enumerable: true, get: function () { return opkind_1.OpKind; } });
-var version_1 = require("./version");
-Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
-/***
- * RpcClient allows interaction with Tezos network through an rpc node
- */
-class RpcClient {
-    /**
-     *
-     * @param url rpc root url
-     * @param chain chain (default main)
-     * @param httpBackend Http backend that issue http request.
-     * You can override it by providing your own if you which to hook in the request/response
-     *
-     * @example new RpcClient('https://mainnet.tezos.ecadinfra.com/', 'main') this will use https://mainnet.tezos.ecadinfra.com//chains/main
-     */
-    constructor(url, chain = rpc_client_interface_1.defaultChain, httpBackend = new http_utils_1.HttpBackend()) {
-        this.url = url;
-        this.chain = chain;
-        this.httpBackend = httpBackend;
-    }
-    createURL(path) {
-        // Trim trailing slashes because it is assumed to be included in path
-        // the regex solution is prone to ReDoS. Please see: https://stackoverflow.com/questions/6680825/return-string-without-trailing-slash#comment124306698_6680877
-        // We also got a CodeQL error for the regex based solution
-        let rootUrl = this.url;
-        while (rootUrl.endsWith('/')) {
-            rootUrl = rootUrl.slice(0, -1);
-        }
-        return `${rootUrl}${path}`;
-    }
-    validateAddress(address) {
-        const addressValidation = (0, utils_2.validateAddress)(address);
-        if (addressValidation !== utils_2.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(address, addressValidation);
-        }
-    }
-    validateContract(address) {
-        const addressValidation = (0, utils_2.validateContractAddress)(address);
-        if (addressValidation !== utils_2.ValidationResult.VALID) {
-            throw new core_1.InvalidContractAddressError(address, addressValidation);
-        }
-    }
-    /**
-     * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * Get the block's hash, its unique identifier.
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-hash
-     */
-    async getBlockHash({ block } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getLiveBlocks({ block } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getBalance(address, { block } = rpc_client_interface_1.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_js_1.default(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)
-     * 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 } = rpc_client_interface_1.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_js_1.default(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)
-     * 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
-     */
-    async getBalanceAndFrozenBonds(address, { block } = rpc_client_interface_1.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_js_1.default(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)
-     * 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
-     */
-    async getSpendableAndFrozenBonds(address, { block } = rpc_client_interface_1.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_js_1.default(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)
-     * 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
-     */
-    async getFullBalance(address, { block } = rpc_client_interface_1.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_js_1.default(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)
-     * 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
-     */
-    async getStakedBalance(address, { block } = rpc_client_interface_1.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_js_1.default(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)
-     * 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
-     */
-    async getUnstakedFinalizableBalance(address, { block } = rpc_client_interface_1.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_js_1.default(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)
-     * 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
-     */
-    async getUnstakedFrozenBalance(address, { block } = rpc_client_interface_1.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_js_1.default(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)
-     * 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
-     */
-    async getUnstakeRequests(address, { block } = rpc_client_interface_1.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 = (0, utils_1.castToBigNumber)({ amount }, ['amount']);
-                    return {
-                        ...rest,
-                        amount: castedToBigNumber.amount,
-                    };
-                }),
-                unfinalizable: {
-                    delegate: response.unfinalizable.delegate,
-                    requests: response.unfinalizable.requests.map(({ amount, cycle }) => {
-                        const castedToBigNumber = (0, utils_1.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)
-     * Access the data of the contract.
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-storage
-     */
-    async getStorage(address, { block } = rpc_client_interface_1.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)
-     * Access the code and data of the contract.
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-script
-     */
-    async getScript(address, { block } = rpc_client_interface_1.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)
-     * Access the script of the contract and normalize it using the requested unparsing mode.
-     */
-    async getNormalizedScript(address, unparsingMode = { unparsing_mode: 'Readable' }, { block } = rpc_client_interface_1.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)
-     * Access the complete status of a contract.
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id
-     */
-    async getContract(address, { block } = rpc_client_interface_1.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_js_1.default(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)
-     * Access the manager of an implicit contract
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-manager-key
-     */
-    async getManagerKey(address, { block } = rpc_client_interface_1.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)
-     * Access the delegate of a contract, if any
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-delegate
-     */
-    async getDelegate(address, { block } = rpc_client_interface_1.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 http_utils_1.HttpResponseError && ex.status === http_utils_1.STATUS_CODE.NOT_FOUND) {
-                delegate = null;
-            }
-            else {
-                throw ex;
-            }
-        }
-        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)
-     * 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
-     */
-    async getBigMapExpr(id, expr, { block } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getAllDelegates(args = {}, { block } = rpc_client_interface_1.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)
-     * Everything about a delegate
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-delegates-pkh
-     */
-    async getDelegates(address, { block } = rpc_client_interface_1.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 = (0, utils_1.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 = (0, utils_1.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)
-     * 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
-     */
-    async getVotingInfo(address, { block } = rpc_client_interface_1.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)
-     * All constants
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-constants
-     */
-    async getConstants({ block } = rpc_client_interface_1.defaultRPCOptions) {
-        const response = await this.httpBackend.createRequest({
-            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/constants`),
-            method: 'GET',
-        });
-        const castedResponse = (0, utils_1.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.
-     * 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..
-     */
-    async getBlock({ block, version } = rpc_client_interface_1.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)
-     * The whole block header
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-header
-     */
-    async getBlockHeader({ block } = rpc_client_interface_1.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
-     * All the metadata associated to the block
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-metadata
-     */
-    async getBlockMetadata({ block, version, } = rpc_client_interface_1.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)
-     * Retrieves the list of delegates allowed to bake a block.
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async getBakingRights(args = {}, { block } = rpc_client_interface_1.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)
-     * Retrieves the delegates allowed to attest a block
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async getAttestationRights(args = {}, { block } = rpc_client_interface_1.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)
-     * Ballots casted so far during a voting period
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-ballot-list
-     */
-    async getBallotList({ block } = rpc_client_interface_1.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)
-     * Sum of ballots casted so far during a voting period
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-ballots
-     */
-    async getBallots({ block } = rpc_client_interface_1.defaultRPCOptions) {
-        const response = await this.httpBackend.createRequest({
-            url: this.createURL(`/chains/${this.chain}/blocks/${block}/votes/ballots`),
-            method: 'GET',
-        });
-        const casted = (0, utils_1.castToBigNumber)(response, ['yay', 'nay', 'pass']);
-        return casted;
-    }
-    /**
-     * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * Current proposal under evaluation.
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-current-proposal
-     */
-    async getCurrentProposal({ block, } = rpc_client_interface_1.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)
-     * Current expected quorum.
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-current-quorum
-     */
-    async getCurrentQuorum({ block, } = rpc_client_interface_1.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)
-     * List of delegates with their voting power
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-listings
-     */
-    async getVotesListings({ block, } = rpc_client_interface_1.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_js_1.default(item.voting_power);
-            }
-            return item;
-        });
-        return response;
-    }
-    /**
-     * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * List of proposals with number of supporters
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-votes-proposals
-     */
-    async getProposals({ block } = rpc_client_interface_1.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_js_1.default(item[1]));
-        });
-        return response;
-    }
-    /**
-     * @param data operation contents to forge
-     * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * Forge an operation returning the unsigned bytes
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async forgeOperations(data, { block } = rpc_client_interface_1.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
-     * 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
-     */
-    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
-     * 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
-     */
-    async preapplyOperations(ops, { block, version } = rpc_client_interface_1.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)
-     * Return the list of entrypoints of the contract
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-context-contracts-contract-id-entrypoints
-     * @remarks version 005_PsBABY5H
-     */
-    async getEntrypoints(contract, { block } = rpc_client_interface_1.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
-     * 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
-     */
-    async simulateOperation(op, { block, version } = rpc_client_interface_1.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)
-     * Run a Michelson script in the current context
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async runCode(code, { block } = rpc_client_interface_1.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)
-     * Simulate a call to a michelson view
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async runScriptView({ unparsing_mode = 'Readable', ...rest }, { block } = rpc_client_interface_1.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)
-     * Simulate a call to a view following the TZIP-4 standard.
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async runView({ unparsing_mode = 'Readable', ...rest }, { block } = rpc_client_interface_1.defaultRPCOptions) {
-        return this.httpBackend.createRequest({
-            url: this.createURL(`/chains/${this.chain}/blocks/${block}/helpers/scripts/run_view`),
-            method: 'POST',
-        }, {
-            unparsing_mode,
-            ...rest,
-        });
-    }
-    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)
-     * 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.
-     * A safer solution to pack and sign data would be to use the `packDataBytes` function available in the `@taquito/michel-codec` package.
-     * @example packData({ data: { string: "test" }, type: { prim: "string" } })
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async packData(data, { block } = rpc_client_interface_1.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_js_1.default(gas || '');
-        if (!tryBigNumber.isNaN()) {
-            formattedGas = tryBigNumber;
-        }
-        return { gas: formattedGas, ...rest };
-    }
-    /**
-     *
-     * Return rpc root url
-     */
-    getRpcUrl() {
-        return this.url;
-    }
-    /**
-     * @param options contains generic configuration for rpc calls to specified block (default to head)
-     * 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
-     */
-    async getCurrentPeriod({ block, } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getSuccessorPeriod({ block, } = rpc_client_interface_1.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)
-     * 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 } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getSaplingDiffByContract(contract, { block } = rpc_client_interface_1.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)
-     * get current and next protocol
-     * @see https://tezos.gitlab.io/active/rpc.html#get-block-id-protocols
-     */
-    async getProtocols({ block } = rpc_client_interface_1.defaultRPCOptions) {
-        return this.httpBackend.createRequest({
-            url: this.createURL(`/chains/${this.chain}/blocks/${block}/protocols`),
-            method: 'GET',
-        });
-    }
-    /**
-     * @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
-     */
-    async getProtocolActivations(protocol = '') {
-        if (protocol) {
-            const protocolValidation = (0, utils_2.validateProtocol)(protocol);
-            if (protocolValidation !== utils_2.ValidationResult.VALID) {
-                throw new utils_2.InvalidProtocolHashError(protocol, protocolValidation);
-            }
-        }
-        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)
-     * Access the used storage space of the contract
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async getStorageUsedSpace(contract, { block } = rpc_client_interface_1.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)
-     * Access the paid storage space of the contract
-     * @see https://gitlab.com/tezos/tezos/-/blob/master/docs/api/alpha-openapi.json
-     */
-    async getStoragePaidSpace(contract, { block } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getTicketBalance(contract, ticket, { block } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getAllTicketBalances(contract, { block } = rpc_client_interface_1.defaultRPCOptions) {
-        return this.httpBackend.createRequest({
-            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/contracts/${contract}/all_ticket_balances`),
-            method: 'GET',
-        });
-    }
-    /**
-     * 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
-     */
-    async getAdaptiveIssuanceLaunchCycle({ block, } = rpc_client_interface_1.defaultRPCOptions) {
-        return this.httpBackend.createRequest({
-            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/adaptive_issuance_launch_cycle`),
-            method: 'GET',
-        });
-    }
-    /**
-     * 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
-     */
-    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)
-     * 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
-     */
-    async getActiveStakingParameters(delegate, { block } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getPendingStakingParameters(delegate, { block } = rpc_client_interface_1.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)
-     * 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
-     */
-    async getDestinationIndex(destination, { block } = rpc_client_interface_1.defaultRPCOptions) {
-        return await this.httpBackend.createRequest({
-            url: this.createURL(`/chains/${this.chain}/blocks/${block}/context/destination/${destination}/index`),
-            method: 'GET',
-        });
-    }
-}
-exports.RpcClient = RpcClient;