@taquito/taquito 24.2.0 → 24.3.0-beta.0

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcContractProvider = void 0;
 const http_utils_1 = require("@taquito/http-utils");
@@ -45,36 +36,34 @@ class RpcContractProvider extends provider_1.Provider {
     }
     /**
      *
-     * @description Return a well formatted json object of the contract storage
+     * 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
      */
-    getStorage(contract, schema) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const contractValidation = (0, utils_1.validateContractAddress)(contract);
-            if (contractValidation !== utils_1.ValidationResult.VALID) {
-                throw new core_1.InvalidContractAddressError(contract, contractValidation);
-            }
-            const script = yield 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
-        });
+    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
     }
     /**
      *
-     * @description Return a well formatted json object of a big map value
+     * 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)
@@ -83,20 +72,18 @@ class RpcContractProvider extends provider_1.Provider {
      *
      * @see https://tezos.gitlab.io/api/rpc.html#get-block-id-context-big-maps-big-map-id-script-expr
      */
-    getBigMapKeyByID(id, keyToEncode, schema, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { key, type } = schema.EncodeBigMapKey(keyToEncode);
-            const { packed } = yield this.context.packer.packData({ data: key, type });
-            const encodedExpr = (0, utils_1.encodeExpr)(packed);
-            const bigMapValue = block
-                ? yield this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, block)
-                : yield this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, 'head');
-            return schema.ExecuteOnBigMapValue(bigMapValue, (0, semantic_1.smartContractAbstractionSemantic)(this));
-        });
+    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));
     }
     /**
      *
-     * @description Fetch multiple values in a big map
+     * 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.
@@ -109,605 +96,569 @@ class RpcContractProvider extends provider_1.Provider {
      * @returns A MichelsonMap containing the keys queried in the big map and their value in a well-formatted JSON object format
      *
      */
-    getBigMapKeysByID(id_1, keys_1, schema_1, block_1) {
-        return __awaiter(this, arguments, void 0, function* (id, keys, schema, block, batchSize = 5) {
-            const level = yield 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, ...(yield Promise.all(batch))];
-                position += batchSize;
-            }
-            for (let i = 0; i < results.length; i++) {
-                bigMapValues.set(keys[i], results[i]);
-            }
-            return bigMapValues;
-        });
+    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;
     }
-    getBlockForRequest(keys, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return keys.length === 1 || typeof block !== 'undefined'
-                ? block
-                : yield this.context.readProvider.getBlockLevel('head');
-        });
+    async getBlockForRequest(keys, block) {
+        return keys.length === 1 || typeof block !== 'undefined'
+            ? block
+            : await this.context.readProvider.getBlockLevel('head');
     }
-    getBigMapValueOrUndefined(keyToEncode, id, schema, level) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.getBigMapKeyByID(id, keyToEncode, schema, level);
+    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;
             }
-            catch (ex) {
-                if (ex instanceof http_utils_1.HttpResponseError && ex.status === http_utils_1.STATUS_CODE.NOT_FOUND) {
-                    return;
-                }
-                else {
-                    throw ex;
-                }
+            else {
+                throw ex;
             }
-        });
+        }
     }
     /**
      *
-     * @description Return a well formatted json object of a sapling state
+     * 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
      *
      */
-    getSaplingDiffByID(id, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const saplingState = block
-                ? yield this.context.readProvider.getSaplingDiffById({ id: id.toString() }, block)
-                : yield this.context.readProvider.getSaplingDiffById({ id: id.toString() }, 'head');
-            return saplingState;
-        });
+    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;
     }
     /**
      *
-     * @description Originate a new contract according to the script in parameters. Will sign and inject an operation using the current context
+     * 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 OriginationOperation Originate operation parameter
+     * @param params Originate operation parameter
      */
-    originate(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const estimate = yield this.estimate(params, this.estimator.originate.bind(this.estimator));
-            const preparedOrigination = yield this.prepare.originate(Object.assign(Object.assign({}, params), estimate));
-            const content = preparedOrigination.opOb.contents.find((op) => op.kind === rpc_1.OpKind.ORIGINATION);
-            const forgedOrigination = yield this.forge(preparedOrigination);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(forgedOrigination);
-            return new origination_operation_1.OriginationOperation(hash, content, forgedBytes, opResponse, context, this);
-        });
+    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);
     }
     /**
      *
-     * @description Set the delegate for a contract. Will sign and inject an operation using the current context
+     * 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 SetDelegate operation parameter
+     * @param params SetDelegate operation parameter
      */
