@pushchain/core 6.0.20 → 6.0.21

package/src/lib/orchestrator/orchestrator.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Orchestrator = void 0;
-const tslib_1 = require("tslib");
 const chain_1 = require("../constants/chain");
 const enums_1 = require("../constants/enums");
 const progress_hook_types_1 = require("../progress-hook/progress-hook.types");
@@ -10,13 +9,29 @@ const formatters_1 = require("../formatters");
 const route_detector_1 = require("./route-detector");
 const data_utils_1 = require("./data-utils");
 const internals_1 = require("./internals");
+const gate_1 = require("./internals/pc20/gate");
 class Orchestrator {
+    universalSigner;
+    pushNetwork;
+    rpcUrls;
+    printTraces;
+    progressHook;
+    // These fields are accessed via `this.ctx` (OrchestratorContext cast) by internal modules
+    _pushClient = null;
+    _pushClientOptions = null;
     /* @internal */ get pushClient() {
         if (!this._pushClient) {
             this._pushClient = new push_client_1.PushClient(this._pushClientOptions);
         }
         return this._pushClient;
     }
+    /* @internal */ accountStatusCache = null;
+    /* @internal */ accountStatusReadyPromise;
+    /**
+     * @internal Mirrors `OrchestratorContext.currentRoute` — set at the top of
+     * execute()/trackTransaction() so emission sites pick the right ID range.
+     */
+    /* @internal */ currentRoute;
     get ctx() { return this; }
     _getResponseCallbacks() {
         return {
@@ -42,10 +57,6 @@ class Orchestrator {
         this.rpcUrls = rpcUrls;
         this.printTraces = printTraces;
         this.progressHook = progressHook;
-        // These fields are accessed via `this.ctx` (OrchestratorContext cast) by internal modules
-        this._pushClient = null;
-        this._pushClientOptions = null;
-        /* @internal */ this.accountStatusCache = null;
         let pushChain;
         if (pushNetwork === enums_1.PUSH_NETWORK.MAINNET) {
             pushChain = enums_1.CHAIN.PUSH_MAINNET;
@@ -85,20 +96,16 @@ class Orchestrator {
      * Fetches account status including UEA deployment state and version info.
      * Results are cached — pass forceRefresh to bypass cache.
      */
-    getAccountStatus(options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.getAccountStatus)(this.ctx, options);
-        });
+    async getAccountStatus(options) {
+        return (0, internals_1.getAccountStatus)(this.ctx, options);
     }
     /**
      * Upgrades the UEA to the latest implementation version.
      * Sends MsgMigrateUEA Cosmos message with EIP-712 signed MigrationPayload.
      * The UEA contract delegates to the UEAMigration contract to update implementation.
      */
-    upgradeAccount(options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.upgradeAccount)(this.ctx, options);
-        });
+    async upgradeAccount(options) {
+        return (0, internals_1.upgradeAccount)(this.ctx, options);
     }
     /**
      * Migrate the CEA contract on an external chain to the latest version.
@@ -107,10 +114,8 @@ class Orchestrator {
      * @param chain - The external chain where the CEA should be migrated
      * @returns Transaction response
      */
-    migrateCEA(chain) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.migrateCEA)(this.ctx, chain, this.execute.bind(this));
-        });
+    async migrateCEA(chain) {
+        return (0, internals_1.migrateCEA)(this.ctx, chain, this.execute.bind(this));
     }
     /**
      * Rescue stuck funds on a source chain.
@@ -121,180 +126,200 @@ class Orchestrator {
      * @param params - RescueFundsParams with universalTxId and prc20 token
      * @returns Transaction response
      */
-    rescueFunds(params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.rescueFunds)(this.ctx, params, this.execute.bind(this));
-        });
+    async rescueFunds(params) {
+        return (0, internals_1.rescueFunds)(this.ctx, params, this.execute.bind(this));
     }
     /**
      * Executes a transaction with automatic route detection.
      * Routes 2-4 (multi-chain) delegate to prepareTransaction().send().
      * Route 1 (Push Chain) dispatches to extracted sub-flow modules.
      */
