@pushchain/core 6.0.19 → 6.0.21

package/src/lib/orchestrator/internals/confirmation.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitForEvmConfirmationsWithCountdown = waitForEvmConfirmationsWithCountdown;
 exports.waitForSvmConfirmationsWithCountdown = waitForSvmConfirmationsWithCountdown;
 exports.waitForLockerFeeConfirmation = waitForLockerFeeConfirmation;
-const tslib_1 = require("tslib");
 const bs58_1 = require("../../internal/bs58");
 const viem_1 = require("viem");
 const chain_1 = require("../../constants/chain");
@@ -18,180 +17,171 @@ const context_2 = require("./context");
 const EVM_RECEIPT_POLL_MS = 3000;
 const EVM_RECEIPT_NOT_FOUND_RE = /not found|TransactionNotFound|TransactionReceiptNotFound|could not be found|No transaction found/i;
 function getErrorMessage(err) {
-    var _a, _b;
     if (err instanceof Error)
         return err.message;
     if (typeof err === 'object' && err !== null) {
         const maybe = err;
-        return String((_b = (_a = maybe.shortMessage) !== null && _a !== void 0 ? _a : maybe.message) !== null && _b !== void 0 ? _b : err);
+        return String(maybe.shortMessage ?? maybe.message ?? err);
     }
     return String(err);
 }
-function waitForEvmReceipt(evmClient, txHash, timeoutMs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const start = Date.now();
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            try {
-                return yield evmClient.publicClient.getTransactionReceipt({
-                    hash: txHash,
-                });
-            }
-            catch (err) {
-                const msg = getErrorMessage(err);
-                const retryable = EVM_RECEIPT_NOT_FOUND_RE.test(msg);
-                if (!retryable || Date.now() - start > timeoutMs) {
-                    throw err;
-                }
-                yield new Promise((r) => setTimeout(r, EVM_RECEIPT_POLL_MS));
+async function waitForEvmReceipt(evmClient, txHash, timeoutMs) {
+    const start = Date.now();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            return await evmClient.publicClient.getTransactionReceipt({
+                hash: txHash,
+            });
+        }
+        catch (err) {
+            const msg = getErrorMessage(err);
+            const retryable = EVM_RECEIPT_NOT_FOUND_RE.test(msg);
+            if (!retryable || Date.now() - start > timeoutMs) {
+                throw err;
             }
+            await new Promise((r) => setTimeout(r, EVM_RECEIPT_POLL_MS));
         }
-    });
+    }
 }
