@taquito/taquito 24.2.0 → 24.3.0-beta.0

package/dist/lib/wallet/wallet.js

@@ -1,18 +1,10 @@
 "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.Wallet = exports.WalletOperationBatch = void 0;
 const contract_1 = require("../contract/contract");
 const types_1 = require("../operations/types");
 const core_1 = require("@taquito/core");
+const http_utils_1 = require("@taquito/http-utils");
 const utils_1 = require("@taquito/utils");
 class WalletOperationBatch {
     constructor(walletProvider, context) {
@@ -21,7 +13,7 @@ class WalletOperationBatch {
         this.operations = [];
     }
     /**
-     * @description Add a transaction operation to the batch
+     * Add a transaction operation to the batch
      * @param params Transfer operation parameter
      */
     withTransfer(params) {
@@ -29,11 +21,11 @@ class WalletOperationBatch {
         if (toValidation !== utils_1.ValidationResult.VALID) {
             throw new core_1.InvalidAddressError(params.to, toValidation);
         }
-        this.operations.push(Object.assign({ kind: types_1.OpKind.TRANSACTION }, params));
+        this.operations.push({ kind: types_1.OpKind.TRANSACTION, ...params });
         return this;
     }
     /**
-     * @description Add a contract call to the batch
+     * Add a contract call to the batch
      * @param params Call a contract method
      * @param options Generic operation parameters
      */
@@ -41,84 +33,81 @@ class WalletOperationBatch {
         return this.withTransfer(params.toTransferParams(options));
     }
     /**
-     * @description Add a delegation operation to the batch
+     * Add a delegation operation to the batch
      * @param params Delegation operation parameter
      */
     withDelegation(params) {
-        var _a;
-        const delegateValidation = (0, utils_1.validateAddress)((_a = params.delegate) !== null && _a !== void 0 ? _a : '');
+        const delegateValidation = (0, utils_1.validateAddress)(params.delegate ?? '');
         if (params.delegate && delegateValidation !== utils_1.ValidationResult.VALID) {
             throw new core_1.InvalidAddressError(params.delegate, delegateValidation);
         }
-        this.operations.push(Object.assign({ kind: types_1.OpKind.DELEGATION }, params));
+        this.operations.push({ kind: types_1.OpKind.DELEGATION, ...params });
         return this;
     }
     /**
-     * @description Add an origination operation to the batch
+     * Add an origination operation to the batch
      * @param params Origination operation parameter
      */
     withOrigination(params) {
-        this.operations.push(Object.assign({ kind: types_1.OpKind.ORIGINATION }, params));
+        this.operations.push({ kind: types_1.OpKind.ORIGINATION, ...params });
         return this;
     }
     /**
-     * @description Add an IncreasePaidStorage operation to the batch
-     * @param param IncreasePaidStorage operation parameter
+     * Add an IncreasePaidStorage operation to the batch
+     * @param params IncreasePaidStorage operation parameter
      */
     withIncreasePaidStorage(params) {
         const destinationValidation = (0, utils_1.validateAddress)(params.destination);
         if (destinationValidation !== utils_1.ValidationResult.VALID) {
             throw new core_1.InvalidAddressError(params.destination, destinationValidation);
         }
-        this.operations.push(Object.assign({ kind: types_1.OpKind.INCREASE_PAID_STORAGE }, params));
+        this.operations.push({ kind: types_1.OpKind.INCREASE_PAID_STORAGE, ...params });
         return this;
     }
     /**
-     * @description Add an TransferTicket operation to the batch
-     * @param param TransferTicket operation parameter
+     * Add an TransferTicket operation to the batch
+     * @param params TransferTicket operation parameter
      */
     withTransferTicket(params) {
         const destinationValidation = (0, utils_1.validateAddress)(params.destination);
         if (destinationValidation !== utils_1.ValidationResult.VALID) {
             throw new core_1.InvalidAddressError(params.destination, destinationValidation);
         }
-        this.operations.push(Object.assign({ kind: types_1.OpKind.TRANSFER_TICKET }, params));
+        this.operations.push({ kind: types_1.OpKind.TRANSFER_TICKET, ...params });
         return this;
     }
     /**
-     * @description Add a RegisterGlobalConstant operation to the batch
-     * @param param RegisterGlobalConstant operation parameter
+     * Add a RegisterGlobalConstant operation to the batch
+     * @param params RegisterGlobalConstant operation parameter
      */
     withRegisterGlobalConstant(params) {
-        this.operations.push(Object.assign({ kind: types_1.OpKind.REGISTER_GLOBAL_CONSTANT }, params));
+        this.operations.push({ kind: types_1.OpKind.REGISTER_GLOBAL_CONSTANT, ...params });
         return this;
     }
-    mapOperation(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (param.kind) {
-                case types_1.OpKind.TRANSACTION:
-                    return this.walletProvider.mapTransferParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () { return param; }));
-                case types_1.OpKind.ORIGINATION:
-                    return this.walletProvider.mapOriginateParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () {
-                        return this.context.parser.prepareCodeOrigination(Object.assign({}, param));
-                    }));
-                case types_1.OpKind.DELEGATION:
-                    return this.walletProvider.mapDelegateParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () { return param; }));
-                case types_1.OpKind.INCREASE_PAID_STORAGE:
-                    return this.walletProvider.mapIncreasePaidStorageWalletParams(() => __awaiter(this, void 0, void 0, function* () { return param; }));
-                case types_1.OpKind.REGISTER_GLOBAL_CONSTANT:
-                    return this.walletProvider.mapRegisterGlobalConstantParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () { return param; }));
-                case types_1.OpKind.TRANSFER_TICKET:
-                    return this.walletProvider.mapTransferTicketParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () { return param; }));
-                default:
-                    throw new core_1.InvalidOperationKindError(JSON.stringify(param.kind));
-            }
-        });
+    async mapOperation(param) {
+        switch (param.kind) {
+            case types_1.OpKind.TRANSACTION:
+                return this.walletProvider.mapTransferParamsToWalletParams(async () => param);
+            case types_1.OpKind.ORIGINATION:
+                return this.walletProvider.mapOriginateParamsToWalletParams(async () => this.context.parser.prepareCodeOrigination({
+                    ...param,
+                }));
+            case types_1.OpKind.DELEGATION:
+                return this.walletProvider.mapDelegateParamsToWalletParams(async () => param);
+            case types_1.OpKind.INCREASE_PAID_STORAGE:
+                return this.walletProvider.mapIncreasePaidStorageWalletParams(async () => param);
+            case types_1.OpKind.REGISTER_GLOBAL_CONSTANT:
+                return this.walletProvider.mapRegisterGlobalConstantParamsToWalletParams(async () => param);
+            case types_1.OpKind.TRANSFER_TICKET:
+                return this.walletProvider.mapTransferTicketParamsToWalletParams(async () => param);
+            default:
+                throw new core_1.InvalidOperationKindError(JSON.stringify(param.kind));
+        }
     }
     /**
-     * @description Add a group operation to the batch. Operation will be applied in the order they are in the params array
+     * Add a group operation to the batch. Operation will be applied in the order they are in the params array
      * @param params Operations parameter
-     * @throws {@link InvalidOperationKindError}
+     * @throws InvalidOperationKindError
      */
     with(params) {
         for (const param of params) {
@@ -148,17 +137,15 @@ class WalletOperationBatch {
         return this;
     }
     /**
-     * @description Submit batch operation to wallet
+     * Submit batch operation to wallet
      */
-    send() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ops = [];
-            for (const op of this.operations) {
-                ops.push(yield this.mapOperation(op));
-            }
-            const opHash = yield this.walletProvider.sendOperations(ops);
-            return this.context.operationFactory.createBatchOperation(opHash);
-        });
+    async send() {
+        const ops = [];
+        for (const op of this.operations) {
+            ops.push(await this.mapOperation(op));
+        }
+        const opHash = await this.walletProvider.sendOperations(ops);
+        return this.context.operationFactory.createBatchOperation(opHash);
     }
 }
 exports.WalletOperationBatch = WalletOperationBatch;