-    execute(params, options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
-            const inlineProgressHook = params.progressHook;
-            if (options || inlineProgressHook) {
-                params = Object.assign(Object.assign({}, params), { options: Object.assign(Object.assign(Object.assign({}, params.options), (inlineProgressHook ? { progressHook: inlineProgressHook } : {})), options) });
-            }
-            const perCallHook = (_a = params.options) === null || _a === void 0 ? void 0 : _a.progressHook;
-            const originalExecuteHook = this.progressHook;
-            const currentHook = this.progressHook;
-            const shouldWrapPerCallHook = !!perCallHook &&
-                perCallHook !== currentHook &&
-                (currentHook === null || currentHook === void 0 ? void 0 : currentHook.__pushPerCallHook) !== perCallHook;
-            const attachPerCallHookForWait = (response) => {
-                if (perCallHook && response._setProgressHookNoReplay) {
-                    response._setProgressHookNoReplay(perCallHook);
-                }
-                return response;
+    async execute(params, options) {
+        const inlineProgressHook = params.progressHook;
+        if (options || inlineProgressHook) {
+            params = {
+                ...params,
+                options: {
+                    ...params.options,
+                    ...(inlineProgressHook ? { progressHook: inlineProgressHook } : {}),
+                    ...options,
+                },
             };
-            if (shouldWrapPerCallHook) {
-                const baseHook = this.progressHook;
-                const wrappedHook = ((event) => {
-                    if (baseHook && baseHook !== perCallHook) {
-                        baseHook(event);
-                    }
-                    perCallHook(event);
-                });
-                wrappedHook.__pushPerCallHook = perCallHook;
-                this.progressHook = wrappedHook;
-            }
-            // Snapshot the caller's active route — `executeMultiChain` recurses into
-            // this same method for R2/R3's inner Push-side execution, and without
-            // snapshot/restore the recursive `detectRoute(params)` would clobber the
-            // outer R2/R3 route with UOA_TO_PUSH (the inner `to` is a string, no
-            // `from`), defeating R1-suppression in fireProgressHook.
-            const previousRoute = this.currentRoute;
-            const isRecursiveInnerCall = previousRoute !== undefined;
-            let detectedRoute;
-            try {
-                detectedRoute = (0, route_detector_1.detectRoute)(params);
-            }
-            catch (_f) {
-                detectedRoute = route_detector_1.TransactionRoute.UOA_TO_PUSH;
+        }
+        const perCallHook = params.options?.progressHook;
+        const originalExecuteHook = this.progressHook;
+        const currentHook = this.progressHook;
+        const shouldWrapPerCallHook = !!perCallHook &&
+            perCallHook !== currentHook &&
+            currentHook?.__pushPerCallHook !== perCallHook;
+        const attachPerCallHookForWait = (response) => {
+            if (perCallHook && response._setProgressHookNoReplay) {
+                response._setProgressHookNoReplay(perCallHook);
             }
-            // Don't downgrade an outer R2/R3/R4 route when the recursive inner call
-            // resolves to R1 — keep the outer perspective so emission stays consistent.
-            const shouldPreserveOuter = isRecursiveInnerCall &&
-                previousRoute !== route_detector_1.TransactionRoute.UOA_TO_PUSH &&
-                detectedRoute === route_detector_1.TransactionRoute.UOA_TO_PUSH;
-            this.currentRoute = shouldPreserveOuter ? previousRoute : detectedRoute;
-            // Reset the terminal-emitted flag at the start of each execute call so
-            // the outer catch below can tell whether a route handler already fired
-            // a terminal-ish error hook (104-04 / 204-04 / 304-04 / 199-02) and
-            // should suppress the second terminal (199-02 / 299-02 / 399-02).
-            this.ctx._routeTerminalEmitted = false;
+            return response;
+        };
+        if (shouldWrapPerCallHook) {
+            const baseHook = this.progressHook;
+            const wrappedHook = ((event) => {
+                if (baseHook && baseHook !== perCallHook) {
+                    baseHook(event);
+                }
+                perCallHook(event);
+            });
+            wrappedHook.__pushPerCallHook = perCallHook;
+            this.progressHook = wrappedHook;
+        }
+        // Snapshot the caller's active route — `executeMultiChain` recurses into
+        // this same method for R2/R3's inner Push-side execution, and without
+        // snapshot/restore the recursive `detectRoute(params)` would clobber the
+        // outer R2/R3 route with UOA_TO_PUSH (the inner `to` is a string, no
+        // `from`), defeating R1-suppression in fireProgressHook.
+        const previousRoute = this.currentRoute;
+        const isRecursiveInnerCall = previousRoute !== undefined;
+        let detectedRoute;
+        try {
+            detectedRoute = (0, route_detector_1.detectRoute)(params);
+        }
+        catch {
+            detectedRoute = route_detector_1.TransactionRoute.UOA_TO_PUSH;
+        }
+        // Don't downgrade an outer R2/R3/R4 route when the recursive inner call
+        // resolves to R1 — keep the outer perspective so emission stays consistent.
+        const shouldPreserveOuter = isRecursiveInnerCall &&
+            previousRoute !== route_detector_1.TransactionRoute.UOA_TO_PUSH &&
+            detectedRoute === route_detector_1.TransactionRoute.UOA_TO_PUSH;
+        this.currentRoute = shouldPreserveOuter ? previousRoute : detectedRoute;
+        // Reset the terminal-emitted flag at the start of each execute call so
+        // the outer catch below can tell whether a route handler already fired
+        // a terminal-ish error hook (104-04 / 204-04 / 304-04 / 199-02) and
+        // should suppress the second terminal (199-02 / 299-02 / 399-02).
+        this.ctx._routeTerminalEmitted = false;
+        try {
+            // Lazy UEA upgrade check
             try {
-                // Lazy UEA upgrade check
-                try {
-                    if (!this.accountStatusCache || !this.accountStatusCache.uea.loaded) {
-                        yield ((_b = this.accountStatusReadyPromise) !== null && _b !== void 0 ? _b : this.getAccountStatus());
-                    }
-                    // If background resolved but cache still empty (timeout/error), fetch fresh
-                    if (!this.accountStatusCache || !this.accountStatusCache.uea.loaded) {
-                        yield this.getAccountStatus();
-                    }
-                    if (((_c = this.accountStatusCache) === null || _c === void 0 ? void 0 : _c.uea.deployed) &&
-                        ((_d = this.accountStatusCache) === null || _d === void 0 ? void 0 : _d.uea.requiresUpgrade)) {
-                        yield this.upgradeAccount({ progressHook: this.progressHook });
-                    }
+                if (!this.accountStatusCache || !this.accountStatusCache.uea.loaded) {
+                    await (this.accountStatusReadyPromise ?? this.getAccountStatus());
                 }
-                catch (err) {
-                    (0, internals_1.printLog)(this.ctx, `Lazy UEA upgrade check failed: ${err instanceof Error ? err.message : String(err)}. Proceeding with transaction.`);
+                // If background resolved but cache still empty (timeout/error), fetch fresh
+                if (!this.accountStatusCache || !this.accountStatusCache.uea.loaded) {
+                    await this.getAccountStatus();
                 }
-                // Check if this is a multi-chain request (has ChainTarget or from.chain)
-                const isMultiChain = (0, route_detector_1.isChainTarget)(params.to) || ('from' in params && ((_e = params.from) === null || _e === void 0 ? void 0 : _e.chain));
-                if (isMultiChain) {
-                    try {
-                        return attachPerCallHookForWait(yield (0, internals_1.executeMultiChain)(this.ctx, params, this.execute.bind(this)));
-                    }
-                    catch (err) {
-                        // R2/R3/R4 outer catch — fires the route-correct terminal failure
-                        // hook (299-02 / 399-02) when an inner route handler throws BEFORE
-                        // its own try/catch around executeFn (e.g. pre-flight balance
-                        // check throws). Without this, the hook stream ends mid-flight and
-                        // consumers have no terminal close-out marker.
-                        if (!isRecursiveInnerCall && !this.ctx._routeTerminalEmitted) {
-                            const errMessage = (0, formatters_1.normalizePublicErrorMessage)(err);
-                            // Lift any structured `decodedError` off the typed error so the
-                            // formatter's optional payload field gets populated.
-                            const decodedError = err instanceof Error && err.decodedError
-                                ? err.decodedError
-                                : undefined;
-                            if (this.currentRoute === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
-                                (0, internals_1.fireProgressHook)(this.ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02, errMessage, 'push', undefined, decodedError);
-                            }
-                            else if (this.currentRoute === route_detector_1.TransactionRoute.UOA_TO_CEA) {
-                                // 299-02 needs the target chain — pull it off ChainTarget.
-                                const targetChain = (0, route_detector_1.isChainTarget)(params.to) && params.to ? params.to.chain : 'unknown';
-                                (0, internals_1.fireProgressHook)(this.ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_02, targetChain, errMessage, decodedError);
-                            }
-                            else {
-                                (0, internals_1.fireProgressHook)(this.ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_02, errMessage, decodedError);
-                            }
-                        }
-                        throw err;
-                    }
+                if (this.accountStatusCache?.uea.deployed &&
+                    this.accountStatusCache?.uea.requiresUpgrade) {
+                    await this.upgradeAccount({ progressHook: this.progressHook });
                 }
-                // Standard Push Chain execution (Route 1)
-                const execute = params;
-                const hasData = (0, data_utils_1.hasExecutablePayloadData)(execute.data);
-                const eventBuffer = [];
-                const originalHook = this.progressHook;
-                this.progressHook = (event) => {
-                    eventBuffer.push(event);
-                    if (originalHook)
-                        originalHook(event);
-                };
+            }
+            catch (err) {
+                (0, internals_1.printLog)(this.ctx, `Lazy UEA upgrade check failed: ${err instanceof Error ? err.message : String(err)}. Proceeding with transaction.`);
+            }
+            // Check if this is a multi-chain request (has ChainTarget or from.chain)
+            const isMultiChain = (0, route_detector_1.isChainTarget)(params.to) || ('from' in params && params.from?.chain);
+            if (isMultiChain) {
                 try {
-                    const rcb = () => this._getResponseCallbacks();
-                    if (execute.funds) {
-                        return attachPerCallHookForWait(!hasData
-                            ? yield (0, internals_1.executeFundsOnly)(this.ctx, execute, eventBuffer, rcb)
-                            : yield (0, internals_1.executeFundsWithPayload)(this.ctx, execute, eventBuffer, rcb));
-                    }
-                    return attachPerCallHookForWait(yield (0, internals_1.executeStandardPayload)(this.ctx, execute, eventBuffer, rcb));
+                    // PC20 gate for the multi-chain routes. Resolves and validates before
+                    // the route handlers quote gas or approve anything — a chain/address
+                    // mismatch must cost the caller nothing.
+                    const gatedParams = (await (0, gate_1.gateFunds)(this.ctx, params));
+                    return attachPerCallHookForWait(await (0, internals_1.executeMultiChain)(this.ctx, gatedParams, this.execute.bind(this)));
                 }
                 catch (err) {
-                    const errMessage = (0, formatters_1.normalizePublicErrorMessage)(err);
-                    // Only the outermost frame emits the terminal error hook, and it picks
-                    // the route-correct ID. Recursive inner frames just re-throw so the
-                    // outer catch drives emission — avoids double-firing 199/299/399 events.
-                    // Additionally, if an inner route handler already fired a terminal-ish
-                    // error (104-04/204-04/304-04/199-02 via execute-standard), the flag is
-                    // set on ctx and we skip emitting a second terminal here.
+                    // R2/R3/R4 outer catch — fires the route-correct terminal failure
+                    // hook (299-02 / 399-02) when an inner route handler throws BEFORE
+                    // its own try/catch around executeFn (e.g. pre-flight balance
+                    // check throws). Without this, the hook stream ends mid-flight and
+                    // consumers have no terminal close-out marker.
                     if (!isRecursiveInnerCall && !this.ctx._routeTerminalEmitted) {
-                        // For R3, the failure surfaced during execute-phase (pre-wait) is a
-                        // Push-chain-side failure — tag phase='push' so 399-02 renders the
-                        // correct "Push Chain Tx Failed" title instead of the inbound copy.
+                        const errMessage = (0, formatters_1.normalizePublicErrorMessage)(err);
+                        // Lift any structured `decodedError` off the typed error so the
+                        // formatter's optional payload field gets populated.
+                        const decodedError = err instanceof Error && err.decodedError
+                            ? err.decodedError
+                            : undefined;
                         if (this.currentRoute === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
-                            (0, internals_1.fireProgressHook)(this.ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02, errMessage, 'push');
+                            (0, internals_1.fireProgressHook)(this.ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02, errMessage, 'push', undefined, decodedError);
+                        }
+                        else if (this.currentRoute === route_detector_1.TransactionRoute.UOA_TO_CEA) {
+                            // 299-02 needs the target chain — pull it off ChainTarget.
+                            const targetChain = (0, route_detector_1.isChainTarget)(params.to) && params.to ? params.to.chain : 'unknown';
+                            (0, internals_1.fireProgressHook)(this.ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_02, targetChain, errMessage, decodedError);
                         }
                         else {
-                            const terminalId = this.currentRoute === route_detector_1.TransactionRoute.UOA_TO_CEA
-                                ? progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_02
-                                : progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_02;
-                            (0, internals_1.fireProgressHook)(this.ctx, terminalId, errMessage);
+                            (0, internals_1.fireProgressHook)(this.ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_02, errMessage, decodedError);
                         }
                     }
                     throw err;
                 }
-                finally {
-                    // Restore original progressHook
-                    this.progressHook = originalHook;
+            }
+            // Standard Push Chain execution (Route 1)
+            const execute = params;
+            const hasData = (0, data_utils_1.hasExecutablePayloadData)(execute.data);
+            const eventBuffer = [];
+            const originalHook = this.progressHook;
+            this.progressHook = (event) => {
+                eventBuffer.push(event);
+                if (originalHook)
+                    originalHook(event);
+            };
+            try {
+                const rcb = () => this._getResponseCallbacks();
+                if (execute.funds) {
+                    // Single PC20 gate. Downstream builders only ever see the legacy
+                    // PRC20/native shape; the PC20 branch is added here in Phase 2.
+                    const legacy = await (0, gate_1.gateFunds)(this.ctx, execute);
+                    // SVM PC20 imports never take the raw funds-only path: the Solana
+                    // gateway prepends the PC20 selector to the (empty) payload and
+                    // classifies the RESULT as FUNDS_AND_PAYLOAD, and the chain's
+                    // inbound decode hard-fails on that selector-only payload with no
+                    // revert — the wrapper is already burned (same "0x" vs "" guard as
+                    // the R3 brick). The payload path always carries a real forward
+                    // payload (UEA multicall transfer to `to`), which classifies and
+                    // decodes legitimately — the same always-forward mitigation R3
+                    // ships on both VMs.
+                    const svmPc20Import = legacy._pc20?.direction === 'import' &&
+                        chain_1.CHAIN_INFO[this.ctx.universalSigner.account.chain].vm === enums_1.VM.SVM;
+                    return attachPerCallHookForWait(!hasData && !svmPc20Import
+                        ? await (0, internals_1.executeFundsOnly)(this.ctx, legacy, eventBuffer, rcb)
+                        : await (0, internals_1.executeFundsWithPayload)(this.ctx, legacy, eventBuffer, rcb));
                 }
+                return attachPerCallHookForWait(await (0, internals_1.executeStandardPayload)(this.ctx, execute, eventBuffer, rcb));
             }
-            finally {
-                if (shouldWrapPerCallHook) {
-                    this.progressHook = originalExecuteHook;
+            catch (err) {
+                const errMessage = (0, formatters_1.normalizePublicErrorMessage)(err);
+                // Only the outermost frame emits the terminal error hook, and it picks
+                // the route-correct ID. Recursive inner frames just re-throw so the
+                // outer catch drives emission — avoids double-firing 199/299/399 events.
+                // Additionally, if an inner route handler already fired a terminal-ish
+                // error (104-04/204-04/304-04/199-02 via execute-standard), the flag is
+                // set on ctx and we skip emitting a second terminal here.
+                if (!isRecursiveInnerCall && !this.ctx._routeTerminalEmitted) {
+                    // For R3, the failure surfaced during execute-phase (pre-wait) is a
+                    // Push-chain-side failure — tag phase='push' so 399-02 renders the
+                    // correct "Push Chain Tx Failed" title instead of the inbound copy.
+                    if (this.currentRoute === route_detector_1.TransactionRoute.CEA_TO_PUSH) {
+                        (0, internals_1.fireProgressHook)(this.ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02, errMessage, 'push');
+                    }
+                    else {
+                        const terminalId = this.currentRoute === route_detector_1.TransactionRoute.UOA_TO_CEA
+                            ? progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_02
+                            : progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_02;
+                        (0, internals_1.fireProgressHook)(this.ctx, terminalId, errMessage);
+                    }
                 }
-                // Restore the caller's route so a recursive inner R1 execute doesn't
-                // leak its UOA_TO_PUSH route back to the outer R2/R3 frame.
-                this.currentRoute = previousRoute;
+                throw err;
+            }
+            finally {
+                // Restore original progressHook
+                this.progressHook = originalHook;
+            }
+        }
+        finally {
+            if (shouldWrapPerCallHook) {
+                this.progressHook = originalExecuteHook;
             }
-        });
+            // Restore the caller's route so a recursive inner R1 execute doesn't
+            // leak its UOA_TO_PUSH route back to the outer R2/R3 frame.
+            this.currentRoute = previousRoute;
+        }
     }
     /**
      * Prepare a universal transaction without executing it.
@@ -304,13 +329,17 @@ class Orchestrator {
      * @param options - Optional transaction behavior switches.
      * @returns PreparedUniversalTx with chaining capabilities
      */
-    prepareTransaction(params, options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (options) {
-                params = Object.assign(Object.assign({}, params), { options: Object.assign(Object.assign({}, params.options), options) });
-            }
-            return (0, internals_1.prepareTransaction)(this.ctx, params, this._getCascadeCallbacks());
-        });
+    async prepareTransaction(params, options) {
+        if (options) {
+            params = {
+                ...params,
+                options: {
+                    ...params.options,
+                    ...options,
+                },
+            };
+        }
+        return (0, internals_1.prepareTransaction)(this.ctx, params, this._getCascadeCallbacks());
     }
     /**
      * Creates a cascaded transaction builder for nested multi-chain execution.
@@ -324,8 +353,8 @@ class Orchestrator {
      * @returns Object with send() method
      */
     createCascadedBuilder(preparedTxs, options) {
-        const perCallHook = options === null || options === void 0 ? void 0 : options.progressHook;
-        const cascadeOptions = (options === null || options === void 0 ? void 0 : options.enforceGasCheck) === true
+        const perCallHook = options?.progressHook;
+        const cascadeOptions = options?.enforceGasCheck === true
             ? { enforceGasCheck: true }
             : undefined;
         if (!perCallHook) {
@@ -344,7 +373,7 @@ class Orchestrator {
         // reference-dedup.
         const innerBuilder = (0, internals_1.createCascadedBuilder)(this.ctx, preparedTxs, this._getCascadeCallbacks(), perCallHook, cascadeOptions);
         return {
-            send: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            send: async () => {
                 const originalHook = this.progressHook;
                 const wrapped = (event) => {
                     if (originalHook && originalHook !== perCallHook) {
@@ -354,37 +383,31 @@ class Orchestrator {
                 };
                 this.progressHook = wrapped;
                 try {
-                    return yield innerBuilder.send();
+                    return await innerBuilder.send();
                 }
                 finally {
                     this.progressHook = originalHook;
                 }
-            }),
+            },
         };
     }
     /**
      * Queries gas fee for an outbound transaction from the UniversalCore contract.
      */
-    queryOutboundGasFee(prc20Token, gasLimit, destinationChain) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.queryOutboundGasFee)(this.ctx, prc20Token, gasLimit, destinationChain);
-        });
+    async queryOutboundGasFee(prc20Token, gasLimit, destinationChain) {
+        return (0, internals_1.queryOutboundGasFee)(this.ctx, prc20Token, gasLimit, destinationChain);
     }
     /**
        * Extracts the first universal sub-tx ID from a Push Chain transaction's Cosmos events.
        */
-    extractUniversalSubTxIdFromTx(pushChainTxHash) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.extractUniversalSubTxIdFromTx)(this.ctx, pushChainTxHash);
-        });
+    async extractUniversalSubTxIdFromTx(pushChainTxHash) {
+        return (0, internals_1.extractUniversalSubTxIdFromTx)(this.ctx, pushChainTxHash);
     }
     /**
      * Extracts all universal sub-tx IDs from a cascaded Push Chain transaction.
      */
-    extractAllUniversalSubTxIds(pushChainTxHash) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.extractAllUniversalSubTxIds)(this.ctx, pushChainTxHash);
-        });
+    async extractAllUniversalSubTxIds(pushChainTxHash) {
+        return (0, internals_1.extractAllUniversalSubTxIds)(this.ctx, pushChainTxHash);
     }
     /**
      * Tracks a transaction by hash on Push Chain and returns UniversalTxResponse.
@@ -399,10 +422,8 @@ class Orchestrator {
      * @throws If `options.chain` is provided but is not a supported chain (not present in CHAIN_INFO)
      * @throws If a source-leg hash cannot be resolved to a universal transaction on Push Chain
      */