-function waitForEvmConfirmationsWithCountdown(ctx, evmClient, txHash, confirmations, timeoutMs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (confirmations <= 0) {
-            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02, 0, 0, txHash);
+async function waitForEvmConfirmationsWithCountdown(ctx, evmClient, txHash, confirmations, timeoutMs) {
+    if (confirmations <= 0) {
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02, 0, 0, txHash);
+        return;
+    }
+    (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03, confirmations, txHash);
+    const start = Date.now();
+    const receipt = await waitForEvmReceipt(evmClient, txHash, timeoutMs);
+    const targetBlock = receipt.blockNumber + BigInt(confirmations);
+    let lastEmitted = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const currentBlock = await evmClient.publicClient.getBlockNumber();
+        if (currentBlock >= targetBlock) {
+            if (lastEmitted < confirmations) {
+                (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02, confirmations, confirmations, txHash);
+            }
             return;
         }
-        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03, confirmations, txHash);
-        const start = Date.now();
-        const receipt = yield waitForEvmReceipt(evmClient, txHash, timeoutMs);
-        const targetBlock = receipt.blockNumber + BigInt(confirmations);
-        let lastEmitted = 0;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const currentBlock = yield evmClient.publicClient.getBlockNumber();
-            if (currentBlock >= targetBlock) {
-                if (lastEmitted < confirmations) {
-                    (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02, confirmations, confirmations, txHash);
-                }
+        const remaining = Number(targetBlock - currentBlock);
+        const completed = Math.max(1, confirmations - remaining + 1);
+        if (completed > lastEmitted) {
+            (0, context_2.fireProgressHook)(ctx, completed >= confirmations
+                ? progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02
+                : progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_01, completed, confirmations, txHash);
+            lastEmitted = completed;
+            if (completed >= confirmations)
                 return;
+        }
+        if (Date.now() - start > timeoutMs) {
+            throw new Error(`Timeout: transaction ${txHash} not confirmed with ${confirmations} confirmations within ${timeoutMs} ms`);
+        }
+        await new Promise((r) => setTimeout(r, 3000));
+    }
+}
+async function waitForSvmConfirmationsWithCountdown(ctx, svmClient, txSignature, confirmations, timeoutMs) {
+    if (confirmations <= 0) {
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02, 0, 0, txSignature);
+        return;
+    }
+    (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03, confirmations, txSignature);
+    const start = Date.now();
+    let lastConfirmed = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const connection = svmClient.connections[svmClient.currentConnectionIndex];
+        const { value } = await connection.getSignatureStatuses([txSignature]);
+        const status = value[0];
+        if (status) {
+            if (status.err) {
+                throw new Error(`SVM transaction ${txSignature} failed: ${JSON.stringify(status.err)}`);
             }
-            const remaining = Number(targetBlock - currentBlock);
-            const completed = Math.max(1, confirmations - remaining + 1);
-            if (completed > lastEmitted) {
-                (0, context_2.fireProgressHook)(ctx, completed >= confirmations
+            const rawConfirmations = status.confirmations;
+            const hasNumericConfirmations = rawConfirmations != null;
+            const currentConfirms = hasNumericConfirmations ? rawConfirmations : 0;
+            const isFinalized = status.err === null &&
+                (status.confirmationStatus === 'finalized' || status.confirmations === null);
+            const hasEnoughConfirmations = hasNumericConfirmations && currentConfirms >= confirmations;
+            if (currentConfirms > lastConfirmed) {
+                const clamped = currentConfirms >= confirmations ? confirmations : currentConfirms;
+                (0, context_2.fireProgressHook)(ctx, clamped >= confirmations
                     ? progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02
-                    : progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_01, completed, confirmations, txHash);
-                lastEmitted = completed;
-                if (completed >= confirmations)
-                    return;
+                    : progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_01, Math.max(1, clamped), confirmations, txSignature);
+                lastConfirmed = currentConfirms;
             }
-            if (Date.now() - start > timeoutMs) {
-                throw new Error(`Timeout: transaction ${txHash} not confirmed with ${confirmations} confirmations within ${timeoutMs} ms`);
+            if (hasEnoughConfirmations || isFinalized) {
+                if (lastConfirmed < confirmations) {
+                    (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02, confirmations, confirmations, txSignature);
+                }
+                return;
             }
-            yield new Promise((r) => setTimeout(r, 3000));
         }
-    });
-}
-function waitForSvmConfirmationsWithCountdown(ctx, svmClient, txSignature, confirmations, timeoutMs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (confirmations <= 0) {
-            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02, 0, 0, txSignature);
-            return;
+        if (Date.now() - start > timeoutMs) {
+            throw new Error(`Timeout: transaction ${txSignature} not confirmed with ${confirmations} confirmations within ${timeoutMs} ms`);
         }
-        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03, confirmations, txSignature);
-        const start = Date.now();
-        let lastConfirmed = 0;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const connection = svmClient.connections[svmClient.currentConnectionIndex];
-            const { value } = yield connection.getSignatureStatuses([txSignature]);
-            const status = value[0];
-            if (status) {
-                if (status.err) {
-                    throw new Error(`SVM transaction ${txSignature} failed: ${JSON.stringify(status.err)}`);
-                }
-                const rawConfirmations = status.confirmations;
-                const hasNumericConfirmations = rawConfirmations != null;
-                const currentConfirms = hasNumericConfirmations ? rawConfirmations : 0;
-                const isFinalized = status.err === null &&
-                    (status.confirmationStatus === 'finalized' || status.confirmations === null);
-                const hasEnoughConfirmations = hasNumericConfirmations && currentConfirms >= confirmations;
-                if (currentConfirms > lastConfirmed) {
-                    const clamped = currentConfirms >= confirmations ? confirmations : currentConfirms;
-                    (0, context_2.fireProgressHook)(ctx, clamped >= confirmations
-                        ? progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02
-                        : progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_01, Math.max(1, clamped), confirmations, txSignature);
-                    lastConfirmed = currentConfirms;
-                }
-                if (hasEnoughConfirmations || isFinalized) {
-                    if (lastConfirmed < confirmations) {
-                        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02, confirmations, confirmations, txSignature);
-                    }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+}
+async function waitForLockerFeeConfirmation(ctx, txHashBytes) {
+    const chain = ctx.universalSigner.account.chain;
+    const { vm, defaultRPC, fastConfirmations, timeout } = chain_1.CHAIN_INFO[chain];
+    // Poll silently — the fee-lock path fires SEND-TX-105-02 as its terminal
+    // confirmation marker; emitting 106-xx here would leak funds-bridge hooks
+    // into a non-funds-bridge path. Uses the same underlying RPC wait as the
+    // funds-bridge confirmation helpers but without the 106-03 / 106-03-02
+    // emissions.
+    switch (vm) {
+        case enums_1.VM.EVM: {
+            const evmClient = (0, context_1.getOriginEvmClient)(ctx);
+            const txHash = (0, viem_1.bytesToHex)(txHashBytes);
+            const receipt = await waitForEvmReceipt(evmClient, txHash, timeout);
+            if (fastConfirmations <= 1)
+                return;
+            const targetBlock = receipt.blockNumber + BigInt(fastConfirmations);
+            const start = Date.now();
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const currentBlock = await evmClient.publicClient.getBlockNumber();
+                if (currentBlock >= targetBlock)
                     return;
+                if (Date.now() - start > timeout) {
+                    throw new Error(`Timeout: fee-lock tx ${txHash} not confirmed with ${fastConfirmations} confirmations within ${timeout} ms`);
                 }
+                await new Promise((r) => setTimeout(r, 3000));
             }
-            if (Date.now() - start > timeoutMs) {
-                throw new Error(`Timeout: transaction ${txSignature} not confirmed with ${confirmations} confirmations within ${timeoutMs} ms`);
-            }
-            yield new Promise((r) => setTimeout(r, 500));
         }
-    });
-}
-function waitForLockerFeeConfirmation(ctx, txHashBytes) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const chain = ctx.universalSigner.account.chain;
-        const { vm, defaultRPC, fastConfirmations, timeout } = chain_1.CHAIN_INFO[chain];
-        // Poll silently — the fee-lock path fires SEND-TX-105-02 as its terminal
-        // confirmation marker; emitting 106-xx here would leak funds-bridge hooks
-        // into a non-funds-bridge path. Uses the same underlying RPC wait as the
-        // funds-bridge confirmation helpers but without the 106-03 / 106-03-02
-        // emissions.
-        switch (vm) {
-            case enums_1.VM.EVM: {
-                const evmClient = (0, context_1.getOriginEvmClient)(ctx);
-                const txHash = (0, viem_1.bytesToHex)(txHashBytes);
-                const receipt = yield waitForEvmReceipt(evmClient, txHash, timeout);
-                if (fastConfirmations <= 1)
-                    return;
-                const targetBlock = receipt.blockNumber + BigInt(fastConfirmations);
-                const start = Date.now();
-                // eslint-disable-next-line no-constant-condition
-                while (true) {
-                    const currentBlock = yield evmClient.publicClient.getBlockNumber();
-                    if (currentBlock >= targetBlock)
-                        return;
-                    if (Date.now() - start > timeout) {
-                        throw new Error(`Timeout: fee-lock tx ${txHash} not confirmed with ${fastConfirmations} confirmations within ${timeout} ms`);
+        case enums_1.VM.SVM: {
+            const rpcUrls = ctx.rpcUrls[chain] || defaultRPC;
+            const svmClient = new svm_client_1.SvmClient({ rpcUrls });
+            const signature = bs58_1.bs58.encode(Buffer.from(txHashBytes));
+            const start = Date.now();
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const connection = svmClient.connections[
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                svmClient.currentConnectionIndex];
+                const { value } = await connection.getSignatureStatuses([signature]);
+                const status = value[0];
+                if (status) {
+                    if (status.err) {
+                        throw new Error(`SVM fee-lock tx ${signature} failed: ${JSON.stringify(status.err)}`);
                     }
-                    yield new Promise((r) => setTimeout(r, 3000));
+                    const isFinalized = status.confirmationStatus === 'finalized' ||
+                        status.confirmations === null;
+                    const hasEnough = status.confirmations != null &&
+                        status.confirmations >= fastConfirmations;
+                    if (isFinalized || hasEnough)
+                        return;
                 }
-            }
-            case enums_1.VM.SVM: {
-                const rpcUrls = ctx.rpcUrls[chain] || defaultRPC;
-                const svmClient = new svm_client_1.SvmClient({ rpcUrls });
-                const signature = bs58_1.bs58.encode(Buffer.from(txHashBytes));
-                const start = Date.now();
-                // eslint-disable-next-line no-constant-condition
-                while (true) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const connection = svmClient.connections[
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    svmClient.currentConnectionIndex];
-                    const { value } = yield connection.getSignatureStatuses([signature]);
-                    const status = value[0];
-                    if (status) {
-                        if (status.err) {
-                            throw new Error(`SVM fee-lock tx ${signature} failed: ${JSON.stringify(status.err)}`);
-                        }
-                        const isFinalized = status.confirmationStatus === 'finalized' ||
-                            status.confirmations === null;
-                        const hasEnough = status.confirmations != null &&
-                            status.confirmations >= fastConfirmations;
-                        if (isFinalized || hasEnough)
-                            return;
-                    }
-                    if (Date.now() - start > timeout) {
-                        throw new Error(`Timeout: fee-lock tx ${signature} not confirmed with ${fastConfirmations} confirmations within ${timeout} ms`);
-                    }
-                    yield new Promise((r) => setTimeout(r, 500));
+                if (Date.now() - start > timeout) {
+                    throw new Error(`Timeout: fee-lock tx ${signature} not confirmed with ${fastConfirmations} confirmations within ${timeout} ms`);
                 }
+                await new Promise((r) => setTimeout(r, 500));
             }
-            default:
-                throw new Error(`Unsupported VM for tx confirmation: ${vm}`);
         }
-    });
+        default:
+            throw new Error(`Unsupported VM for tx confirmation: ${vm}`);
+    }
 }
 //# sourceMappingURL=confirmation.js.map