@@ -175,108 +162,103 @@ class Wallet {
         return this.context.walletProvider;
     }
     /**
-     * @description Retrieve the PKH of the account that is currently in use by the wallet
+     * Retrieve the PKH of the account that is currently in use by the wallet
      * @param option Option to use while fetching the PKH.
      * If forceRefetch is specified the wallet provider implementation will refetch the PKH from the wallet
      */
-    pkh() {
-        return __awaiter(this, arguments, void 0, function* ({ forceRefetch } = {}) {
-            if (!this._pkh || forceRefetch) {
-                this._pkh = yield this.walletProvider.getPKH();
-            }
-            return this._pkh;
-        });
+    async pkh({ forceRefetch } = {}) {
+        if (!this._pkh || forceRefetch) {
+            this._pkh = await this.walletProvider.getPKH();
+        }
+        return this._pkh;
     }
     /**
-     * @description Retrieve the PK of the account that is currently in use by the wallet
+     * Retrieve the PK of the account that is currently in use by the wallet
      * @param option Option to use while fetching the PK.
      * If forceRefetch is specified the wallet provider implementation will refetch the PK from the wallet
      */
-    pk() {
-        return __awaiter(this, arguments, void 0, function* ({ forceRefetch } = {}) {
-            if (!this._pk || forceRefetch) {
-                this._pk = yield this.walletProvider.getPK();
-            }
-            return this._pk;
-        });
+    async pk({ forceRefetch } = {}) {
+        if (!this._pk || forceRefetch) {
+            this._pk = await this.walletProvider.getPK();
+        }
+        return this._pk;
     }
     /**
-     * @description Originate a new contract according to the script in parameters.
+     * Originate a new contract according to the script in parameters.
      * @returns a OriginationWalletOperation promise object when followed by .send()
-     * @param originateParams Originate operation parameter
+     * @param params Originate operation parameter
      */
     originate(params) {
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapOriginateParamsToWalletParams(() => this.context.parser.prepareCodeOrigination(Object.assign({}, params)));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapOriginateParamsToWalletParams(() => this.context.parser.prepareCodeOrigination({
+                ...params,
+            }));
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
             return this.context.operationFactory.createOriginationOperation(opHash);
-        }));
+        });
     }
     /**
-     * @description Set the delegate for a contract.
+     * Set the delegate for a contract.
      * @returns a WalletDelegateParams promise object when followed by .send()
-     * @param delegateParams operation parameter
+     * @param params operation parameter
      */
     setDelegate(params) {
-        var _a;
-        const delegateValidation = (0, utils_1.validateAddress)((_a = params.delegate) !== null && _a !== void 0 ? _a : '');
+        const delegateValidation = (0, utils_1.validateAddress)(params.delegate ?? '');
         if (params.delegate && delegateValidation !== utils_1.ValidationResult.VALID) {
             throw new core_1.InvalidAddressError(params.delegate, delegateValidation);
         }
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapDelegateParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () { return params; }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapDelegateParamsToWalletParams(async () => params);
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
             return this.context.operationFactory.createDelegationOperation(opHash);
-        }));
+        });
     }
     /**
-     * @description failing_noop operation that is guaranteed to fail. DISCLAIMER: Not all wallets support signing failing_noop operations.
+     * failing_noop operation that is guaranteed to fail. DISCLAIMER: Not all wallets support signing failing_noop operations.
      * @returns Signature for a failing_noop
      * @param params operation parameter
      */
