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

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

@@ -1,675 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcContractProvider = void 0;
-const http_utils_1 = require("@taquito/http-utils");
-const michelson_encoder_1 = require("@taquito/michelson-encoder");
-const rpc_1 = require("@taquito/rpc");
-const utils_1 = require("@taquito/utils");
-const core_1 = require("@taquito/core");
-const rpc_batch_provider_1 = require("../batch/rpc-batch-provider");
-const delegate_operation_1 = require("../operations/delegate-operation");
-const origination_operation_1 = require("../operations/origination-operation");
-const register_global_constant_operation_1 = require("../operations/register-global-constant-operation");
-const reveal_operation_1 = require("../operations/reveal-operation");
-const transaction_operation_1 = require("../operations/transaction-operation");
-const contract_1 = require("./contract");
-const errors_1 = require("./errors");
-const semantic_1 = require("./semantic");
-const transfer_ticket_operation_1 = require("../operations/transfer-ticket-operation");
-const increase_paid_storage_operation_1 = require("../operations/increase-paid-storage-operation");
-const ballot_operation_1 = require("../operations/ballot-operation");
-const drain_delegate_operation_1 = require("../operations/drain-delegate-operation");
-const proposals_operation_1 = require("../operations/proposals-operation");
-const update_consensus_key_operation_1 = require("../operations/update-consensus-key-operation");
-const update_companion_key_operation_1 = require("../operations/update-companion-key-operation");
-const smart_rollup_add_messages_operation_1 = require("../operations/smart-rollup-add-messages-operation");
-const smart_rollup_originate_operation_1 = require("../operations/smart-rollup-originate-operation");
-const smart_rollup_execute_outbox_message_operation_1 = require("../operations/smart-rollup-execute-outbox-message-operation");
-const provider_1 = require("../provider");
-const prepare_1 = require("../prepare");
-class RpcContractProvider extends provider_1.Provider {
-    constructor(context, estimator) {
-        super(context);
-        this.estimator = estimator;
-        this.contractProviderTypeSymbol = Symbol.for('taquito-contract-provider-type-symbol');
-        this.prepare = new prepare_1.PrepareProvider(this.context);
-    }
-    /**
-     *
-     * Return a well formatted json object of the contract storage
-     *
-     * @param contract contract address you want to get the storage from
-     * @param schema optional schema can either be the contract script rpc response or a michelson-encoder schema
-     * @throws {@link InvalidContractAddressError}
-     * @see https://tezos.gitlab.io/api/rpc.html#get-block-id-context-contracts-contract-id-script
-     */
-    async getStorage(contract, schema) {
-        const contractValidation = (0, utils_1.validateContractAddress)(contract);
-        if (contractValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidContractAddressError(contract, contractValidation);
-        }
-        const script = await this.context.readProvider.getScript(contract, 'head');
-        if (!schema) {
-            schema = script;
-        }
-        let contractSchema;
-        if (michelson_encoder_1.Schema.isSchema(schema)) {
-            contractSchema = schema;
-        }
-        else {
-            contractSchema = michelson_encoder_1.Schema.fromRPCResponse({ script: schema });
-        }
-        return contractSchema.Execute(script.storage, (0, semantic_1.smartContractAbstractionSemantic)(this)); // Cast into T because only the caller can know the true type of the storage
-    }
-    /**
-     *
-     * Return a well formatted json object of a big map value
-     *
-     * @param id Big Map ID
-     * @param keyToEncode key to query (will be encoded properly according to the schema)
-     * @param schema Big Map schema (can be determined using your contract type)
-     * @param block optional block level to fetch the values from
-     *
-     * @see https://tezos.gitlab.io/api/rpc.html#get-block-id-context-big-maps-big-map-id-script-expr
-     */
-    async getBigMapKeyByID(id, keyToEncode, schema, block) {
-        const { key, type } = schema.EncodeBigMapKey(keyToEncode);
-        const { packed } = await this.context.packer.packData({ data: key, type });
-        const encodedExpr = (0, utils_1.encodeExpr)(packed);
-        const bigMapValue = block
-            ? await this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, block)
-            : await this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, 'head');
-        return schema.ExecuteOnBigMapValue(bigMapValue, (0, semantic_1.smartContractAbstractionSemantic)(this));
-    }
-    /**
-     *
-     * Fetch multiple values in a big map
-     * All values will be fetched on the same block level. If a block is specified in the request, the values will be fetched at it.
-     * Otherwise, a first request will be done to the node to fetch the level of the head and all values will be fetched at this level.
-     * If one of the keys does not exist in the big map, its value will be set to undefined.
-     *
-     * @param id Big Map ID
-     * @param keys Array of keys to query (will be encoded properly according to the schema)
-     * @param schema Big Map schema (can be determined using your contract type)
-     * @param block optional block level to fetch the values from
-     * @param batchSize optional batch size representing the number of requests to execute in parallel
-     * @returns A MichelsonMap containing the keys queried in the big map and their value in a well-formatted JSON object format
-     *
-     */
-    async getBigMapKeysByID(id, keys, schema, block, batchSize = 5) {
-        const level = await this.getBlockForRequest(keys, block);
-        const bigMapValues = new michelson_encoder_1.MichelsonMap();
-        // Execute batch of promises in series
-        let position = 0;
-        let results = [];
-        while (position < keys.length) {
-            const keysBatch = keys.slice(position, position + batchSize);
-            const batch = keysBatch.map((keyToEncode) => this.getBigMapValueOrUndefined(keyToEncode, id, schema, level));
-            results = [...results, ...(await Promise.all(batch))];
-            position += batchSize;
-        }
-        for (let i = 0; i < results.length; i++) {
-            bigMapValues.set(keys[i], results[i]);
-        }
-        return bigMapValues;
-    }
-    async getBlockForRequest(keys, block) {
-        return keys.length === 1 || typeof block !== 'undefined'
-            ? block
-            : await this.context.readProvider.getBlockLevel('head');
-    }
-    async getBigMapValueOrUndefined(keyToEncode, id, schema, level) {
-        try {
-            return await this.getBigMapKeyByID(id, keyToEncode, schema, level);
-        }
-        catch (ex) {
-            if (ex instanceof http_utils_1.HttpResponseError && ex.status === http_utils_1.STATUS_CODE.NOT_FOUND) {
-                return;
-            }
-            else {
-                throw ex;
-            }
-        }
-    }
-    /**
-     *
-     * Return a well formatted json object of a sapling state
-     *
-     * @param id Sapling state ID
-     * @param block optional block level to fetch the value from
-     *
-     */
-    async getSaplingDiffByID(id, block) {
-        const saplingState = block
-            ? await this.context.readProvider.getSaplingDiffById({ id: id.toString() }, block)
-            : await this.context.readProvider.getSaplingDiffById({ id: id.toString() }, 'head');
-        return saplingState;
-    }
-    /**
-     *
-     * Originate a new contract according to the script in parameters. Will sign and inject an operation using the current context
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @warn You cannot specify storage and init at the same time (use init to pass the raw michelson representation of storage)
-     *
-     * @param params Originate operation parameter
-     */
-    async originate(params) {
-        const estimate = await this.estimate(params, this.estimator.originate.bind(this.estimator));
-        const preparedOrigination = await this.prepare.originate({ ...params, ...estimate });
-        const content = preparedOrigination.opOb.contents.find((op) => op.kind === rpc_1.OpKind.ORIGINATION);
-        const forgedOrigination = await this.forge(preparedOrigination);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(forgedOrigination);
-        return new origination_operation_1.OriginationOperation(hash, content, forgedBytes, opResponse, context, this);
-    }
-    /**
-     *
-     * Set the delegate for a contract. Will sign and inject an operation using the current context
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params SetDelegate operation parameter
-     */
-    async setDelegate(params) {
-        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
-        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.source, sourceValidation);
-        }
-        const delegateValidation = (0, utils_1.validateAddress)(params.delegate ?? '');
-        if (params.delegate && delegateValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.delegate, delegateValidation);
-        }
-        // Since babylon delegation source cannot smart contract
-        if (/^kt1/i.test(params.source ?? '')) {
-            throw new errors_1.InvalidDelegationSource(params.source ?? '');
-        }
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const sourceOrDefault = params.source || publicKeyHash;
-        const estimate = await this.estimate(params, this.estimator.setDelegate.bind(this.estimator));
-        const preparedDelegation = await this.prepare.delegation({ ...params, ...estimate });
-        const content = preparedDelegation.opOb.contents.find((op) => op.kind === rpc_1.OpKind.DELEGATION);
-        const opBytes = await this.forge(preparedDelegation);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new delegate_operation_1.DelegateOperation(hash, content, sourceOrDefault, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Register the current address as delegate. Will sign and inject an operation using the current context
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params RegisterDelegate operation parameter
-     */
-    async registerDelegate(params) {
-        const estimate = await this.estimate(params, this.estimator.registerDelegate.bind(this.estimator));
-        const source = await this.signer.publicKeyHash();
-        const prepared = await this.prepare.registerDelegate({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.DELEGATION);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new delegate_operation_1.DelegateOperation(hash, content, source, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Transfer tz from current address to a specific address. Will sign and inject an operation using the current context
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params Transfer operation parameter
-     */
-    async transfer(params) {
-        const toValidation = (0, utils_1.validateAddress)(params.to);
-        if (toValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.to, toValidation);
-        }
-        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
-        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.source, sourceValidation);
-        }
-        if (params.amount < 0) {
-            throw new core_1.InvalidAmountError(params.amount.toString());
-        }
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.transfer.bind(this.estimator));
-        const source = params.source || publicKeyHash;
-        const prepared = await this.prepare.transaction({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Stake a given amount for the source address
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params Stake pseudo-operation parameter
-     */
-    async stake(params) {
-        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
-        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.source, sourceValidation);
-        }
-        if (!params.to) {
-            params.to = params.source;
-        }
-        if (params.to && params.to !== params.source) {
-            throw new core_1.InvalidStakingAddressError(params.to);
-        }
-        if (params.amount < 0) {
-            throw new core_1.InvalidAmountError(params.amount.toString());
-        }
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.stake.bind(this.estimator));
-        const source = params.source || publicKeyHash;
-        const prepared = await this.prepare.stake({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Unstake the given amount. If "everything" is given as amount, unstakes everything from the staking balance.
-     * Unstaked tez remains frozen for a set amount of cycles (the slashing period) after the operation. Once this period is over,
-     * the operation "finalize unstake" must be called for the funds to appear in the liquid balance.
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params Unstake pseudo-operation parameter
-     */
-    async unstake(params) {
-        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
-        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.source, sourceValidation);
-        }
-        if (!params.to) {
-            params.to = params.source;
-        }
-        if (params.to && params.to !== params.source) {
-            throw new core_1.InvalidStakingAddressError(params.to);
-        }
-        if (params.amount < 0) {
-            throw new core_1.InvalidAmountError(params.amount.toString());
-        }
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.unstake.bind(this.estimator));
-        const source = params.source || publicKeyHash;
-        const prepared = await this.prepare.unstake({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Transfer all the finalizable unstaked funds of the source to their liquid balance
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params Finalize_unstake pseudo-operation parameter
-     */
-    async finalizeUnstake(params) {
-        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
-        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.source, sourceValidation);
-        }
-        if (!params.to) {
-            params.to = params.source;
-        }
-        if (!params.amount) {
-            params.amount = 0;
-        }
-        if (params.amount !== undefined && params.amount > 0) {
-            throw new core_1.InvalidFinalizeUnstakeAmountError('Amount must be 0 to finalize unstake.');
-        }
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.finalizeUnstake.bind(this.estimator));
-        const source = params.source || publicKeyHash;
-        const prepared = await this.prepare.finalizeUnstake({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Transfer Tickets to a smart contract address
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params TransferTicket operation parameter
-     */
-    async transferTicket(params) {
-        const destinationValidation = (0, utils_1.validateAddress)(params.destination);
-        if (destinationValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.destination, destinationValidation);
-        }
-        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
-        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.source, sourceValidation);
-        }
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const source = params.source ?? publicKeyHash;
-        const estimate = await this.estimate(params, this.estimator.transferTicket.bind(this.estimator));
-        const prepared = await this.prepare.transferTicket({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSFER_TICKET);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new transfer_ticket_operation_1.TransferTicketOperation(hash, content, source, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Reveal the public key of the current address. Will throw an error if the address is already revealed.
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params Reveal operation parameter
-     */
-    async reveal(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const [, pkhPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(publicKeyHash, utils_1.publicKeyHashPrefixes);
-        if (pkhPrefix === utils_1.PrefixV2.BLS12_381PublicKeyHash) {
-            if (params.proof) {
-                (0, utils_1.b58DecodeAndCheckPrefix)(params.proof, [utils_1.PrefixV2.BLS12_381Signature]); // validate proof to be a bls signature
-            }
-            else {
-                const { prefixSig } = await this.signer.provePossession();
-                params.proof = prefixSig;
-            }
-        }
-        else {
-            if (params.proof) {
-                throw new core_1.ProhibitedActionError('Proof field is only allowed to reveal a bls account ');
-            }
-        }
-        const estimateReveal = await this.estimator.reveal(params);
-        if (estimateReveal) {
-            const estimated = await this.estimate(params, async () => estimateReveal);
-            const prepared = await this.prepare.reveal({ ...params, ...estimated });
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.REVEAL);
-            const opBytes = await this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-            return new reveal_operation_1.RevealOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        }
-        else {
-            throw new errors_1.RevealOperationError(`The publicKeyHash '${publicKeyHash}' has already been revealed.`);
-        }
-    }
-    /**
-     *
-     * Register a Micheline expression in a global table of constants. Will sign and inject an operation using the current context
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params registerGlobalConstant operation parameter
-     */
-    async registerGlobalConstant(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.registerGlobalConstant.bind(this.estimator));
-        const prepared = await this.prepare.registerGlobalConstant({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new register_global_constant_operation_1.RegisterGlobalConstantOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Increase the paid storage of a smart contract
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params increasePaidStorage operation parameter
-     */
-    async increasePaidStorage(params) {
-        if (params.amount <= 0) {
-            throw new core_1.InvalidAmountError(params.amount.toString());
-        }
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.increasePaidStorage.bind(this.estimator));
-        const prepared = await this.prepare.increasePaidStorage({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.INCREASE_PAID_STORAGE);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new increase_paid_storage_operation_1.IncreasePaidStorageOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Transfers the spendable balance of the delegate to destination when consensus_key is the active consensus key of delegate
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params drainDelegate operation parameter
-     */
-    async drainDelegate(params) {
-        const prepared = await this.prepare.drainDelegate(params);
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.DRAIN_DELEGATE);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new drain_delegate_operation_1.DrainDelegateOperation(hash, content, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Submit a ballot vote to a specified proposal
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params Ballot operation parameter
-     */
-    async ballot(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
-        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.source, sourceValidation);
-        }
-        const source = params.source ?? publicKeyHash;
-        const prepared = await this.prepare.ballot({ ...params, source });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.BALLOT);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new ballot_operation_1.BallotOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Submit or upvote a proposal during the Proposal period
-     *
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params Proposals operation parameter
-     */
-    async proposals(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
-        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.source, sourceValidation);
-        }
-        const source = params.source ?? publicKeyHash;
-        const prepared = await this.prepare.proposals({ ...params, source });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.PROPOSALS);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new proposals_operation_1.ProposalsOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Update the consensus key of a delegate starting from the current cycle plus CONSENSUS_RIGHTS_DELAY + 1
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params UpdateConsensusKey operation parameter
-     */
-    async updateConsensusKey(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const [, pkPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(params.pk, utils_1.publicKeyPrefixes);
-        if (pkPrefix === utils_1.PrefixV2.BLS12_381PublicKey) {
-            if (!params.proof) {
-                throw new core_1.InvalidProofError('Proof is required to set a bls account as consensus key ');
-            }
-        }
-        else {
-            if (params.proof) {
-                throw new core_1.ProhibitedActionError('Proof field is only allowed for a bls account as consensus key');
-            }
-        }
-        const estimate = await this.estimate(params, this.estimator.updateConsensusKey.bind(this.estimator));
-        const prepared = await this.prepare.updateConsensusKey({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.UPDATE_CONSENSUS_KEY);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new update_consensus_key_operation_1.UpdateConsensusKeyOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * Updates the companion key of the delegate starting from the current cycle plus CONSENSUS_KEY_ACTIVATION_DELAY + 1
-     * @returns An operation handle with the result from the rpc node
-     *
-     * @param params UpdateCompanionKey operation parameter
-     */
-    async updateCompanionKey(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const [, pkPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(params.pk, utils_1.publicKeyPrefixes);
-        if (pkPrefix !== utils_1.PrefixV2.BLS12_381PublicKey) {
-            throw new core_1.ProhibitedActionError('Proof field is only allowed for a bls account as companion key');
-        }
-        if (!params.proof) {
-            throw new core_1.InvalidProofError('Proof is required to set a bls account as companion key ');
-        }
-        const estimate = await this.estimate(params, this.estimator.updateCompanionKey.bind(this.estimator));
-        const prepared = await this.prepare.updateCompanionKey({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.UPDATE_COMPANION_KEY);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new update_companion_key_operation_1.UpdateCompanionKeyOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     * Adds messages to the rollup inbox that can be executed/claimed after it gets cemented
-     * @param params SmartRollupAddMessages operation parameter
-     * @returns An operation handle with results from the RPC node
-     */
-    async smartRollupAddMessages(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.smartRollupAddMessages.bind(this.estimator));
-        const prepared = await this.prepare.smartRollupAddMessages({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new smart_rollup_add_messages_operation_1.SmartRollupAddMessagesOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     * Creates a smart rollup originate operation
-     * @param params SmartRollupOriginate operation parameter
-     * @returns An operation handle with results from the RPC node
-     */
-    async smartRollupOriginate(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.smartRollupOriginate.bind(this.estimator));
-        const prepared = await this.prepare.smartRollupOriginate({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.SMART_ROLLUP_ORIGINATE);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new smart_rollup_originate_operation_1.SmartRollupOriginateOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     * Execute a message from a smart rollup's outbox of a cemented commitment
-     * @param params SmartRollupExecuteOutboxMessage operation parameter
-     * @returns An operation handle with results from the RPC node
-     */
-    async smartRollupExecuteOutboxMessage(params) {
-        const publicKeyHash = await this.signer.publicKeyHash();
-        const estimate = await this.estimate(params, this.estimator.smartRollupExecuteOutboxMessage.bind(this.estimator));
-        const prepared = await this.prepare.smartRollupExecuteOutboxMessage({ ...params, ...estimate });
-        const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE);
-        const opBytes = await this.forge(prepared);
-        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
-        return new smart_rollup_execute_outbox_message_operation_1.SmartRollupExecuteOutboxMessageOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-    }
-    /**
-     *
-     * A failing_noop operation that is guaranteed to fail.
-     *
-     * @returns A FailingNoopOperation object representing the signed failing_noop operation
-     *
-     * @param params failingNoop operation parameter
-     */
-    async failingNoop(params) {
-        const op = {
-            kind: rpc_1.OpKind.FAILING_NOOP,
-            arbitrary: params.arbitrary,
-        };
-        const hash = await this.context.readProvider.getBlockHash(params.basedOnBlock);
-        const forged = await this.context.forger.forge({
-            branch: hash,
-            contents: [op],
-        });
-        const { prefixSig } = await this.signer.sign(forged, new Uint8Array([3]));
-        return {
-            signature: prefixSig,
-            bytes: forged,
-            signedContent: {
-                branch: hash,
-                contents: [
-                    {
-                        kind: rpc_1.OpKind.FAILING_NOOP,
-                        arbitrary: params.arbitrary,
-                    },
-                ],
-            },
-        };
-    }
-    /**
-     *
-     * Create an smart contract abstraction for the address specified.
-     *
-     * @param address Smart contract address
-     * @throws {@link InvalidContractAddressError}
-     */
-    async at(address, contractAbstractionComposer = (x) => x, block = 'head') {
-        const addressValidation = (0, utils_1.validateContractAddress)(address);
-        if (addressValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidContractAddressError(address, addressValidation);
-        }
-        const rpc = this.context.withExtensions().rpc;
-        const readProvider = this.context.withExtensions().readProvider;
-        const loadContractState = async (requestedBlock) => {
-            const script = await readProvider.getScript(address, requestedBlock);
-            const entrypoints = requestedBlock === 'head'
-                ? await readProvider.getEntrypoints(address)
-                : await rpc.getEntrypoints(address, { block: String(requestedBlock) });
-            return { script, entrypoints };
-        };
-        let contractState;
-        try {
-            contractState = await loadContractState(block);
-        }
-        catch (error) {
-            // Shadownet's rolling nodes occasionally 404 a just-originated contract at the exact
-            // inclusion level even after confirmation. Retry at head so the contract abstraction still
-            // resolves once the node's contract index catches up.
-            if (block !== 'head' &&
-                error instanceof http_utils_1.HttpResponseError &&
-                error.status === http_utils_1.STATUS_CODE.NOT_FOUND) {
-                contractState = await loadContractState('head');
-            }
-            else {
-                throw error;
-            }
-        }
-        const abs = new contract_1.ContractAbstraction(address, contractState.script, this, this, contractState.entrypoints, rpc, readProvider);
-        return contractAbstractionComposer(abs, this.context);
-    }
-    /**
-     *
-     * Batch a group of operation together. Operations will be applied in the order in which they are added to the batch
-     *
-     * @returns A batch object from which we can add more operation or send a command to execute the batch
-     *
-     * @param params List of operation to batch together
-     */
-    batch(params) {
-        const batch = new rpc_batch_provider_1.OperationBatch(this.context, this.estimator);
-        if (Array.isArray(params)) {
-            batch.with(params);
-        }
-        return batch;
-    }
-}
-exports.RpcContractProvider = RpcContractProvider;