-    trackTransaction(txHash, options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.trackTransaction)(this.ctx, txHash, options, this._getResponseCallbacks());
-        });
+    async trackTransaction(txHash, options) {
+        return (0, internals_1.trackTransaction)(this.ctx, txHash, options, this._getResponseCallbacks());
     }
     /**
      * Computes UEA for given UniversalAccount
@@ -410,10 +431,8 @@ class Orchestrator {
      * @dev - Don't use this fn in production - only used for testing
      * @returns UEA Address with Deployment Status
      */
-    computeUEA() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, internals_1.computeUEA)(this.ctx);
-        });
+    async computeUEA() {
+        return (0, internals_1.computeUEA)(this.ctx);
     }
     computeUEAOffchain() {
         return (0, internals_1.computeUEAOffchain)(this.ctx);
@@ -429,10 +448,8 @@ class Orchestrator {
      * Quotes exact-output on Uniswap V3 for EVM origin chains using QuoterV2.
      * Returns the minimum required input (amountIn) to receive the target amountOut.
      */
-    _quoteExactOutput(amountOut_1, _a) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* (amountOut, { from, to, }) {
-            return (0, internals_1.quoteExactOutput)(this.ctx, amountOut, { from, to });
-        });
+    async _quoteExactOutput(amountOut, { from, to, }) {
+        return (0, internals_1.quoteExactOutput)(this.ctx, amountOut, { from, to });
     }
 }
 exports.Orchestrator = Orchestrator;