-    signFailingNoop(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const op = {
-                kind: types_1.OpKind.FAILING_NOOP,
-                arbitrary: params.arbitrary,
-            };
-            const hash = yield this.context.readProvider.getBlockHash(params.basedOnBlock);
-            const forgedBytes = yield this.context.forger.forge({
-                branch: hash,
-                contents: [op],
-            });
-            const signature = yield this.walletProvider.sign(forgedBytes, Uint8Array.from([3]));
-            return {
-                signature,
-                bytes: forgedBytes,
-                signedContent: {
-                    branch: hash,
-                    contents: [
-                        {
-                            kind: types_1.OpKind.FAILING_NOOP,
-                            arbitrary: params.arbitrary,
-                        },
-                    ],
-                },
-            };
+    async signFailingNoop(params) {
+        const op = {
+            kind: types_1.OpKind.FAILING_NOOP,
+            arbitrary: params.arbitrary,
+        };
+        const hash = await this.context.readProvider.getBlockHash(params.basedOnBlock);
+        const forgedBytes = await this.context.forger.forge({
+            branch: hash,
+            contents: [op],
         });
+        const signature = await this.walletProvider.sign(forgedBytes, Uint8Array.from([3]));
+        return {
+            signature,
+            bytes: forgedBytes,
+            signedContent: {
+                branch: hash,
+                contents: [
+                    {
+                        kind: types_1.OpKind.FAILING_NOOP,
+                        arbitrary: params.arbitrary,
+                    },
+                ],
+            },
+        };
     }
     /**
-     * @description Register the current address as delegate.
+     * Register the current address as delegate.
      * @returns a DelegationWalletOperation promise object when followed by .send()
      */
     registerDelegate() {
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapDelegateParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () {
-                const delegate = yield this.pkh();
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapDelegateParamsToWalletParams(async () => {
+                const delegate = await this.pkh();
                 return { delegate };
-            }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
+            });
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
             return this.context.operationFactory.createDelegationOperation(opHash);
-        }));
+        });
     }
     /**
-     * @description Transfer tezos tokens from current address to a specific address or call a smart contract.
+     * Transfer tezos tokens from current address to a specific address or call a smart contract.
      * @returns a TransactionWalletOperation promise object when followed by .send()
      * @param params operation parameter
      */
