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

package/dist/lib/taquito/src/prepare/prepare-provider.js

@@ -1,1049 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _PrepareProvider_counters;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrepareProvider = void 0;
-const rpc_1 = require("@taquito/rpc");
-const types_1 = require("../operations/types");
-const constants_1 = require("../constants");
-const errors_1 = require("../errors");
-const core_1 = require("@taquito/core");
-const contract_1 = require("../contract");
-const provider_1 = require("../provider");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const utils_1 = require("@taquito/utils");
-const mergeLimits = (userDefinedLimit, defaultLimits) => {
-    return {
-        fee: userDefinedLimit.fee ?? defaultLimits.fee,
-        gasLimit: userDefinedLimit.gasLimit ?? defaultLimits.gasLimit,
-        storageLimit: userDefinedLimit.storageLimit ?? defaultLimits.storageLimit,
-    };
-};
-/**
- * PrepareProvider is a utility class to output the prepared format of an operation
- */
-class PrepareProvider extends provider_1.Provider {
-    constructor(context) {
-        super(context);
-        this.context = context;
-        _PrepareProvider_counters.set(this, void 0);
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-    }
-    async getBlockHash(block) {
-        return this.context.readProvider.getBlockHash(block ?? 'head~2');
-    }
-    async getProtocolHash() {
-        return this.context.readProvider.getNextProtocol('head');
-    }
-    async getHeadCounter(pkh) {
-        return this.context.readProvider.getCounter(pkh, 'head') ?? '0';
-    }
-    adjustGasForManagerOperations(gasLimitBlock, gaslimitOp, opsNeedingGasLimitPatch, explicitGasLimitTotal = new bignumber_js_1.default(0)) {
-        if (opsNeedingGasLimitPatch <= 0) {
-            return gaslimitOp;
-        }
-        const remainingBlockGas = gasLimitBlock.minus(explicitGasLimitTotal);
-        if (remainingBlockGas.lte(0)) {
-            return new bignumber_js_1.default(0);
-        }
-        return bignumber_js_1.default.min(gaslimitOp, remainingBlockGas.div(opsNeedingGasLimitPatch).integerValue(bignumber_js_1.default.ROUND_DOWN));
-    }
-    getOperationLimits(constants, options = {}) {
-        const { hard_gas_limit_per_operation, hard_gas_limit_per_block, hard_storage_limit_per_operation, } = constants;
-        return {
-            fee: 0,
-            gasLimit: this.adjustGasForManagerOperations(hard_gas_limit_per_block, hard_gas_limit_per_operation, options.opsNeedingGasLimitPatch ?? 0, options.explicitGasLimitTotal).toNumber(),
-            storageLimit: hard_storage_limit_per_operation.toNumber(),
-        };
-    }
-    async getOperationLimitsForManagerOperation(constants, publicKeyHash, kind, gasLimit) {
-        const revealNeeded = await this.isRevealOpNeeded([{ kind }], publicKeyHash);
-        return this.getOperationLimits(constants, {
-            opsNeedingGasLimitPatch: typeof gasLimit === 'undefined' ? 1 : 0,
-            explicitGasLimitTotal: revealNeeded
-                ? new bignumber_js_1.default((0, constants_1.getRevealGasLimit)(publicKeyHash))
-                : undefined,
-        });
-    }
-    getFee(op, pkh, headCounter) {
-        if (!__classPrivateFieldGet(this, _PrepareProvider_counters, "f")[pkh] || __classPrivateFieldGet(this, _PrepareProvider_counters, "f")[pkh] < headCounter) {
-            __classPrivateFieldGet(this, _PrepareProvider_counters, "f")[pkh] = headCounter;
-        }
-        const opCounter = ++__classPrivateFieldGet(this, _PrepareProvider_counters, "f")[pkh];
-        return {
-            counter: `${opCounter}`,
-            fee: typeof op.fee === 'undefined' ? '0' : `${op.fee}`,
-            gas_limit: typeof op.gas_limit === 'undefined' ? '0' : `${op.gas_limit}`,
-            storage_limit: typeof op.storage_limit === 'undefined' ? '0' : `${op.storage_limit}`,
-        };
-    }
-    getSource(op, pkh, source) {
-        return { source: typeof op.source === 'undefined' ? source || pkh : op.source };
-    }
-    async addRevealOperationIfNeeded(operation, publicKeyHash) {
-        if ((0, types_1.isOpRequireReveal)(operation)) {
-            const ops = [operation];
-            const { publicKey, pkh } = await this.getKeys();
-            if (await this.isAccountRevealRequired(publicKeyHash)) {
-                if (!publicKey) {
-                    throw new core_1.PublicKeyNotFoundError(pkh);
-                }
-                const [, pkhPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(pkh, utils_1.publicKeyHashPrefixes);
-                ops.unshift(await (0, contract_1.createRevealOperation)({
-                    fee: (0, constants_1.getRevealFee)(pkh),
-                    storageLimit: constants_1.REVEAL_STORAGE_LIMIT,
-                    gasLimit: (0, constants_1.getRevealGasLimit)(pkh),
-                    proof: pkhPrefix === utils_1.PrefixV2.BLS12_381PublicKeyHash
-                        ? (await this.signer.provePossession()).prefixSig
-                        : undefined,
-                }, publicKeyHash, publicKey));
-                return ops;
-            }
-        }
-        return operation;
-    }
-    async getKeys() {
-        const isSignerConfigured = this.context.isAnySignerConfigured();
-        return {
-            pkh: isSignerConfigured ? await this.signer.publicKeyHash() : await this.context.wallet.pkh(),
-            publicKey: isSignerConfigured
-                ? await this.signer.publicKey()
-                : await this.context.wallet.pk(),
-        };
-    }
-    convertIntoArray(op) {
-        if (Array.isArray(op)) {
-            return [...op];
-        }
-        else {
-            return [op];
-        }
-    }
-    getSingleManagerOperationSimulation(ops, gasLimit) {
-        if (typeof gasLimit !== 'undefined' || ops.length === 0) {
-            return;
-        }
-        return {
-            gasLimitPatchableIndexes: [ops.length - 1],
-        };
-    }
-    withSimulationMetadata(preparedOperation, simulation) {
-        if (!simulation) {
-            return preparedOperation;
-        }
-        // Keep retry bookkeeping available to estimation without changing the
-        // enumerable shape of single-op prepared results.
-        Object.defineProperty(preparedOperation, 'simulation', {
-            value: simulation,
-            configurable: true,
-            enumerable: false,
-            writable: true,
-        });
-        return preparedOperation;
-    }
-    constructOpContents(ops, headCounter, pkh, source, currentVotingPeriod) {
-        return ops.map((op) => {
-            switch (op.kind) {
-                case rpc_1.OpKind.ACTIVATION:
-                case rpc_1.OpKind.DRAIN_DELEGATE:
-                    return {
-                        ...op,
-                    };
-                case rpc_1.OpKind.ORIGINATION:
-                    return {
-                        ...op,
-                        balance: typeof op.balance !== 'undefined' ? `${op.balance}` : '0',
-                        ...this.getSource(op, pkh, source),
-                        ...this.getFee(op, pkh, headCounter),
-                    };
-                case rpc_1.OpKind.TRANSACTION: {
-                    const cops = {
-                        ...op,
-                        amount: typeof op.amount !== 'undefined' ? `${op.amount}` : '0',
-                        ...this.getSource(op, pkh, source),
-                        ...this.getFee(op, pkh, headCounter),
-                    };
-                    if (cops.source.toLowerCase().startsWith('kt1')) {
-                        throw new core_1.DeprecationError(`KT1 addresses are not supported as source since ${constants_1.Protocols.PsBabyM1}`);
-                    }
-                    return cops;
-                }
-                case rpc_1.OpKind.REVEAL:
-                case rpc_1.OpKind.DELEGATION:
-                case rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT:
-                case rpc_1.OpKind.UPDATE_CONSENSUS_KEY:
-                case rpc_1.OpKind.UPDATE_COMPANION_KEY:
-                case rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES:
-                case rpc_1.OpKind.SMART_ROLLUP_ORIGINATE:
-                case rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE:
-                    return {
-                        ...op,
-                        ...this.getSource(op, pkh, source),
-                        ...this.getFee(op, pkh, headCounter),
-                    };
-                case rpc_1.OpKind.TRANSFER_TICKET:
-                    return {
-                        ...op,
-                        ticket_amount: `${op.ticket_amount}`,
-                        ...this.getSource(op, pkh, source),
-                        ...this.getFee(op, pkh, headCounter),
-                    };
-                case rpc_1.OpKind.INCREASE_PAID_STORAGE:
-                    return {
-                        ...op,
-                        amount: `${op.amount}`,
-                        ...this.getSource(op, pkh, source),
-                        ...this.getFee(op, pkh, headCounter),
-                    };
-                case rpc_1.OpKind.BALLOT:
-                    if (currentVotingPeriod === undefined) {
-                        throw new errors_1.RPCResponseError(`Failed to get the current voting period index`);
-                    }
-                    return {
-                        ...op,
-                        period: currentVotingPeriod?.voting_period.index,
-                        ...this.getSource(op, pkh, source),
-                    };
-                case rpc_1.OpKind.PROPOSALS:
-                    if (currentVotingPeriod === undefined) {
-                        throw new errors_1.RPCResponseError(`Failed to get the current voting period index`);
-                    }
-                    return {
-                        ...op,
-                        period: currentVotingPeriod?.voting_period.index,
-                        ...this.getSource(op, pkh, source),
-                    };
-                default:
-                    throw new core_1.InvalidOperationKindError(op.kind);
-            }
-        });
-    }
-    /**
-     *
-     * Method to prepare an activation operation
-     * @returns a PreparedOperation object
-     */
-    async activate({ pkh, secret }) {
-        const op = await (0, contract_1.createActivationOperation)({
-            pkh,
-            secret,
-        });
-        const ops = this.convertIntoArray(op);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return preparedOperation;
-    }
-    /**
-     *
-     * Method to prepare a reveal operation
-     * @returns a PreparedOperation object
-     */
-    async reveal({ fee, gasLimit, storageLimit, proof }) {
-        const { pkh, publicKey } = await this.getKeys();
-        if (!publicKey) {
-            throw new core_1.PublicKeyNotFoundError(pkh);
-        }
-        const [, pkhPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(pkh, utils_1.publicKeyHashPrefixes);
-        if (pkhPrefix === utils_1.PrefixV2.BLS12_381PublicKeyHash) {
-            if (proof) {
-                (0, utils_1.b58DecodeAndCheckPrefix)(proof, [utils_1.PrefixV2.BLS12_381Signature]); // validate proof to be a bls signature
-            }
-            else {
-                const { prefixSig } = await this.signer.provePossession();
-                proof = prefixSig;
-            }
-        }
-        else {
-            if (proof) {
-                throw new core_1.ProhibitedActionError('Proof field is only allowed to reveal a bls account ');
-            }
-        }
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimits(protocolConstants);
-        const mergedEstimates = mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS);
-        const op = await (0, contract_1.createRevealOperation)({
-            fee: mergedEstimates.fee,
-            gasLimit: mergedEstimates.gasLimit,
-            storageLimit: mergedEstimates.storageLimit,
-            proof,
-        }, pkh, publicKey);
-        const ops = this.convertIntoArray(op);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return preparedOperation;
-    }
-    /**
-     *
-     * Method to prepare an origination operation
-     * @param source string or undefined source pkh
-     * @returns a PreparedOperation object
-     */
-    async originate({ fee, storageLimit, gasLimit, ...rest }, source) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.ORIGINATION, gasLimit);
-        const op = await (0, contract_1.createOriginationOperation)(await this.context.parser.prepareCodeOrigination({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        }));
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a transaction operation
-     * @returns a PreparedOperation object
-     */
-    async transaction({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.TRANSACTION, gasLimit);
-        const op = await (0, contract_1.createTransferOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a stake pseudo-operation
-     * @returns a PreparedOperation object
-     */
-    async stake({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.TRANSACTION, gasLimit);
-        const op = await (0, contract_1.createTransferOperation)({
-            ...rest,
-            to: pkh,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-            parameter: {
-                entrypoint: 'stake',
-                value: {
-                    prim: 'Unit',
-                },
-            },
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a unstake pseudo-operation
-     * @returns a PreparedOperation object
-     */
-    async unstake({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.TRANSACTION, gasLimit);
-        const op = await (0, contract_1.createTransferOperation)({
-            ...rest,
-            to: pkh,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-            parameter: {
-                entrypoint: 'unstake',
-                value: { prim: 'Unit' },
-            },
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a finalize_unstake pseudo-operation
-     * @returns a PreparedOperation object
-     */
-    async finalizeUnstake({ fee, storageLimit, gasLimit, to, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.TRANSACTION, gasLimit);
-        const op = await (0, contract_1.createTransferOperation)({
-            ...rest,
-            to: to ? to : pkh,
-            amount: 0,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-            parameter: {
-                entrypoint: 'finalize_unstake',
-                value: { prim: 'Unit' },
-            },
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a delegation operation
-     * @returns a PreparedOperation object
-     */
-    async delegation({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.DELEGATION, gasLimit);
-        const op = await (0, contract_1.createSetDelegateOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a register delegate operation
-     * @param source string or undefined source pkh
-     * @returns a PreparedOperation object
-     */
-    async registerDelegate({ fee, storageLimit, gasLimit }, source) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.DELEGATION, gasLimit);
-        const mergedEstimates = mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS);
-        const op = await (0, contract_1.createRegisterDelegateOperation)({
-            fee: mergedEstimates.fee,
-            storageLimit: mergedEstimates.storageLimit,
-            gasLimit: mergedEstimates.gasLimit,
-        }, pkh);
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a register_global_constant operation
-     * @returns a PreparedOperation object
-     */
-    async registerGlobalConstant({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT, gasLimit);
-        const op = await (0, contract_1.createRegisterGlobalConstantOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare an update_consensus_key operation
-     * @param source string or undefined source pkh
-     * @returns a PreparedOperation object
-     */
-    async updateConsensusKey({ fee, storageLimit, gasLimit, ...rest }, source) {
-        const { pkh } = await this.getKeys();
-        const [, pkPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(rest.pk, utils_1.publicKeyPrefixes);
-        if (pkPrefix === utils_1.PrefixV2.BLS12_381PublicKey) {
-            if (!rest.proof) {
-                throw new core_1.InvalidProofError('Proof is required to set a bls account as consensus key ');
-            }
-        }
-        else {
-            if (rest.proof) {
-                throw new core_1.ProhibitedActionError('Proof field is only allowed for a bls account as consensus key');
-            }
-        }
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.UPDATE_CONSENSUS_KEY, gasLimit);
-        const op = await (0, contract_1.createUpdateConsensusKeyOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare an update_companion_key operation
-     * @param source string or undefined source pkh
-     * @returns a PreparedOperation object
-     */
-    async updateCompanionKey({ fee, storageLimit, gasLimit, ...rest }, source) {
-        const { pkh } = await this.getKeys();
-        const [, pkPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(rest.pk, utils_1.publicKeyPrefixes);
-        if (pkPrefix !== utils_1.PrefixV2.BLS12_381PublicKey) {
-            throw new core_1.ProhibitedActionError('companion key must be a bls account');
-        }
-        if (!rest.proof) {
-            throw new core_1.InvalidProofError('Proof is required to set a bls account as companion key ');
-        }
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.UPDATE_COMPANION_KEY, gasLimit);
-        const op = await (0, contract_1.createUpdateCompanionKeyOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare an increase_paid_storage operation
-     * @returns a PreparedOperation object
-     */
-    async increasePaidStorage({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.INCREASE_PAID_STORAGE, gasLimit);
-        const op = await (0, contract_1.createIncreasePaidStorageOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a ballot operation
-     * @param params ballot operation parameters
-     * @returns a PreparedOperation object
-     */
-    async ballot(params) {
-        const { pkh } = await this.getKeys();
-        const op = await (0, contract_1.createBallotOperation)({
-            ...params,
-        });
-        const ops = this.convertIntoArray(op);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        let currentVotingPeriod;
-        try {
-            currentVotingPeriod = await this.rpc.getCurrentPeriod();
-        }
-        catch (e) {
-            throw new errors_1.RPCResponseError('Failed to get the current voting period index');
-        }
-        const contents = this.constructOpContents(ops, headCounter, pkh, params.source, currentVotingPeriod);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return preparedOperation;
-    }
-    /**
-     *
-     * Method to prepare a proposals operation
-     * @param params proposals operation parameters
-     * @returns a PreparedOperation object
-     */
-    async proposals(params) {
-        const { pkh } = await this.getKeys();
-        const op = await (0, contract_1.createProposalsOperation)({
-            ...params,
-        });
-        const ops = this.convertIntoArray(op);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        let currentVotingPeriod;
-        try {
-            currentVotingPeriod = await this.rpc.getCurrentPeriod();
-        }
-        catch (e) {
-            throw new errors_1.RPCResponseError('Failed to get the current voting period index');
-        }
-        const contents = this.constructOpContents(ops, headCounter, pkh, params.source, currentVotingPeriod);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return preparedOperation;
-    }
-    /**
-     *
-     * Method to prepare a drain_delegate operation
-     * @param params drainDelegate operation parameters
-     * @returns a PreparedOperation object
-     */
-    async drainDelegate(params, source) {
-        const { pkh } = await this.getKeys();
-        const op = await (0, contract_1.createDrainDelegateOperation)({
-            ...params,
-        });
-        const ops = this.convertIntoArray(op);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return preparedOperation;
-    }
-    /**
-     *
-     * Method to prepare a transfer_ticket operation
-     * @returns a PreparedOperation object
-     */
-    async transferTicket({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.TRANSFER_TICKET, gasLimit);
-        const op = await (0, contract_1.createTransferTicketOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a smart_rollup_add_messages operation
-     * @returns a PreparedOperation object
-     */
-    async smartRollupAddMessages({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES, gasLimit);
-        const op = await (0, contract_1.createSmartRollupAddMessagesOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a smart_rollup_originate operation
-     * @returns a PreparedOperation object
-     */
-    async smartRollupOriginate({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.SMART_ROLLUP_ORIGINATE, gasLimit);
-        const op = await (0, contract_1.createSmartRollupOriginateOperation)({
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-            ...rest,
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a smart_rollup_execute_outbox_message operation
-     * @returns a PreparedOperation object
-     */
-    async smartRollupExecuteOutboxMessage({ fee, storageLimit, gasLimit, ...rest }) {
-        const { pkh } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE, gasLimit);
-        const op = await (0, contract_1.createSmartRollupExecuteOutboxMessageOperation)({
-            ...rest,
-            ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
-        });
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, gasLimit));
-    }
-    /**
-     *
-     * Method to prepare a batch operation
-     * @param batchParams batch operation parameters
-     * @returns a PreparedOperation object
-     */
-    async batch(batchParams, estimates) {
-        const { pkh, publicKey } = await this.getKeys();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const revealNeeded = await this.isRevealOpNeeded(batchParams, pkh);
-        const explicitGasLimitTotal = batchParams.reduce((acc, op) => (0, types_1.isOpWithFee)(op) && typeof op.gasLimit !== 'undefined' ? acc.plus(op.gasLimit) : acc, revealNeeded ? new bignumber_js_1.default((0, constants_1.getRevealGasLimit)(pkh)) : new bignumber_js_1.default(0));
-        const DEFAULT_PARAMS = this.getOperationLimits(protocolConstants, {
-            opsNeedingGasLimitPatch: batchParams.filter((op) => (0, types_1.isOpWithFee)(op) && typeof op.gasLimit === 'undefined').length,
-            explicitGasLimitTotal,
-        });
-        const ops = [];
-        const gasLimitPatchableFlags = [];
-        if (!estimates) {
-            for (const op of batchParams) {
-                if ((0, types_1.isOpWithFee)(op)) {
-                    const limits = mergeLimits(op, DEFAULT_PARAMS);
-                    ops.push(await this.getRPCOp({ ...op, ...limits }));
-                    gasLimitPatchableFlags.push(typeof op.gasLimit === 'undefined');
-                }
-                else {
-                    ops.push({ ...op });
-                    gasLimitPatchableFlags.push(false);
-                }
-            }
-        }
-        else {
-            for (const op of batchParams) {
-                if ((0, types_1.isOpWithFee)(op)) {
-                    const e = estimates.shift();
-                    const limits = mergeLimits(op, {
-                        fee: e.suggestedFeeMutez,
-                        storageLimit: e.storageLimit,
-                        gasLimit: e.gasLimit,
-                    });
-                    ops.push(await this.getRPCOp({ ...op, ...limits }));
-                    gasLimitPatchableFlags.push(false);
-                }
-                else {
-                    ops.push({ ...op });
-                    gasLimitPatchableFlags.push(false);
-                }
-            }
-        }
-        if (revealNeeded) {
-            if (!publicKey) {
-                throw new core_1.PublicKeyNotFoundError(pkh);
-            }
-            const [, pkhPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(pkh, utils_1.publicKeyHashPrefixes);
-            ops.unshift(await (0, contract_1.createRevealOperation)({
-                fee: (0, constants_1.getRevealFee)(pkh),
-                storageLimit: constants_1.REVEAL_STORAGE_LIMIT,
-                gasLimit: (0, constants_1.getRevealGasLimit)(pkh),
-                proof: pkhPrefix === utils_1.PrefixV2.BLS12_381PublicKeyHash
-                    ? (await this.signer.provePossession()).prefixSig
-                    : undefined,
-            }, pkh, publicKey));
-            gasLimitPatchableFlags.unshift(false);
-        }
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const contents = this.constructOpContents(ops, headCounter, pkh);
-        const gasLimitPatchableIndexes = gasLimitPatchableFlags.flatMap((isPatchable, index) => isPatchable ? [index] : []);
-        return {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-            simulation: gasLimitPatchableIndexes.length > 0
-                ? {
-                    gasLimitPatchableIndexes,
-                }
-                : undefined,
-        };
-    }
-    /**
-     *
-     * Method to prepare a contract call operation
-     * @param contractMethod ContractMethodObject retrieved from smart contract
-     * @returns a PreparedOperation object
-     */
-    async contractCall(contractMethod) {
-        const hash = await this.getBlockHash();
-        const protocol = await this.getProtocolHash();
-        const { pkh } = await this.getKeys();
-        __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
-        const headCounter = parseInt(await this.getHeadCounter(pkh), 10);
-        const params = contractMethod.toTransferParams();
-        const protocolConstants = await this.context.readProvider.getProtocolConstants('head');
-        const DEFAULT_PARAMS = await this.getOperationLimitsForManagerOperation(protocolConstants, pkh, rpc_1.OpKind.TRANSACTION, params.gasLimit);
-        const estimateLimits = mergeLimits({
-            fee: params.fee,
-            storageLimit: params.storageLimit,
-            gasLimit: params.gasLimit,
-        }, DEFAULT_PARAMS);
-        const op = {
-            kind: rpc_1.OpKind.TRANSACTION,
-            fee: params.fee ?? estimateLimits.fee,
-            gas_limit: params.gasLimit ?? estimateLimits.gasLimit,
-            storage_limit: params.storageLimit ?? estimateLimits.storageLimit,
-            amount: String(params.amount),
-            destination: params.to,
-            parameters: params.parameter,
-        };
-        const operation = await this.addRevealOperationIfNeeded(op, pkh);
-        const ops = this.convertIntoArray(operation);
-        const contents = this.constructOpContents(ops, headCounter, pkh);
-        const preparedOperation = {
-            opOb: {
-                branch: hash,
-                contents,
-                protocol,
-            },
-            counter: headCounter,
-        };
-        return this.withSimulationMetadata(preparedOperation, this.getSingleManagerOperationSimulation(ops, params.gasLimit));
-    }
-    /**
-     *
-     * Method to convert a PreparedOperation to the params needed for the preapplyOperation method
-     * @param prepared a Prepared Operation
-     * @returns a PreapplyParams object
-     */
-    async toPreapply(prepared) {
-        const { opOb: { contents, branch, protocol }, } = prepared;
-        const forgeParams = this.toForge(prepared);
-        const forged = await this.context.forger.forge(forgeParams);
-        const sig = await this.context.signer.sign(forged, new Uint8Array([3]));
-        return [{ contents, branch, protocol, signature: sig.prefixSig }];
-    }
-    /**
-     *
-     * Method to convert a PreparedOperation to the params needed for forging
-     * @param param a Prepared Operation
-     * @returns a ForgeParams object
-     */
-    toForge({ opOb: { contents, branch } }) {
-        return {
-            branch,
-            contents,
-        };
-    }
-}
-exports.PrepareProvider = PrepareProvider;
-_PrepareProvider_counters = new WeakMap();