@taquito/taquito 24.2.0 → 24.3.0-beta.0

package/dist/lib/wallet/legacy.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.LegacyWalletProvider = void 0;
 const types_1 = require("../operations/types");
@@ -15,72 +6,46 @@ class LegacyWalletProvider {
     constructor(context) {
         this.context = context;
     }
-    getPKH() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.context.signer.publicKeyHash();
-        });
+    async getPKH() {
+        return this.context.signer.publicKeyHash();
     }
-    getPK() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.context.signer.publicKey();
-        });
+    async getPK() {
+        return this.context.signer.publicKey();
     }
-    mapTransferParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSACTION);
-        });
+    async mapTransferParamsToWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.TRANSACTION);
     }
-    mapStakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSACTION);
-        });
+    async mapStakeParamsToWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.TRANSACTION);
     }
-    mapUnstakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSACTION);
-        });
+    async mapUnstakeParamsToWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.TRANSACTION);
     }
-    mapFinalizeUnstakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSACTION);
-        });
+    async mapFinalizeUnstakeParamsToWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.TRANSACTION);
     }
-    mapOriginateParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.ORIGINATION);
-        });
+    async mapOriginateParamsToWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.ORIGINATION);
     }
-    mapDelegateParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.DELEGATION);
-        });
+    async mapDelegateParamsToWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.DELEGATION);
     }
-    mapIncreasePaidStorageWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.INCREASE_PAID_STORAGE);
-        });
+    async mapIncreasePaidStorageWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.INCREASE_PAID_STORAGE);
     }
-    mapTransferTicketParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSFER_TICKET);
-        });
+    async mapTransferTicketParamsToWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.TRANSFER_TICKET);
     }
-    mapRegisterGlobalConstantParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, types_1.attachKind)(yield params(), types_1.OpKind.REGISTER_GLOBAL_CONSTANT);
-        });
+    async mapRegisterGlobalConstantParamsToWalletParams(params) {
+        return (0, types_1.attachKind)(await params(), types_1.OpKind.REGISTER_GLOBAL_CONSTANT);
     }
-    sendOperations(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const op = yield this.context.batch.batch(params).send();
-            return op.hash;
-        });
+    async sendOperations(params) {
+        const op = await this.context.batch.batch(params).send();
+        return op.hash;
     }
-    sign(bytes, watermark) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { prefixSig } = yield this.context.signer.sign(bytes, watermark);
-            return prefixSig;
-        });
+    async sign(bytes, watermark) {
+        const { prefixSig } = await this.context.signer.sign(bytes, watermark);
+        return prefixSig;
     }
 }
 exports.LegacyWalletProvider = LegacyWalletProvider;

package/dist/lib/wallet/operation-factory.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.OperationFactory = exports.createNewPollingBasedHeadObservable = void 0;
 exports.timeoutAfter = timeoutAfter;
@@ -48,70 +39,50 @@ class OperationFactory {
             return (0, create_observable_from_subscription_1.createObservableFromSubscription)(this.context.stream.subscribeBlock('head'));
         });
     }
-    createNewHeadObservable() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, exports.createNewPollingBasedHeadObservable)(this.sharedHeadObs, this.context);
-        });
+    async createNewHeadObservable() {
+        return (0, exports.createNewPollingBasedHeadObservable)(this.sharedHeadObs, this.context);
     }
     createPastBlockWalker(startBlock, count = 1) {
         return (0, rxjs_1.from)(this.context.readProvider.getBlock(startBlock)).pipe((0, operators_1.switchMap)((block) => {
             if (count === 1) {
                 return (0, rxjs_1.of)(block);
             }
-            return (0, rxjs_1.range)(block.header.level, count - 1).pipe((0, operators_1.startWith)(block), (0, operators_1.concatMap)((level) => __awaiter(this, void 0, void 0, function* () {
+            return (0, rxjs_1.range)(block.header.level, count - 1).pipe((0, operators_1.startWith)(block), (0, operators_1.concatMap)(async (level) => {
                 return this.context.readProvider.getBlock(typeof level === 'number' ? level : level.header.level);
-            })));
+            }));
         }));
     }