@@ -285,14 +267,14 @@ class Wallet {
         if (toValidation !== utils_1.ValidationResult.VALID) {
             throw new core_1.InvalidAddressError(params.to, toValidation);
         }
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapTransferParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () { return params; }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapTransferParamsToWalletParams(async () => params);
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
             return this.context.operationFactory.createTransactionOperation(opHash);
-        }));
+        });
     }
     /**
-     * @description Transfer tezos tickets from current address to a specific address or a smart contract
+     * Transfer tezos tickets from current address to a specific address or a smart contract
      * @returns a TransferTicketWalletOperation promise object when followed by .send()
      * @param params operation parameter
      */
@@ -301,21 +283,21 @@ class Wallet {
         if (toValidation !== utils_1.ValidationResult.VALID) {
             throw new core_1.InvalidAddressError(params.destination, toValidation);
         }
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapTransferTicketParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () { return params; }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapTransferTicketParamsToWalletParams(async () => params);
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
             return this.context.operationFactory.createTransferTicketOperation(opHash);
-        }));
+        });
     }
     /**
-     * @description Stake a given amount for the source address
+     * Stake a given amount for the source address
      * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param Stake pseudo-operation parameter
+     * @param params Stake pseudo-operation parameter
      */
     stake(params) {
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapStakeParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () {
-                const source = yield this.pkh();
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapStakeParamsToWalletParams(async () => {
+                const source = await this.pkh();
                 if (!params.to) {
                     params.to = source;
                 }
@@ -324,22 +306,22 @@ class Wallet {
                 }
                 params.parameter = { entrypoint: 'stake', value: { prim: 'Unit' } };
                 return params;
-            }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
+            });
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
             return this.context.operationFactory.createTransactionOperation(opHash);
-        }));
+        });
     }
     /**
-     * @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 a TransactionWalletOperation promise object when followed by .send()
-     * @param Unstake pseudo-operation parameter
+     * @param params Unstake pseudo-operation parameter
      */
     unstake(params) {
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapUnstakeParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () {
-                const source = yield this.pkh();
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapUnstakeParamsToWalletParams(async () => {
+                const source = await this.pkh();
                 if (!params.to) {
                     params.to = source;
                 }
@@ -348,20 +330,20 @@ class Wallet {
                 }
                 params.parameter = { entrypoint: 'unstake', value: { prim: 'Unit' } };
                 return params;
-            }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
-            return yield this.context.operationFactory.createTransactionOperation(opHash);
-        }));
+            });
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
+            return await this.context.operationFactory.createTransactionOperation(opHash);
+        });
     }
     /**
-     * @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 a TransactionWalletOperation promise object when followed by .send()
-     * @param Finalize_unstake pseudo-operation parameter
+     * @param params Finalize_unstake pseudo-operation parameter
      */
     finalizeUnstake(params) {
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapFinalizeUnstakeParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () {
-                const source = yield this.pkh();
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapFinalizeUnstakeParamsToWalletParams(async () => {
+                const source = await this.pkh();
                 if (!params.to) {
                     params.to = source;
                 }
@@ -373,13 +355,13 @@ class Wallet {
                 }
                 params.parameter = { entrypoint: 'finalize_unstake', value: { prim: 'Unit' } };
                 return params;
-            }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
-            return yield this.context.operationFactory.createTransactionOperation(opHash);
-        }));
+            });
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
+            return await this.context.operationFactory.createTransactionOperation(opHash);
+        });
     }
     /**
-     * @description Increase the paid storage of a smart contract.
+     * Increase the paid storage of a smart contract.
      * @returns a IncreasePaidStorageWalletOperation promise object when followed by .send()
      * @param params operation parameter
      */