-    setDelegate(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
-            if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-                throw new core_1.InvalidAddressError(params.source, sourceValidation);
-            }
-            const delegateValidation = (0, utils_1.validateAddress)((_b = params.delegate) !== null && _b !== void 0 ? _b : '');
-            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((_c = params.source) !== null && _c !== void 0 ? _c : '')) {
-                throw new errors_1.InvalidDelegationSource((_d = params.source) !== null && _d !== void 0 ? _d : '');
-            }
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const sourceOrDefault = params.source || publicKeyHash;
-            const estimate = yield this.estimate(params, this.estimator.setDelegate.bind(this.estimator));
-            const preparedDelegation = yield this.prepare.delegation(Object.assign(Object.assign({}, params), estimate));
-            const content = preparedDelegation.opOb.contents.find((op) => op.kind === rpc_1.OpKind.DELEGATION);
-            const opBytes = yield this.forge(preparedDelegation);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new delegate_operation_1.DelegateOperation(hash, content, sourceOrDefault, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Register the current address as delegate. Will sign and inject an operation using the current 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 RegisterDelegate operation parameter
+     * @param params RegisterDelegate operation parameter
      */
-    registerDelegate(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const estimate = yield this.estimate(params, this.estimator.registerDelegate.bind(this.estimator));
-            const source = yield this.signer.publicKeyHash();
-            const prepared = yield this.prepare.registerDelegate(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.DELEGATION);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new delegate_operation_1.DelegateOperation(hash, content, source, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Transfer tz from current address to a specific address. Will sign and inject an operation using the current 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 Transfer operation parameter
+     * @param params Transfer operation parameter
      */
-    transfer(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            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)((_a = params.source) !== null && _a !== void 0 ? _a : '');
-            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 = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.transfer.bind(this.estimator));
-            const source = params.source || publicKeyHash;
-            const prepared = yield this.prepare.transaction(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Stake a given amount for the source address
+     * Stake a given amount for the source address
      *
      * @returns An operation handle with the result from the rpc node
      *
-     * @param Stake pseudo-operation parameter
+     * @param params Stake pseudo-operation parameter
      */
-    stake(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
-            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 = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.stake.bind(this.estimator));
-            const source = params.source || publicKeyHash;
-            const prepared = yield this.prepare.stake(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Unstake the given amount. If "everything" is given as amount, unstakes everything from the staking balance.
+     * 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 Unstake pseudo-operation parameter
+     * @param params Unstake pseudo-operation parameter
      */
-    unstake(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
-            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 = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.unstake.bind(this.estimator));
-            const source = params.source || publicKeyHash;
-            const prepared = yield this.prepare.unstake(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Transfer all the finalizable unstaked funds of the source to their liquid balance
+     * 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 Finalize_unstake pseudo-operation parameter
+     * @param params Finalize_unstake pseudo-operation parameter
      */
-    finalizeUnstake(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
-            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 = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.finalizeUnstake.bind(this.estimator));
-            const source = params.source || publicKeyHash;
-            const prepared = yield this.prepare.finalizeUnstake(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Transfer Tickets to a smart contract address
+     * Transfer Tickets to a smart contract address
      *
      * @returns An operation handle with the result from the rpc node
      *
-     * @param TransferTicketParams operation parameter
+     * @param params TransferTicket operation parameter
      */
-    transferTicket(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            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)((_a = params.source) !== null && _a !== void 0 ? _a : '');
-            if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-                throw new core_1.InvalidAddressError(params.source, sourceValidation);
-            }
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const source = (_b = params.source) !== null && _b !== void 0 ? _b : publicKeyHash;
-            const estimate = yield this.estimate(params, this.estimator.transferTicket.bind(this.estimator));
-            const prepared = yield this.prepare.transferTicket(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSFER_TICKET);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new transfer_ticket_operation_1.TransferTicketOperation(hash, content, source, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Reveal the public key of the current address. Will throw an error if the address is already revealed.
+     * 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 RevealParams operation parameter
+     * @param params Reveal operation parameter
      */
-    reveal(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const publicKeyHash = yield 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 } = yield this.signer.provePossession();
-                    params.proof = prefixSig;
-                }
+    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 {
-                if (params.proof) {
-                    throw new core_1.ProhibitedActionError('Proof field is only allowed to reveal a bls account ');
-                }
-            }
-            const estimateReveal = yield this.estimator.reveal(params);
-            if (estimateReveal) {
-                const estimated = yield this.estimate(params, () => __awaiter(this, void 0, void 0, function* () { return estimateReveal; }));
-                const prepared = yield this.prepare.reveal(Object.assign(Object.assign({}, params), estimated));
-                const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.REVEAL);
-                const opBytes = yield this.forge(prepared);
-                const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-                return new reveal_operation_1.RevealOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
+                const { prefixSig } = await this.signer.provePossession();
+                params.proof = prefixSig;
             }
-            else {
-                throw new errors_1.RevealOperationError(`The publicKeyHash '${publicKeyHash}' has already been revealed.`);
+        }
+        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.`);
+        }
     }
     /**
      *
-     * @description Register a Micheline expression in a global table of constants. Will sign and inject an operation using the current context
+     * 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
      */
-    registerGlobalConstant(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.registerGlobalConstant.bind(this.estimator));
-            const prepared = yield this.prepare.registerGlobalConstant(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new register_global_constant_operation_1.RegisterGlobalConstantOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Increase the paid storage of a smart contract
+     * Increase the paid storage of a smart contract
      *
      * @returns An operation handle with the result from the rpc node
      *
      * @param params increasePaidStorage operation parameter
      */
-    increasePaidStorage(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (params.amount <= 0) {
-                throw new core_1.InvalidAmountError(params.amount.toString());
-            }
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.increasePaidStorage.bind(this.estimator));
-            const prepared = yield this.prepare.increasePaidStorage(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.INCREASE_PAID_STORAGE);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new increase_paid_storage_operation_1.IncreasePaidStorageOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Transfers the spendable balance of the delegate to destination when consensus_key is the active consensus key of delegate
+     * 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
      */
-    drainDelegate(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const prepared = yield this.prepare.drainDelegate(params);
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.DRAIN_DELEGATE);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new drain_delegate_operation_1.DrainDelegateOperation(hash, content, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Submit a ballot vote to a specified proposal
+     * Submit a ballot vote to a specified proposal
      *
      * @returns An operation handle with the result from the rpc node
      *
-     * @param BallotParams Ballot operation parameter
+     * @param params Ballot operation parameter
      */
-    ballot(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
-            if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-                throw new core_1.InvalidAddressError(params.source, sourceValidation);
-            }
-            const source = (_b = params.source) !== null && _b !== void 0 ? _b : publicKeyHash;
-            const prepared = yield this.prepare.ballot(Object.assign(Object.assign({}, params), { source }));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.BALLOT);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new ballot_operation_1.BallotOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Submit or upvote a proposal during the Proposal period
+     * Submit or upvote a proposal during the Proposal period
      *
      * @returns An operation handle with the result from the rpc node
      *
-     * @param ProposalsParams Proposals operation parameter
+     * @param params Proposals operation parameter
      */
-    proposals(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
-            if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
-                throw new core_1.InvalidAddressError(params.source, sourceValidation);
-            }
-            const source = (_b = params.source) !== null && _b !== void 0 ? _b : publicKeyHash;
-            const prepared = yield this.prepare.proposals(Object.assign(Object.assign({}, params), { source }));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.PROPOSALS);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new proposals_operation_1.ProposalsOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description Update the consensus key of a delegate starting from the current cycle plus CONSENSUS_RIGHTS_DELAY + 1
+     * 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 UpdateConsensusKeyParams
+     * @param params UpdateConsensusKey operation parameter
      */
-    updateConsensusKey(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const publicKeyHash = yield 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 ');
-                }
+    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');
-                }
+        }
+        else {
+            if (params.proof) {
+                throw new core_1.ProhibitedActionError('Proof field is only allowed for a bls account as consensus key');
             }
-            const estimate = yield this.estimate(params, this.estimator.updateConsensusKey.bind(this.estimator));
-            const prepared = yield this.prepare.updateConsensusKey(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.UPDATE_CONSENSUS_KEY);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new update_consensus_key_operation_1.UpdateConsensusKeyOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+        }
+        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);
     }
     /**
      *
-     * @description Updates the companion key of the delegate starting from the current cycle plus CONSENSUS_KEY_ACTIVATION_DELAY + 1
+     * 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 UpdateCompanionKeyParams
+     * @param params UpdateCompanionKey operation parameter
      */
-    updateCompanionKey(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const publicKeyHash = yield 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 = yield this.estimate(params, this.estimator.updateCompanionKey.bind(this.estimator));
-            const prepared = yield this.prepare.updateCompanionKey(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.UPDATE_COMPANION_KEY);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new update_companion_key_operation_1.UpdateCompanionKeyOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
-     * @description Adds messages to the rollup inbox that can be executed/claimed after it gets cemented
-     * @param SmartRollupAddMessagesParams
+     * 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
      */
-    smartRollupAddMessages(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.smartRollupAddMessages.bind(this.estimator));
-            const prepared = yield this.prepare.smartRollupAddMessages(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new smart_rollup_add_messages_operation_1.SmartRollupAddMessagesOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
-     * @description Creates a smart rollup originate operation
-     * @param SmartRollupOriginateParams
+     * Creates a smart rollup originate operation
+     * @param params SmartRollupOriginate operation parameter
      * @returns An operation handle with results from the RPC node
      */
-    smartRollupOriginate(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.smartRollupOriginate.bind(this.estimator));
-            const prepared = yield this.prepare.smartRollupOriginate(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.SMART_ROLLUP_ORIGINATE);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new smart_rollup_originate_operation_1.SmartRollupOriginateOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
-     * @description Execute a message from a smart rollup's outbox of a cemented commitment
-     * @param SmartRollupExecuteOutboxMessageParams
+     * 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
      */
-    smartRollupExecuteOutboxMessage(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const publicKeyHash = yield this.signer.publicKeyHash();
-            const estimate = yield this.estimate(params, this.estimator.smartRollupExecuteOutboxMessage.bind(this.estimator));
-            const prepared = yield this.prepare.smartRollupExecuteOutboxMessage(Object.assign(Object.assign({}, params), estimate));
-            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE);
-            const opBytes = yield this.forge(prepared);
-            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
-            return new smart_rollup_execute_outbox_message_operation_1.SmartRollupExecuteOutboxMessageOperation(hash, content, publicKeyHash, forgedBytes, opResponse, context);
-        });
+    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);
     }
     /**
      *
-     * @description A failing_noop operation that is guaranteed to fail.
+     * A failing_noop operation that is guaranteed to fail.
      *
      * @returns A FailingNoopOperation object representing the signed failing_noop operation
      *
      * @param params failingNoop operation parameter
      */
-    failingNoop(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const op = {
-                kind: rpc_1.OpKind.FAILING_NOOP,
-                arbitrary: params.arbitrary,
-            };
-            const hash = yield this.context.readProvider.getBlockHash(params.basedOnBlock);
-            const forged = yield this.context.forger.forge({
-                branch: hash,
-                contents: [op],
-            });
-            const { prefixSig } = yield 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,
-                        },
-                    ],
-                },
-            };
+    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,
+                    },
+                ],
+            },
+        };
     }
     /**
      *
-     * @description Create an smart contract abstraction for the address specified.
+     * Create an smart contract abstraction for the address specified.
      *
      * @param address Smart contract address
      * @throws {@link InvalidContractAddressError}
      */
-    at(address_1) {
-        return __awaiter(this, arguments, void 0, function* (address, contractAbstractionComposer = (x) => x) {
-            const addressValidation = (0, utils_1.validateContractAddress)(address);
-            if (addressValidation !== utils_1.ValidationResult.VALID) {
-                throw new core_1.InvalidContractAddressError(address, addressValidation);
+    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');
             }
-            const rpc = this.context.withExtensions().rpc;
-            const readProvider = this.context.withExtensions().readProvider;
-            const script = yield readProvider.getScript(address, 'head');
-            const entrypoints = yield readProvider.getEntrypoints(address);
-            const abs = new contract_1.ContractAbstraction(address, script, this, this, entrypoints, rpc, readProvider);
-            return contractAbstractionComposer(abs, this.context);
-        });
+            else {
+                throw error;
+            }
+        }
+        const abs = new contract_1.ContractAbstraction(address, contractState.script, this, this, contractState.entrypoints, rpc, readProvider);
+        return contractAbstractionComposer(abs, this.context);
     }
     /**
      *
-     * @description Batch a group of operation together. Operations will be applied in the order in which they are added to the batch
+     * 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
      *