-    createHeadObservableFromConfig(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ blockIdentifier }) {
-            const observableSequence = [];
-            if (blockIdentifier) {
-                observableSequence.push(this.createPastBlockWalker(blockIdentifier));
-            }
-            observableSequence.push(yield this.createNewHeadObservable());
-            return (0, rxjs_1.concat)(...observableSequence);
-        });
+    async createHeadObservableFromConfig({ blockIdentifier }) {
+        const observableSequence = [];
+        if (blockIdentifier) {
+            observableSequence.push(this.createPastBlockWalker(blockIdentifier));
+        }
+        observableSequence.push(await this.createNewHeadObservable());
+        return (0, rxjs_1.concat)(...observableSequence);
     }
-    createOperation(hash_1) {
-        return __awaiter(this, arguments, void 0, function* (hash, config = {}) {
-            return new operation_1.WalletOperation(hash, this.context.clone(), yield this.createHeadObservableFromConfig(config));
-        });
+    async createOperation(hash, config = {}) {
+        return new operation_1.WalletOperation(hash, this.context.clone(), await this.createHeadObservableFromConfig(config));
     }
-    createBatchOperation(hash_1) {
-        return __awaiter(this, arguments, void 0, function* (hash, config = {}) {
-            return new batch_operation_1.BatchWalletOperation(hash, this.context.clone(), yield this.createHeadObservableFromConfig(config));
-        });
+    async createBatchOperation(hash, config = {}) {
+        return new batch_operation_1.BatchWalletOperation(hash, this.context.clone(), await this.createHeadObservableFromConfig(config));
     }
-    createTransactionOperation(hash_1) {
-        return __awaiter(this, arguments, void 0, function* (hash, config = {}) {
-            return new transaction_operation_1.TransactionWalletOperation(hash, this.context.clone(), yield this.createHeadObservableFromConfig(config));
-        });
+    async createTransactionOperation(hash, config = {}) {
+        return new transaction_operation_1.TransactionWalletOperation(hash, this.context.clone(), await this.createHeadObservableFromConfig(config));
     }
-    createTransferTicketOperation(hash_1) {
-        return __awaiter(this, arguments, void 0, function* (hash, config = {}) {
-            return new transfer_ticket_operation_1.TransferTicketWalletOperation(hash, this.context.clone(), yield this.createHeadObservableFromConfig(config));
-        });
+    async createTransferTicketOperation(hash, config = {}) {
+        return new transfer_ticket_operation_1.TransferTicketWalletOperation(hash, this.context.clone(), await this.createHeadObservableFromConfig(config));
     }
-    createDelegationOperation(hash_1) {
-        return __awaiter(this, arguments, void 0, function* (hash, config = {}) {
-            return new delegation_operation_1.DelegationWalletOperation(hash, this.context.clone(), yield this.createHeadObservableFromConfig(config));
-        });
+    async createDelegationOperation(hash, config = {}) {
+        return new delegation_operation_1.DelegationWalletOperation(hash, this.context.clone(), await this.createHeadObservableFromConfig(config));
     }
-    createOriginationOperation(hash_1) {
-        return __awaiter(this, arguments, void 0, function* (hash, config = {}) {
-            return new origination_operation_1.OriginationWalletOperation(hash, this.context.clone(), yield this.createHeadObservableFromConfig(config));
-        });
+    async createOriginationOperation(hash, config = {}) {
+        return new origination_operation_1.OriginationWalletOperation(hash, this.context.clone(), await this.createHeadObservableFromConfig(config));
     }
-    createIncreasePaidStorageOperation(hash_1) {
-        return __awaiter(this, arguments, void 0, function* (hash, config = {}) {
-            return new increase_paid_storage_operation_1.IncreasePaidStorageWalletOperation(hash, this.context.clone(), yield this.createHeadObservableFromConfig(config));
-        });
+    async createIncreasePaidStorageOperation(hash, config = {}) {
+        return new increase_paid_storage_operation_1.IncreasePaidStorageWalletOperation(hash, this.context.clone(), await this.createHeadObservableFromConfig(config));
     }
-    createRegisterGlobalConstantOperation(hash_1) {
-        return __awaiter(this, arguments, void 0, function* (hash, config = {}) {
-            return new register_global_constant_operation_1.RegisterGlobalConstantWalletOperation(hash, this.context.clone(), yield this.createHeadObservableFromConfig(config));
-        });
+    async createRegisterGlobalConstantOperation(hash, config = {}) {
+        return new register_global_constant_operation_1.RegisterGlobalConstantWalletOperation(hash, this.context.clone(), await this.createHeadObservableFromConfig(config));
     }
 }
 exports.OperationFactory = OperationFactory;

package/dist/lib/wallet/operation.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.WalletOperation = void 0;
 const rxjs_1 = require("rxjs");
@@ -18,32 +9,76 @@ const errors_1 = require("../errors");
 const errors_2 = require("./errors");
 const core_1 = require("@taquito/core");
 const MAX_BRANCH_ANCESTORS = 60;
+const walletOpTraceEnabled = /^(1|true)$/i.test(process?.env?.TAQUITO_OP_TRACE ?? '');
+const walletOpTraceVerbose = /^(1|true)$/i.test(process?.env?.TAQUITO_OP_TRACE_VERBOSE ?? '');
+const parsedWalletOpTraceSlowMs = Number(process?.env?.TAQUITO_OP_TRACE_SLOW_MS ?? '60000');
+const walletOpTraceSlowMs = Number.isFinite(parsedWalletOpTraceSlowMs) && parsedWalletOpTraceSlowMs >= 0
+    ? parsedWalletOpTraceSlowMs
+    : 60000;
+const asRecord = (value) => typeof value === 'object' && value !== null ? value : undefined;
+const getErrors = (value) => (Array.isArray(value) ? value : []);
+const summarizeWalletOperationResults = (results) => Array.isArray(results)
+    ? results.map((result) => {
+        const resultRecord = asRecord(result) ?? {};
+        const metadata = asRecord(resultRecord.metadata);
+        const operationResult = asRecord(metadata?.operation_result);
+        return {
+            kind: typeof resultRecord.kind === 'string' ? resultRecord.kind : 'unknown',
+            status: typeof operationResult?.status === 'string' ? operationResult.status : 'unknown',
+            errors: getErrors(operationResult?.errors),
+            consumed_milligas: typeof operationResult?.consumed_milligas === 'string'
+                ? operationResult.consumed_milligas
+                : undefined,
+        };
+    })
+    : [];
+const toErrorMessage = (error) => {
+    if (error instanceof Error) {
+        return `${error.name}: ${error.message}`;
+    }
+    return String(error);
+};
+const traceWalletOperation = (payload) => {
+    if (!walletOpTraceEnabled) {
+        return;
+    }
+    // JSON logs are easier to aggregate when diagnosing flaky CI behavior.
+    console.log(`[taquito:wallet-op-trace] ${JSON.stringify(payload)}`);
+};
 /**
- * @description WalletOperation allows to monitor operation inclusion on chains and surface information related to the operation
+ * WalletOperation allows to monitor operation inclusion on chains and surface information related to the operation
  */
 class WalletOperation {
-    operationResults() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._operationResult.pipe((0, operators_1.first)()).toPromise();
-        });
+    async operationResults() {
+        return this._operationResult.pipe((0, operators_1.first)()).toPromise();
+    }
+    async getInclusionBlock() {
+        const inclusionBlock = await this._includedInBlock.pipe((0, operators_1.first)()).toPromise();
+        if (!inclusionBlock) {
+            throw new errors_2.ObservableError('Inclusion block is undefined');
+        }
+        return inclusionBlock;
+    }
+    async getOperationResultsIfIncluded() {
+        if (!this._included) {
+            return undefined;
+        }
+        return this.operationResults().catch(() => undefined);
     }
     /**
-     * @description Receipt expose the total amount of tezos token burn and spent on fees
+     * Receipt expose the total amount of tezos token burn and spent on fees
      * The promise returned by receipt will resolve only once the transaction is included
      */
-    receipt() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.operationResults();
-            if (!results) {
-                throw new errors_2.ObservableError('Unable to get operation results');
-            }
-            return (0, receipt_1.receiptFromOperation)(results);
-        });
+    async receipt() {
+        const results = await this.operationResults();
+        if (!results) {
+            throw new errors_2.ObservableError('Unable to get operation results');
+        }
+        return (0, receipt_1.receiptFromOperation)(results);
     }
     /**
      *
      * @param opHash Operation hash
-     * @param raw Raw operation that was injected
      * @param context Taquito context allowing access to rpc and signer
      * @throws {InvalidOperationHashError}
      */
@@ -55,8 +90,7 @@ class WalletOperation {
         this._includedInBlock = new rxjs_1.ReplaySubject(1);
         this._included = false;
         this.newHead$ = this._newHead$.pipe((0, operators_1.switchMap)((newHead) => {
-            var _a, _b;
-            const prevHead = (_b = (_a = this.lastHead) === null || _a === void 0 ? void 0 : _a.header.level) !== null && _b !== void 0 ? _b : newHead.header.level - 1;
+            const prevHead = this.lastHead?.header.level ?? newHead.header.level - 1;
             return (0, rxjs_1.range)(prevHead + 1, newHead.header.level - prevHead - 1).pipe((0, operators_1.concatMap)((level) => this.context.readProvider.getBlock(level)), (0, operators_1.endWith)(newHead));
         }), (0, operators_1.tap)((newHead) => (this.lastHead = newHead)), (0, operators_1.share)({
             connector: () => new rxjs_1.ReplaySubject(1),
@@ -92,38 +126,31 @@ class WalletOperation {
             .pipe((0, operators_1.first)(), (0, operators_1.catchError)(() => (0, rxjs_1.of)(undefined)))
             .subscribe();
     }
-    getCurrentConfirmation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._included) {
-                return 0;
-            }
-            return (0, rxjs_1.combineLatest)([this._includedInBlock, (0, rxjs_1.from)(this.context.readProvider.getBlock('head'))])
-                .pipe((0, operators_1.map)(([foundAtBlock, head]) => {
-                return head.header.level - foundAtBlock.header.level + 1;
-            }), (0, operators_1.first)())
-                .toPromise();
-        });
+    async getCurrentConfirmation() {
+        if (!this._included) {
+            return 0;
+        }
+        return (0, rxjs_1.combineLatest)([this._includedInBlock, (0, rxjs_1.from)(this.context.readProvider.getBlock('head'))])
+            .pipe((0, operators_1.map)(([foundAtBlock, head]) => {
+            return head.header.level - foundAtBlock.header.level + 1;
+        }), (0, operators_1.first)())
+            .toPromise();
     }
-    isInCurrentBranch() {
-        return __awaiter(this, arguments, void 0, function* (tipBlockIdentifier = 'head') {
-            // By default it is assumed that the operation is in the current branch
-            if (!this._included) {
-                return true;
-            }
-            const tipBlockHeaderLevel = yield this.context.readProvider.getBlockLevel(tipBlockIdentifier);
-            const inclusionBlock = yield this._includedInBlock.pipe((0, operators_1.first)()).toPromise();
-            if (!inclusionBlock) {
-                throw new errors_2.ObservableError('Inclusion block is undefined');
-            }
-            const levelDiff = (tipBlockHeaderLevel - inclusionBlock.header.level);
-            // Block produced before the operation is included are assumed to be part of the current branch
-            if (levelDiff <= 0) {
-                return true;
-            }
-            const tipBlockLevel = Math.min(inclusionBlock.header.level + levelDiff, inclusionBlock.header.level + MAX_BRANCH_ANCESTORS);
-            const blocks = new Set(yield this.context.readProvider.getLiveBlocks(tipBlockLevel));
-            return blocks.has(inclusionBlock.hash);
-        });
+    async isInCurrentBranch(tipBlockIdentifier = 'head') {
+        // By default it is assumed that the operation is in the current branch
+        if (!this._included) {
+            return true;
+        }
+        const tipBlockHeaderLevel = await this.context.readProvider.getBlockLevel(tipBlockIdentifier);
+        const inclusionBlock = await this.getInclusionBlock();
+        const levelDiff = (tipBlockHeaderLevel - inclusionBlock.header.level);
+        // Block produced before the operation is included are assumed to be part of the current branch
+        if (levelDiff <= 0) {
+            return true;
+        }
+        const tipBlockLevel = Math.min(inclusionBlock.header.level + levelDiff, inclusionBlock.header.level + MAX_BRANCH_ANCESTORS);
+        const blocks = new Set(await this.context.readProvider.getLiveBlocks(tipBlockLevel));
+        return blocks.has(inclusionBlock.hash);
     }
     confirmationObservable(confirmations) {
         if (typeof confirmations !== 'undefined' && confirmations < 1) {
@@ -150,8 +177,45 @@ class WalletOperation {
      *
      * @param confirmations [0] Number of confirmation to wait for
      */
-    confirmation(confirmations) {
-        return this.confirmationObservable(confirmations).toPromise();
+    async confirmation(confirmations) {
+        const startedAt = Date.now();
+        const expectedConfirmation = confirmations ?? this.context.config.defaultConfirmationCount;
+        try {
+            const confirmationResult = await this.confirmationObservable(confirmations).toPromise();
+            const operationResults = await this.getOperationResultsIfIncluded();
+            const summary = summarizeWalletOperationResults(operationResults);
+            const nonAppliedStatuses = summary
+                .filter((result) => result.status !== 'applied')
+                .map((result) => result.status);
+            const elapsedMs = Date.now() - startedAt;
+            if (walletOpTraceVerbose ||
+                elapsedMs >= walletOpTraceSlowMs ||
+                nonAppliedStatuses.length > 0) {
+                traceWalletOperation({
+                    stage: 'confirmation-complete',
+                    opHash: this.opHash,
+                    elapsedMs,
+                    expectedConfirmation,
+                    currentConfirmation: confirmationResult?.currentConfirmation,
+                    completed: confirmationResult?.completed,
+                    statuses: summary.map((result) => result.status),
+                    results: summary,
+                });
+            }
+            return confirmationResult;
+        }
+        catch (error) {
+            const operationResults = await this.getOperationResultsIfIncluded();
+            traceWalletOperation({
+                stage: 'confirmation-error',
+                opHash: this.opHash,
+                elapsedMs: Date.now() - startedAt,
+                expectedConfirmation,
+                error: toErrorMessage(error),
+                results: summarizeWalletOperationResults(operationResults),
+            });
+            throw error;
+        }
     }
 }
 exports.WalletOperation = WalletOperation;

package/dist/lib/wallet/origination-operation.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.OriginationWalletOperation = void 0;
 const rpc_1 = require("@taquito/rpc");
@@ -20,46 +11,43 @@ class OriginationWalletOperation extends operation_1.WalletOperation {
         this.opHash = opHash;
         this.context = context;
     }
-    originationOperation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const operationResult = yield this.operationResults();
-            if (operationResult) {
-                return (0, types_1.findWithKind)(operationResult, rpc_1.OpKind.ORIGINATION);
-            }
-            else {
-                throw new errors_1.ObservableError('Unable to fetch operation result');
-            }
-        });
+    async originationOperation() {
+        const operationResult = await this.operationResults();
+        if (operationResult) {
+            return (0, types_1.findWithKind)(operationResult, rpc_1.OpKind.ORIGINATION);
+        }
+        else {
+            throw new errors_1.ObservableError('Unable to fetch operation result');
+        }
     }
-    revealOperation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const operationResult = yield this.operationResults();
-            if (operationResult) {
-                return (0, types_1.findWithKind)(operationResult, rpc_1.OpKind.REVEAL);
-            }
-            else {
-                throw new errors_1.ObservableError('Unable to fetch operation result');
-            }
-        });
+    async revealOperation() {
+        const operationResult = await this.operationResults();
+        if (operationResult) {
+            return (0, types_1.findWithKind)(operationResult, rpc_1.OpKind.REVEAL);
+        }
+        else {
+            throw new errors_1.ObservableError('Unable to fetch operation result');
+        }
     }
-    status() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._included) {
-                return 'pending';
-            }
-            const op = yield this.originationOperation();
-            if (!op) {
-                return 'unknown';
-            }
-            return op.metadata.operation_result.status;
-        });
+    async status() {
+        if (!this._included) {
+            return 'pending';
+        }
+        const op = await this.originationOperation();
+        if (!op) {
+            return 'unknown';
+        }
+        return op.metadata.operation_result.status;
     }
-    contract() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const op = yield this.originationOperation();
-            const address = ((op === null || op === void 0 ? void 0 : op.metadata.operation_result.originated_contracts) || [])[0];
-            return this.context.wallet.at(address);
-        });
+    async contract() {
+        const op = await this.originationOperation();
+        const address = (op?.metadata.operation_result.originated_contracts || [])[0];
+        if (!address) {
+            throw new errors_1.OriginationWalletOperationError('No contract was originated in this operation');
+        }
+        await this.confirmation();
+        const inclusionBlock = await this.getInclusionBlock();
+        return this.context.wallet.at(address, undefined, inclusionBlock.header.level);
     }
 }
 exports.OriginationWalletOperation = OriginationWalletOperation;

