@pushchain/core 5.1.5-alpha.1 → 5.1.5

package/src/lib/orchestrator/internals/push-chain-tx.d.ts

@@ -10,6 +10,23 @@ import { UniversalPayload } from '../../generated/v1/tx';
 import type { TxResponse } from '../../vm-client/vm-client.types';
 import type { ExecuteParams, UniversalTxResponse } from '../orchestrator.types';
 import type { OrchestratorContext } from './context';
+/**
+ * Typed error for Route 1 Push Chain tx failures. Thrown by
+ * `extractPcTxAndTransform` when the final pcTx commits with `status === 'FAILED'`,
+ * and surfaced as `SEND_TX_199_02` on the live stream. The readonly `code`
+ * discriminator lets callers classify via `instanceof PushChainExecutionError`
+ * instead of sniffing error messages.
+ *
+ * Carries the origin-chain gateway tx hash. There is no successful Push Chain
+ * tx to reference on this path — by definition the pcTx committed `FAILED`.
+ */
+export declare class PushChainExecutionError extends Error {
+    readonly code: "PUSH_CHAIN_EXECUTION_FAILED";
+    readonly gatewayTxHash?: string;
+    constructor(message: string, opts?: {
+        gatewayTxHash?: string;
+    });
+}
 type TransformToResponseFn = (tx: TxResponse, eventBuffer: ProgressEvent[]) => Promise<UniversalTxResponse>;
 /**
  * Sends an EVM transaction directly on Push Chain.
@@ -19,11 +36,20 @@ type TransformToResponseFn = (tx: TxResponse, eventBuffer: ProgressEvent[]) => P
  * local nonce management and per-tx receipt confirmation.
  */
 export declare function sendPushTx(ctx: OrchestratorContext, execute: ExecuteParams, eventBuffer: ProgressEvent[], transformFn: TransformToResponseFn): Promise<UniversalTxResponse>;
+export type ResignUniversalPayloadFn = () => Promise<{
+    universalPayload: UniversalPayload;
+    verificationData: `0x${string}`;
+}>;
 /**
  * Sends a Cosmos tx to Push Chain (gasless) to execute user intent.
  * Wraps the EVM payload in a MsgExecutePayload Cosmos message.
+ *
+ * `resignFn` (optional): if provided, `sendUniversalTx` retries up to
+ * `MAX_SIG_RETRIES` times when the Cosmos revert carries the
+ * `InvalidEVMSignature()` selector. Each retry calls `resignFn` to obtain
+ * a payload re-signed against the UEA's current on-chain nonce.
  */
-export declare function sendUniversalTx(ctx: OrchestratorContext, isUEADeployed: boolean, feeLockTxHash: string | undefined, universalPayload: UniversalPayload | undefined, verificationData: `0x${string}` | undefined, eventBuffer: ProgressEvent[], transformFn: TransformToResponseFn): Promise<UniversalTxResponse[]>;
+export declare function sendUniversalTx(ctx: OrchestratorContext, isUEADeployed: boolean, feeLockTxHash: string | undefined, universalPayload: UniversalPayload | undefined, verificationData: `0x${string}` | undefined, eventBuffer: ProgressEvent[], transformFn: TransformToResponseFn, resignFn?: ResignUniversalPayloadFn): Promise<UniversalTxResponse[]>;
 /**
  * Validates Push Chain tx response, extracts last pcTx, fetches EVM tx,
  * and transforms to UniversalTxResponse.

package/src/lib/orchestrator/internals/push-chain-tx.js

@@ -6,6 +6,7 @@
  * sendUniversalTx:  Cosmos-wrapped EVM tx via PushClient (gasless path)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushChainExecutionError = void 0;
 exports.sendPushTx = sendPushTx;
 exports.sendUniversalTx = sendUniversalTx;
 exports.extractPcTxAndTransform = extractPcTxAndTransform;
@@ -14,8 +15,31 @@ const bs58_1 = require("../../internal/bs58");
 const viem_1 = require("viem");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
+const progress_hook_types_1 = require("../../progress-hook/progress-hook.types");
 const context_1 = require("./context");
 // ============================================================================
+// PushChainExecutionError
+// ============================================================================
+/**
+ * Typed error for Route 1 Push Chain tx failures. Thrown by
+ * `extractPcTxAndTransform` when the final pcTx commits with `status === 'FAILED'`,
+ * and surfaced as `SEND_TX_199_02` on the live stream. The readonly `code`
+ * discriminator lets callers classify via `instanceof PushChainExecutionError`
+ * instead of sniffing error messages.
+ *
+ * Carries the origin-chain gateway tx hash. There is no successful Push Chain
+ * tx to reference on this path — by definition the pcTx committed `FAILED`.
+ */
+class PushChainExecutionError extends Error {
+    constructor(message, opts = {}) {
+        super(message);
+        this.code = 'PUSH_CHAIN_EXECUTION_FAILED';
+        this.name = 'PushChainExecutionError';
+        this.gatewayTxHash = opts.gatewayTxHash;
+    }
+}
+exports.PushChainExecutionError = PushChainExecutionError;
+// ============================================================================
 // sendPushTx
 // ============================================================================
 /**
@@ -117,11 +141,31 @@ function sendPushTx(ctx, execute, eventBuffer, transformFn) {
 // ============================================================================
 // sendUniversalTx
 // ============================================================================
+/**
+ * UEAErrors.InvalidEVMSignature() selector. Thrown by UEA_EVM.executeUniversalTx
+ * when the recovered EIP-712 signer doesn't match the UEA owner — typically
+ * because UEA storage `nonce` advanced between getUEANonce() and Cosmos
+ * inclusion. The retry hook re-fetches nonce, re-signs, and re-broadcasts.
+ */
+const INVALID_EVM_SIGNATURE_SELECTOR = '0xc7dbd31d';
+const MAX_SIG_RETRIES = 2;
+// Cosmos-layer sequence race: two broadcasts sign with the same account
+// sequence before either lands; the node rejects the loser with
+// "account sequence mismatch". Re-signing pulls a fresh sequence (signCosmosTx
+// re-fetches it per call), so a simple loop-back is sufficient.
+const COSMOS_SEQUENCE_MISMATCH_RE = /account sequence mismatch|incorrect account sequence/i;
+const MAX_SEQ_RETRIES = 3;
+const SEQ_RETRY_BASE_DELAY_MS = 400;
 /**
  * Sends a Cosmos tx to Push Chain (gasless) to execute user intent.
  * Wraps the EVM payload in a MsgExecutePayload Cosmos message.
+ *
+ * `resignFn` (optional): if provided, `sendUniversalTx` retries up to
+ * `MAX_SIG_RETRIES` times when the Cosmos revert carries the
+ * `InvalidEVMSignature()` selector. Each retry calls `resignFn` to obtain
+ * a payload re-signed against the UEA's current on-chain nonce.
  */