package/src/lib/orchestrator/internals/error-decoder.js

@@ -117,7 +117,7 @@ function decodeRevert(errorMsg) {
                 }
             }
         }
-        catch (_a) {
+        catch {
             /* fall through to unknown */
         }
     }

package/src/lib/orchestrator/internals/errors.js

@@ -28,9 +28,11 @@ const formatters_1 = require("../../formatters");
  * consumers don't have to parse the message string.
  */
 class PushChainExecutionError extends Error {
+    code = 'PUSH_CHAIN_EXECUTION_FAILED';
+    gatewayTxHash;
+    decodedError;
     constructor(message, opts = {}) {
         super((0, formatters_1.normalizePublicErrorMessage)(message));
-        this.code = 'PUSH_CHAIN_EXECUTION_FAILED';
         this.name = 'PushChainExecutionError';
         this.gatewayTxHash = opts.gatewayTxHash;
         this.decodedError = opts.decodedError;
@@ -44,9 +46,16 @@ exports.PushChainExecutionError = PushChainExecutionError;
  * inside Uniswap with `Error("STF")`.
  */
 class InsufficientUEABalanceError extends PushChainExecutionError {
+    required;
+    available;
+    shortfall;
+    ueaAddress;
+    pathTag;
+    reason;
+    burnToken;
+    segmentIndex;
     constructor(opts) {
-        var _a;
-        const reason = (_a = opts.reason) !== null && _a !== void 0 ? _a : 'NATIVE';
+        const reason = opts.reason ?? 'NATIVE';
         const segLabel = opts.segmentIndex !== undefined ? `:seg${opts.segmentIndex}` : '';
         const tokenSuffix = reason === 'PRC20' && opts.burnToken
             ? ` of token ${opts.burnToken}`

package/src/lib/orchestrator/internals/execute-funds-only.d.ts

@@ -5,7 +5,7 @@
  * for both EVM and SVM origin chains.
  */
 import { ProgressEvent } from '../../progress-hook/progress-hook.types';
-import type { ExecuteParams, UniversalTxResponse } from '../orchestrator.types';
+import type { LegacyExecuteParams, UniversalTxResponse } from '../orchestrator.types';
 import type { OrchestratorContext } from './context';
 import type { ResponseBuilderCallbacks } from './response-builder';
-export declare function executeFundsOnly(ctx: OrchestratorContext, execute: ExecuteParams, eventBuffer: ProgressEvent[], getResponseCallbacks: () => ResponseBuilderCallbacks): Promise<UniversalTxResponse>;
+export declare function executeFundsOnly(ctx: OrchestratorContext, execute: LegacyExecuteParams, eventBuffer: ProgressEvent[], getResponseCallbacks: () => ResponseBuilderCallbacks): Promise<UniversalTxResponse>;