package/dist/lib/wallet/register-global-constant-operation.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.RegisterGlobalConstantWalletOperation = void 0;
 const rpc_1 = require("@taquito/rpc");
@@ -20,43 +11,35 @@ class RegisterGlobalConstantWalletOperation extends operation_1.WalletOperation
         this.opHash = opHash;
         this.context = context;
     }
-    revealOperation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const operationResult = yield this.operationResults();
-            if (!operationResult) {
-                throw new errors_1.ObservableError('operationResult returned undefined');
-            }
-            return operationResult.find((x) => x.kind === rpc_1.OpKind.REVEAL);
-        });
+    async revealOperation() {
+        const operationResult = await this.operationResults();
+        if (!operationResult) {
+            throw new errors_1.ObservableError('operationResult returned undefined');
+        }
+        return operationResult.find((x) => x.kind === rpc_1.OpKind.REVEAL);
     }
-    registerGlobalConstantOperation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const operationResult = yield this.operationResults();
-            if (operationResult) {
-                return (0, types_1.findWithKind)(operationResult, rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT);
-            }
-            else {
-                throw new errors_1.ObservableError('Unable to fetch operation result');
-            }
-        });
+    async registerGlobalConstantOperation() {
+        const operationResult = await this.operationResults();
+        if (operationResult) {
+            return (0, types_1.findWithKind)(operationResult, rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT);
+        }
+        else {
+            throw new errors_1.ObservableError('Unable to fetch operation result');
+        }
     }
-    status() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._included) {
-                return 'pending';
-            }
-            const op = yield this.registerGlobalConstantOperation();
-            if (!op) {
-                return 'unknown';
-            }
-            return op.metadata.operation_result.status;
-        });
+    async status() {
+        if (!this._included) {
+            return 'pending';
+        }
+        const op = await this.registerGlobalConstantOperation();
+        if (!op) {
+            return 'unknown';
+        }
+        return op.metadata.operation_result.status;
     }
-    globalConstantHash() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const op = yield this.registerGlobalConstantOperation();
-            return op === null || op === void 0 ? void 0 : op.metadata.operation_result.global_address;
-        });
+    async globalConstantHash() {
+        const op = await this.registerGlobalConstantOperation();
+        return op?.metadata.operation_result.global_address;
     }
 }
 exports.RegisterGlobalConstantWalletOperation = RegisterGlobalConstantWalletOperation;