-function sendUniversalTx(ctx, isUEADeployed, feeLockTxHash, universalPayload, verificationData, eventBuffer, transformFn) {
+function sendUniversalTx(ctx, isUEADeployed, feeLockTxHash, universalPayload, verificationData, eventBuffer, transformFn, resignFn) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d;
         const { chain, address } = ctx.universalSigner.account;
@@ -136,19 +180,63 @@ function sendUniversalTx(ctx, isUEADeployed, feeLockTxHash, universalPayload, ve
                     : address,
         };
         const { cosmosAddress: signer } = ctx.pushClient.getSignerAddress();
-        const msgs = [];
-        if (universalPayload && verificationData) {
-            msgs.push(ctx.pushClient.createMsgExecutePayload({
-                signer,
-                universalAccountId,
-                universalPayload,
-                verificationData,
-            }));
-        }
-        const txBody = yield ctx.pushClient.createCosmosTxBody(msgs);
-        const txRaw = yield ctx.pushClient.signCosmosTx(txBody);
-        const tx = yield ctx.pushClient.broadcastCosmosTx(txRaw);
-        if (tx.code !== 0) {
+        let currentPayload = universalPayload;
+        let currentVerificationData = verificationData;
+        let tx;
+        let seqRetryCount = 0;
+        for (let attempt = 0; attempt <= MAX_SIG_RETRIES; attempt++) {
+            const msgs = [];
+            if (currentPayload && currentVerificationData) {
+                msgs.push(ctx.pushClient.createMsgExecutePayload({
+                    signer,
+                    universalAccountId,
+                    universalPayload: currentPayload,
+                    verificationData: currentVerificationData,
+                }));
+            }
+            const txBody = yield ctx.pushClient.createCosmosTxBody(msgs);
+            const txRaw = yield ctx.pushClient.signCosmosTx(txBody);
+            try {
+                tx = yield ctx.pushClient.broadcastCosmosTx(txRaw);
+            }
+            catch (err) {
+                const msg = (err === null || err === void 0 ? void 0 : err.message) || String(err);
+                if (COSMOS_SEQUENCE_MISMATCH_RE.test(msg) &&
+                    seqRetryCount < MAX_SEQ_RETRIES) {
+                    seqRetryCount++;
+                    const delay = Math.round(SEQ_RETRY_BASE_DELAY_MS * seqRetryCount * (1 + Math.random() * 0.2));
+                    (0, context_1.printLog)(ctx, `sendUniversalTx — Cosmos sequence mismatch on broadcast (retry ${seqRetryCount}/${MAX_SEQ_RETRIES}), sleeping ${delay}ms: ${msg}`);
+                    yield new Promise((r) => setTimeout(r, delay));
+                    attempt--; // don't consume EVM-signature retry budget
+                    continue;
+                }
+                throw err;
+            }
+            if (tx.code === 0)
+                break;
+            // Cosmos sequence race: returned via tx.rawLog rather than thrown
+            const isSeqMismatch = typeof tx.rawLog === 'string' &&
+                COSMOS_SEQUENCE_MISMATCH_RE.test(tx.rawLog);
+            if (isSeqMismatch && seqRetryCount < MAX_SEQ_RETRIES) {
+                seqRetryCount++;
+                const delay = Math.round(SEQ_RETRY_BASE_DELAY_MS * seqRetryCount * (1 + Math.random() * 0.2));
+                (0, context_1.printLog)(ctx, `sendUniversalTx — Cosmos sequence mismatch in tx.rawLog (retry ${seqRetryCount}/${MAX_SEQ_RETRIES}), sleeping ${delay}ms: ${tx.rawLog}`);
+                yield new Promise((r) => setTimeout(r, delay));
+                attempt--; // don't consume EVM-signature retry budget
+                continue;
+            }
+            // Nonce-race retry: UEA storage nonce advanced between our read and
+            // tx inclusion. Re-sign with the fresh nonce and rebroadcast.
+            const isSigMismatch = typeof tx.rawLog === 'string' &&
+                tx.rawLog.includes(INVALID_EVM_SIGNATURE_SELECTOR);
+            if (attempt < MAX_SIG_RETRIES && isSigMismatch && resignFn) {
+                (0, context_1.printLog)(ctx, `sendUniversalTx — InvalidEVMSignature on attempt ${attempt + 1} (${tx.rawLog}); re-signing with fresh UEA nonce (retry ${attempt + 1}/${MAX_SIG_RETRIES})`);
+                const fresh = yield resignFn();
+                currentPayload = fresh.universalPayload;
+                currentVerificationData = fresh.verificationData;
+                continue;
+            }
+            // Terminal failure
             const failedEthTxHashes = (_b = (_a = tx.events) === null || _a === void 0 ? void 0 : _a.filter((e) => e.type === 'ethereum_tx').flatMap((e) => {
                 var _a;
                 return (_a = e.attributes) === null || _a === void 0 ? void 0 : _a.filter((attr) => attr.key === 'ethereumTxHash').map((attr) => attr.value);
@@ -164,6 +252,9 @@ function sendUniversalTx(ctx, isUEADeployed, feeLockTxHash, universalPayload, ve
             (0, context_1.printLog)(ctx, failureSummary);
             throw new Error(tx.rawLog);
         }
+        if (!tx || tx.code !== 0) {
+            throw new Error(`sendUniversalTx — unreachable: loop exited without success or throw`);
+        }
         const ethTxHashes = (_d = (_c = tx.events) === null || _c === void 0 ? void 0 : _c.filter((e) => e.type === 'ethereum_tx').flatMap((e) => {
             var _a;
             return (_a = e.attributes) === null || _a === void 0 ? void 0 : _a.filter((attr) => attr.key === 'ethereumTxHash').map((attr) => attr.value);
@@ -212,7 +303,12 @@ function extractPcTxAndTransform(ctx, pushChainUniversalTx, gatewayTxHash, event
                     hint = ' [ExpiredDeadline: the transaction deadline has passed.]';
                 }
             }
-            throw new Error(`Push Chain transaction failed for gateway tx: ${gatewayTxHash}${errorDetails}${hint}`);
+            const fullMessage = `Push Chain transaction failed for gateway tx: ${gatewayTxHash}${errorDetails}${hint}`;
+            // Live-emit 199-02 before throwing so the terminal failure hook reaches
+            // any caller-registered progress stream (parity with reconstructProgressEvents
+            // which emits 199-02 on replay).
+            (0, context_1.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_02, fullMessage);
+            throw new PushChainExecutionError(fullMessage, { gatewayTxHash });
         }
         const tx = yield ctx.pushClient.getTransaction(lastPcTransaction.txHash);
         return transformFn(tx, eventBuffer);

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

@@ -55,7 +55,7 @@ function rescueFunds(ctx, params, executeFn) {
         // Query rescue gas fee
         let nativeValueForGas = BigInt(0);
         try {
-            const result = yield (0, gas_calculator_1.queryRescueGasFee)(ctx, params.prc20);
+            const result = yield (0, gas_calculator_1.queryRescueGasFee)(ctx, params.prc20, ctx.universalSigner.account.chain);
             nativeValueForGas = result.nativeValueForGas;
             (0, context_1.printLog)(ctx, `rescueFunds — queried gas fee: gasFee=${result.gasFee.toString()}, gasToken=${result.gasToken}, nativeValueForGas=${nativeValueForGas.toString()}`);
         }

package/src/lib/orchestrator/internals/response-builder.d.ts

@@ -20,6 +20,11 @@ export interface ResponseBuilderCallbacks {
         pollingIntervalMs: number;
         maxTimeoutMs: number;
     };
+    inboundConstants: {
+        initialWaitMs: number;
+        pollingIntervalMs: number;
+        maxTimeoutMs: number;
+    };
 }
 export declare function queryUniversalTxStatusFromGatewayTx(ctx: OrchestratorContext, evmClient: EvmClient | undefined, gatewayAddress: `0x${string}` | undefined, txHash: string, evmGatewayMethod: 'sendFunds' | 'sendTxWithFunds' | 'sendTxWithGas'): Promise<UniversalTx | undefined>;
 export declare function trackTransaction(ctx: OrchestratorContext, txHash: string, options?: TrackTransactionOptions, callbacks?: ResponseBuilderCallbacks): Promise<UniversalTxResponse>;