@@ -388,26 +370,26 @@ class Wallet {
         if (destinationValidation !== utils_1.ValidationResult.VALID) {
             throw new core_1.InvalidAddressError(params.destination, destinationValidation);
         }
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapIncreasePaidStorageWalletParams(() => __awaiter(this, void 0, void 0, function* () { return params; }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapIncreasePaidStorageWalletParams(async () => params);
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
             return this.context.operationFactory.createIncreasePaidStorageOperation(opHash);
-        }));
+        });
     }
     /**
-     * @description Register a Micheline expression in a global table of constants.
+     * Register a Micheline expression in a global table of constants.
      * @returns a RegisterGlobalConstantWalletOperation promise object when followed by .send()
      * @param params operation parameter
      */
     registerGlobalConstant(params) {
-        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
-            const mappedParams = yield this.walletProvider.mapRegisterGlobalConstantParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () { return params; }));
-            const opHash = yield this.walletProvider.sendOperations([mappedParams]);
+        return this.walletCommand(async () => {
+            const mappedParams = await this.walletProvider.mapRegisterGlobalConstantParamsToWalletParams(async () => params);
+            const opHash = await this.walletProvider.sendOperations([mappedParams]);
             return this.context.operationFactory.createRegisterGlobalConstantOperation(opHash);
-        }));
+        });
     }
     /**
-     * @description Create a batch of operation
+     * Create a batch of operation
      * @returns A batch object from which we can add more operation or send a command to the wallet to execute the batch
      * @param params List of operation to initialize the batch with
      */
@@ -419,24 +401,45 @@ class Wallet {
         return batch;
     }
     /**
-     * @description Create an smart contract abstraction for the address specified. Calling entrypoints with the returned
+     * Create an smart contract abstraction for the address specified. Calling entrypoints with the returned
      * smart contract abstraction will leverage the wallet provider to make smart contract calls
      * @param address Smart contract address
-     * @throws {@link InvalidContractAddressError} If the contract address is not valid
+     * @throws InvalidContractAddressError If the contract address is not valid
      */
-    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) {
+            // Newly originated contracts can be visible at the operation's inclusion level in one RPC
+            // call and still lag on another endpoint of the same rolling node. Retry at head so
+            // wallet op.contract() behaves like octez-client, which resolves the originated contract
+            // after confirmation instead of pinning itself to a stale context forever.
+            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.context.contract, entrypoints, rpc, readProvider);
-            return contractAbstractionComposer(abs, this.context);
-        });
+            else {
+                throw error;
+            }
+        }
+        const abs = new contract_1.ContractAbstraction(address, contractState.script, this, this.context.contract, contractState.entrypoints, rpc, readProvider);
+        return contractAbstractionComposer(abs, this.context);
     }
 }
 exports.Wallet = Wallet;