@pushchain/core 6.0.20 → 6.0.21

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

@@ -10,7 +10,6 @@ exports.PushChainExecutionError = void 0;
 exports.sendPushTx = sendPushTx;
 exports.sendUniversalTx = sendUniversalTx;
 exports.extractPcTxAndTransform = extractPcTxAndTransform;
-const tslib_1 = require("tslib");
 const bs58_1 = require("../../internal/bs58");
 const viem_1 = require("viem");
 const chain_1 = require("../../constants/chain");
@@ -25,36 +24,34 @@ const formatters_1 = require("../../formatters");
 const PUSH_TX_INDEX_TIMEOUT_MS = 30000;
 const PUSH_TX_INDEX_POLL_MS = 1000;
 const TX_NOT_INDEXED_RE = /not found|TransactionNotFound|TransactionReceiptNotFound|could not be found|No transaction found/i;
-function getIndexedPushTransaction(ctx, txHash, label) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const startedAt = Date.now();
-        let receiptWaited = false;
-        let retryLogged = false;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            try {
-                if (!receiptWaited) {
-                    yield ctx.pushClient.publicClient.waitForTransactionReceipt({
-                        hash: txHash,
-                    });
-                    receiptWaited = true;
-                }
-                return yield ctx.pushClient.getTransaction(txHash);
+async function getIndexedPushTransaction(ctx, txHash, label) {
+    const startedAt = Date.now();
+    let receiptWaited = false;
+    let retryLogged = false;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            if (!receiptWaited) {
+                await ctx.pushClient.publicClient.waitForTransactionReceipt({
+                    hash: txHash,
+                });
+                receiptWaited = true;
             }
-            catch (err) {
-                const msg = (err === null || err === void 0 ? void 0 : err.shortMessage) || (err === null || err === void 0 ? void 0 : err.message) || String(err);
-                const retryable = TX_NOT_INDEXED_RE.test(msg);
-                if (!retryable || Date.now() - startedAt >= PUSH_TX_INDEX_TIMEOUT_MS) {
-                    throw err;
-                }
-                if (!retryLogged) {
-                    (0, context_1.printLog)(ctx, `${label} — Push tx ${txHash} has a receipt but is not indexed yet; retrying transaction lookup`);
-                    retryLogged = true;
-                }
-                yield new Promise((r) => setTimeout(r, PUSH_TX_INDEX_POLL_MS));
+            return await ctx.pushClient.getTransaction(txHash);
+        }
+        catch (err) {
+            const msg = err?.shortMessage || err?.message || String(err);
+            const retryable = TX_NOT_INDEXED_RE.test(msg);
+            if (!retryable || Date.now() - startedAt >= PUSH_TX_INDEX_TIMEOUT_MS) {
+                throw err;
             }
+            if (!retryLogged) {
+                (0, context_1.printLog)(ctx, `${label} — Push tx ${txHash} has a receipt but is not indexed yet; retrying transaction lookup`);
+                retryLogged = true;
+            }
+            await new Promise((r) => setTimeout(r, PUSH_TX_INDEX_POLL_MS));
         }
-    });
+    }
 }
 // ============================================================================
 // sendPushTx
@@ -66,140 +63,137 @@ function getIndexedPushTransaction(ctx, txHash, label) {
  * For multicall arrays: executes each call as a separate transaction with
  * local nonce management and per-tx receipt confirmation.
  */
-function sendPushTx(ctx, execute, eventBuffer, transformFn) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        if (Array.isArray(execute.data)) {
-            const calls = execute.data;
-            // Reject a zero `to` BEFORE route selection so behaviour is identical
-            // regardless of signer capability: ERC-7821 (the 7702 path) reinterprets
-            // `target == 0` as the account itself, whereas the legacy loop would send to
-            // the zero address. A zero target is almost always a bug — disallow it.
-            if (calls.some((c) => /^0x0{40}$/i.test(c.to))) {
-                throw new errors_1.PushChainExecutionError('A multicall entry has a zero `to` address. Use an explicit target ' +
-                    '(the EIP-7702 executor reinterprets a zero target as the account itself).');
+async function sendPushTx(ctx, execute, eventBuffer, transformFn) {
+    if (Array.isArray(execute.data)) {
+        const calls = execute.data;
+        // Reject a zero `to` BEFORE route selection so behaviour is identical
+        // regardless of signer capability: ERC-7821 (the 7702 path) reinterprets
+        // `target == 0` as the account itself, whereas the legacy loop would send to
+        // the zero address. A zero target is almost always a bug — disallow it.
+        if (calls.some((c) => /^0x0{40}$/i.test(c.to))) {
+            throw new errors_1.PushChainExecutionError('A multicall entry has a zero `to` address. Use an explicit target ' +
+                '(the EIP-7702 executor reinterprets a zero target as the account itself).');
+        }
+        // Preferred path: execute the batch atomically in a single EIP-7702 type-4
+        // transaction. Requires (a) a deployed PushBatchExecutor on this chain and
+        // (b) a wallet that can sign a 7702 authorization. When either is missing we
+        // fall back to the legacy non-atomic per-call loop below.
+        const executor = (0, chain_1.getBatchExecutorAddress)(ctx.universalSigner.account.chain);
+        if (executor && ctx.universalSigner.signAuthorization) {
+            try {
+                (0, context_1.printLog)(ctx, `sendPushTx — executing ${calls.length} call(s) atomically via EIP-7702 (executor: ${executor})`);
+                const txHash = await ctx.pushClient.sendBatch7702({
+                    executor,
+                    calls,
+                    signer: ctx.universalSigner,
+                });
+                const txResponse = await getIndexedPushTransaction(ctx, txHash, 'sendPushTx');
+                return await transformFn(txResponse, eventBuffer);
+            }
+            catch (err) {
+                // Only fall back when the wallet genuinely can't sign a 7702
+                // authorization. This is raised before any broadcast, so falling back
+                // to sequential execution cannot double-execute. Any other error
+                // (e.g. a real revert) must surface.
+                if (!(err instanceof evm_client_1.EIP7702NotSupportedError))
+                    throw err;
+                (0, context_1.printLog)(ctx, `sendPushTx — wallet cannot sign EIP-7702 authorization; falling back to sequential execution`);
+                // eslint-disable-next-line no-console
+                console.warn('[push-chain] Wallet cannot produce an EIP-7702 authorization — batch ' +
+                    'will execute as separate, non-atomic transactions (if one call reverts, ' +
+                    'earlier calls remain committed).');
             }
-            // Preferred path: execute the batch atomically in a single EIP-7702 type-4
-            // transaction. Requires (a) a deployed PushBatchExecutor on this chain and
-            // (b) a wallet that can sign a 7702 authorization. When either is missing we
-            // fall back to the legacy non-atomic per-call loop below.
-            const executor = (0, chain_1.getBatchExecutorAddress)(ctx.universalSigner.account.chain);
-            if (executor && ctx.universalSigner.signAuthorization) {
+        }
+        else if (!ctx.universalSigner.signAuthorization) {
+            // eslint-disable-next-line no-console
+            console.warn('[push-chain] Signer does not support EIP-7702 — batch will execute as ' +
+                'separate, non-atomic transactions (if one call reverts, earlier calls ' +
+                'remain committed).');
+        }
+        const MAX_NONCE_RETRIES = 3;
+        let nonce = await ctx.pushClient.publicClient.getTransactionCount({
+            address: ctx.universalSigner.account.address,
+            blockTag: 'pending',
+        });
+        let lastTxHash = '0x';
+        for (let i = 0; i < calls.length; i++) {
+            const call = calls[i];
+            let txSent = false;
+            for (let retry = 0; retry < MAX_NONCE_RETRIES && !txSent; retry++) {
                 try {
-                    (0, context_1.printLog)(ctx, `sendPushTx — executing ${calls.length} call(s) atomically via EIP-7702 (executor: ${executor})`);
-                    const txHash = yield ctx.pushClient.sendBatch7702({
-                        executor,
-                        calls,
+                    (0, context_1.printLog)(ctx, `sendPushTx — executing multicall operation ${i + 1}/${calls.length} to: ${call.to} (nonce: ${nonce})`);
+                    lastTxHash = await ctx.pushClient.sendTransaction({
+                        to: call.to,
+                        data: (call.data || '0x'),
+                        value: call.value,
                         signer: ctx.universalSigner,
+                        nonce,
                     });
-                    const txResponse = yield getIndexedPushTransaction(ctx, txHash, 'sendPushTx');
-                    return yield transformFn(txResponse, eventBuffer);
+                    txSent = true;
                 }
                 catch (err) {
-                    // Only fall back when the wallet genuinely can't sign a 7702
-                    // authorization. This is raised before any broadcast, so falling back
-                    // to sequential execution cannot double-execute. Any other error
-                    // (e.g. a real revert) must surface.
-                    if (!(err instanceof evm_client_1.EIP7702NotSupportedError))
+                    const msg = err?.message || err?.details || '';
+                    if (msg.includes('invalid nonce') || msg.includes('invalid sequence')) {
+                        (0, context_1.printLog)(ctx, `sendPushTx — nonce mismatch on operation ${i + 1}/${calls.length} (retry ${retry + 1}/${MAX_NONCE_RETRIES}), re-fetching nonce`);
+                        nonce = await ctx.pushClient.publicClient.getTransactionCount({
+                            address: ctx.universalSigner.account.address,
+                            blockTag: 'pending',
+                        });
+                    }
+                    else {
                         throw err;
-                    (0, context_1.printLog)(ctx, `sendPushTx — wallet cannot sign EIP-7702 authorization; falling back to sequential execution`);
-                    // eslint-disable-next-line no-console
-                    console.warn('[push-chain] Wallet cannot produce an EIP-7702 authorization — batch ' +
-                        'will execute as separate, non-atomic transactions (if one call reverts, ' +
-                        'earlier calls remain committed).');
+                    }
                 }
             }
-            else if (!ctx.universalSigner.signAuthorization) {
-                // eslint-disable-next-line no-console
-                console.warn('[push-chain] Signer does not support EIP-7702 — batch will execute as ' +
-                    'separate, non-atomic transactions (if one call reverts, earlier calls ' +
-                    'remain committed).');
+            if (!txSent) {
+                throw new Error(`sendPushTx — multicall operation ${i + 1}/${calls.length} failed after ${MAX_NONCE_RETRIES} nonce retries`);
             }
-            const MAX_NONCE_RETRIES = 3;
-            let nonce = yield ctx.pushClient.publicClient.getTransactionCount({
-                address: ctx.universalSigner.account.address,
-                blockTag: 'pending',
+            const receipt = await ctx.pushClient.publicClient.waitForTransactionReceipt({
+                hash: lastTxHash,
             });
-            let lastTxHash = '0x';
-            for (let i = 0; i < calls.length; i++) {
-                const call = calls[i];
-                let txSent = false;
-                for (let retry = 0; retry < MAX_NONCE_RETRIES && !txSent; retry++) {
-                    try {
-                        (0, context_1.printLog)(ctx, `sendPushTx — executing multicall operation ${i + 1}/${calls.length} to: ${call.to} (nonce: ${nonce})`);
-                        lastTxHash = yield ctx.pushClient.sendTransaction({
-                            to: call.to,
-                            data: (call.data || '0x'),
-                            value: call.value,
-                            signer: ctx.universalSigner,
-                            nonce,
-                        });
-                        txSent = true;
-                    }
-                    catch (err) {
-                        const msg = (err === null || err === void 0 ? void 0 : err.message) || (err === null || err === void 0 ? void 0 : err.details) || '';
-                        if (msg.includes('invalid nonce') || msg.includes('invalid sequence')) {
-                            (0, context_1.printLog)(ctx, `sendPushTx — nonce mismatch on operation ${i + 1}/${calls.length} (retry ${retry + 1}/${MAX_NONCE_RETRIES}), re-fetching nonce`);
-                            nonce = yield ctx.pushClient.publicClient.getTransactionCount({
-                                address: ctx.universalSigner.account.address,
-                                blockTag: 'pending',
-                            });
-                        }
-                        else {
-                            throw err;
-                        }
-                    }
-                }
-                if (!txSent) {
-                    throw new Error(`sendPushTx — multicall operation ${i + 1}/${calls.length} failed after ${MAX_NONCE_RETRIES} nonce retries`);
+            if (receipt.status === 'reverted') {
+                // Simulate the failed call to extract the revert reason
+                let revertReason = 'unknown';
+                try {
+                    await ctx.pushClient.publicClient.call({
+                        to: call.to,
+                        data: (call.data || '0x'),
+                        value: call.value,
+                        account: ctx.universalSigner.account.address,
+                        blockNumber: receipt.blockNumber,
+                    });
                 }
-                const receipt = yield ctx.pushClient.publicClient.waitForTransactionReceipt({
-                    hash: lastTxHash,
-                });
-                if (receipt.status === 'reverted') {
-                    // Simulate the failed call to extract the revert reason
-                    let revertReason = 'unknown';
-                    try {
-                        yield ctx.pushClient.publicClient.call({
-                            to: call.to,
-                            data: (call.data || '0x'),
-                            value: call.value,
-                            account: ctx.universalSigner.account.address,
-                            blockNumber: receipt.blockNumber,
-                        });
+                catch (simErr) {
+                    // viem decodes common revert reasons into shortMessage
+                    revertReason =
+                        simErr?.shortMessage || simErr?.cause?.reason || simErr?.cause?.message || simErr?.message || String(simErr);
+                    // Also log the raw revert data if available
+                    const revertData = simErr?.cause?.data || simErr?.data;
+                    if (revertData) {
+                        revertReason += ` [data: ${revertData}]`;
                     }
-                    catch (simErr) {
-                        // viem decodes common revert reasons into shortMessage
-                        revertReason =
-                            (simErr === null || simErr === void 0 ? void 0 : simErr.shortMessage) || ((_a = simErr === null || simErr === void 0 ? void 0 : simErr.cause) === null || _a === void 0 ? void 0 : _a.reason) || ((_b = simErr === null || simErr === void 0 ? void 0 : simErr.cause) === null || _b === void 0 ? void 0 : _b.message) || (simErr === null || simErr === void 0 ? void 0 : simErr.message) || String(simErr);
-                        // Also log the raw revert data if available
-                        const revertData = ((_c = simErr === null || simErr === void 0 ? void 0 : simErr.cause) === null || _c === void 0 ? void 0 : _c.data) || (simErr === null || simErr === void 0 ? void 0 : simErr.data);
-                        if (revertData) {
-                            revertReason += ` [data: ${revertData}]`;
-                        }
-                    }
-                    (0, context_1.printLog)(ctx, `sendPushTx — multicall operation ${i + 1}/${calls.length} reverted (to: ${call.to}, txHash: ${lastTxHash}, revertReason: ${revertReason})`);
-                    throw new Error(`sendPushTx — multicall operation ${i + 1}/${calls.length} reverted (to: ${call.to}, txHash: ${lastTxHash}, revertReason: ${revertReason})`);
                 }
-                (0, context_1.printLog)(ctx, `sendPushTx — operation ${i + 1}/${calls.length} confirmed in block ${receipt.blockNumber}`);
-                nonce++;
+                (0, context_1.printLog)(ctx, `sendPushTx — multicall operation ${i + 1}/${calls.length} reverted (to: ${call.to}, txHash: ${lastTxHash}, revertReason: ${revertReason})`);
+                throw new Error(`sendPushTx — multicall operation ${i + 1}/${calls.length} reverted (to: ${call.to}, txHash: ${lastTxHash}, revertReason: ${revertReason})`);
             }
-            const txResponse = yield getIndexedPushTransaction(ctx, lastTxHash, 'sendPushTx');
-            // Sequential fallback: each call was a separate tx, so the batch is NOT
-            // atomic (an earlier call can be committed while a later one reverts).
-            const resp = yield transformFn(txResponse, eventBuffer);
-            resp.atomic = false;
-            return resp;
+            (0, context_1.printLog)(ctx, `sendPushTx — operation ${i + 1}/${calls.length} confirmed in block ${receipt.blockNumber}`);
+            nonce++;
         }
-        const txHash = yield ctx.pushClient.sendTransaction({
-            to: execute.to,
-            data: (execute.data || '0x'),
-            value: execute.value,
-            signer: ctx.universalSigner,
-        });
-        const txResponse = yield getIndexedPushTransaction(ctx, txHash, 'sendPushTx');
-        return yield transformFn(txResponse, eventBuffer);
+        const txResponse = await getIndexedPushTransaction(ctx, lastTxHash, 'sendPushTx');
+        // Sequential fallback: each call was a separate tx, so the batch is NOT
+        // atomic (an earlier call can be committed while a later one reverts).
+        const resp = await transformFn(txResponse, eventBuffer);
+        resp.atomic = false;
+        return resp;
+    }
+    const txHash = await ctx.pushClient.sendTransaction({
+        to: execute.to,
+        data: (execute.data || '0x'),
+        value: execute.value,
+        signer: ctx.universalSigner,
     });
+    const txResponse = await getIndexedPushTransaction(ctx, txHash, 'sendPushTx');
+    return await transformFn(txResponse, eventBuffer);
 }
 // ============================================================================
 // sendUniversalTx
@@ -228,139 +222,138 @@ const SEQ_RETRY_BASE_DELAY_MS = 400;
  * `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, resignFn) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e;
-        const { chain, address } = ctx.universalSigner.account;
-        const { vm, chainId } = chain_1.CHAIN_INFO[chain];
-        const universalAccountId = {
-            chainNamespace: chain_1.VM_NAMESPACE[vm],
-            chainId: chainId,
-            owner: vm === enums_1.VM.EVM
-                ? address
-                : vm === enums_1.VM.SVM
-                    ? (0, viem_1.bytesToHex)(new Uint8Array(bs58_1.bs58.decode(address)))
-                    : address,
-        };
-        const { cosmosAddress: signer } = ctx.pushClient.getSignerAddress();
-        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) {
+async function sendUniversalTx(ctx, isUEADeployed, feeLockTxHash, universalPayload, verificationData, eventBuffer, transformFn, resignFn) {
+    const { chain, address } = ctx.universalSigner.account;
+    const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+    const universalAccountId = {
+        chainNamespace: chain_1.VM_NAMESPACE[vm],
+        chainId: chainId,
+        owner: vm === enums_1.VM.EVM
+            ? address
+            : vm === enums_1.VM.SVM
+                ? (0, viem_1.bytesToHex)(new Uint8Array(bs58_1.bs58.decode(address)))
+                : address,
+    };
+    const { cosmosAddress: signer } = ctx.pushClient.getSignerAddress();
+    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 = await ctx.pushClient.createCosmosTxBody(msgs);
+        const txRaw = await ctx.pushClient.signCosmosTx(txBody);
+        try {
+            tx = await ctx.pushClient.broadcastCosmosTx(txRaw);
+        }
+        catch (err) {
+            const msg = 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 in tx.rawLog (retry ${seqRetryCount}/${MAX_SEQ_RETRIES}), sleeping ${delay}ms: ${tx.rawLog}`);
-                yield new Promise((r) => setTimeout(r, delay));
+                (0, context_1.printLog)(ctx, `sendUniversalTx — Cosmos sequence mismatch on broadcast (retry ${seqRetryCount}/${MAX_SEQ_RETRIES}), sleeping ${delay}ms: ${msg}`);
+                await 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);
-            })) !== null && _b !== void 0 ? _b : [];
-            // Decode known revert selectors (e.g. `ret 0xacfdb444`) from the cosmos
-            // rawLog so the consumer-facing error AND the diagnostic failureSummary
-            // log carry an actionable hint instead of raw 4-byte hex. Mirrors the
-            // wiring in `extractPcTxAndTransform` for the post-success `pcTx FAILED`
-            // path. Also feeds the structured `decodedError` payload through to the
-            // terminal hook (199-02 / 299-02 / 399-02 / 999-02).
-            const rawMessage = (_c = tx.rawLog) !== null && _c !== void 0 ? _c : '';
-            let publicMessage = (0, formatters_1.normalizePublicErrorMessage)(rawMessage);
-            let decodedForPayload;
-            const decoded = (0, error_decoder_1.decodeRevert)(rawMessage);
-            if ((decoded === null || decoded === void 0 ? void 0 : decoded.kind) === 'custom') {
-                publicMessage = (0, error_decoder_1.formatDecodedRevertForUser)(decoded);
-                decodedForPayload = {
-                    name: decoded.name,
-                    hint: decoded.hint,
-                    selector: decoded.selector,
-                };
-            }
-            else if ((decoded === null || decoded === void 0 ? void 0 : decoded.kind) === 'string') {
-                publicMessage = (0, error_decoder_1.formatDecodedRevertForUser)(decoded);
-                decodedForPayload = {
-                    decoded: decoded.decoded,
-                    selector: decoded.selector,
-                };
-            }
-            else if ((decoded === null || decoded === void 0 ? void 0 : decoded.kind) === 'unknown') {
-                (0, context_1.printLog)(ctx, `[error-decoder] unknown selector ${decoded.selector} — consider adding to KNOWN_ERROR_SELECTORS`);
-            }
-            const failureSummary = [
-                `PUSH CHAIN TRANSACTION FAILED`,
-                `Cosmos TX Hash: ${tx.transactionHash}`,
-                `Block Height: ${tx.height}, TX Code: ${tx.code} (error)`,
-                `Gas Used: ${tx.gasUsed}, Gas Wanted: ${tx.gasWanted}`,
-                ...(failedEthTxHashes.length > 0 ? [`Ethereum TX Hash(es): ${failedEthTxHashes.join(', ')}`] : []),
-                `Error: ${publicMessage}`,
-            ].join(' | ');
-            (0, context_1.printLog)(ctx, failureSummary);
-            // Throw a typed error so the orchestrator's outer catch can lift the
-            // structured `decodedError` straight onto the terminal-hook payload.
-            throw new errors_1.PushChainExecutionError(publicMessage, {
-                decodedError: decodedForPayload,
-            });
+            throw err;
         }
-        if (!tx || tx.code !== 0) {
-            throw new Error(`sendUniversalTx — unreachable: loop exited without success or throw`);
+        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}`);
+            await new Promise((r) => setTimeout(r, delay));
+            attempt--; // don't consume EVM-signature retry budget
+            continue;
         }
-        const ethTxHashes = (_e = (_d = tx.events) === null || _d === void 0 ? void 0 : _d.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);
-        })) !== null && _e !== void 0 ? _e : [];
-        if (ethTxHashes.length === 0) {
-            throw new Error('No ethereumTxHash found in transaction events');
+        // 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 = await resignFn();
+            currentPayload = fresh.universalPayload;
+            currentVerificationData = fresh.verificationData;
+            continue;
         }
-        const evmTxs = yield Promise.all(ethTxHashes.map((hash) => tslib_1.__awaiter(this, void 0, void 0, function* () { return getIndexedPushTransaction(ctx, hash, 'sendUniversalTx'); })));
-        const responses = yield Promise.all(evmTxs.map((tx, index) => transformFn(tx, index === evmTxs.length - 1 ? eventBuffer : [])));
-        return responses;
-    });
+        // Terminal failure
+        const failedEthTxHashes = tx.events
+            ?.filter((e) => e.type === 'ethereum_tx')
+            .flatMap((e) => e.attributes
+            ?.filter((attr) => attr.key === 'ethereumTxHash')
+            .map((attr) => attr.value)) ?? [];
+        // Decode known revert selectors (e.g. `ret 0xacfdb444`) from the cosmos
+        // rawLog so the consumer-facing error AND the diagnostic failureSummary
+        // log carry an actionable hint instead of raw 4-byte hex. Mirrors the
+        // wiring in `extractPcTxAndTransform` for the post-success `pcTx FAILED`
+        // path. Also feeds the structured `decodedError` payload through to the
+        // terminal hook (199-02 / 299-02 / 399-02 / 999-02).
+        const rawMessage = tx.rawLog ?? '';
+        let publicMessage = (0, formatters_1.normalizePublicErrorMessage)(rawMessage);
+        let decodedForPayload;
+        const decoded = (0, error_decoder_1.decodeRevert)(rawMessage);
+        if (decoded?.kind === 'custom') {
+            publicMessage = (0, error_decoder_1.formatDecodedRevertForUser)(decoded);
+            decodedForPayload = {
+                name: decoded.name,
+                hint: decoded.hint,
+                selector: decoded.selector,
+            };
+        }
+        else if (decoded?.kind === 'string') {
+            publicMessage = (0, error_decoder_1.formatDecodedRevertForUser)(decoded);
+            decodedForPayload = {
+                decoded: decoded.decoded,
+                selector: decoded.selector,
+            };
+        }
+        else if (decoded?.kind === 'unknown') {
+            (0, context_1.printLog)(ctx, `[error-decoder] unknown selector ${decoded.selector} — consider adding to KNOWN_ERROR_SELECTORS`);
+        }
+        const failureSummary = [
+            `PUSH CHAIN TRANSACTION FAILED`,
+            `Cosmos TX Hash: ${tx.transactionHash}`,
+            `Block Height: ${tx.height}, TX Code: ${tx.code} (error)`,
+            `Gas Used: ${tx.gasUsed}, Gas Wanted: ${tx.gasWanted}`,
+            ...(failedEthTxHashes.length > 0 ? [`Ethereum TX Hash(es): ${failedEthTxHashes.join(', ')}`] : []),
+            `Error: ${publicMessage}`,
+        ].join(' | ');
+        (0, context_1.printLog)(ctx, failureSummary);
+        // Throw a typed error so the orchestrator's outer catch can lift the
+        // structured `decodedError` straight onto the terminal-hook payload.
+        throw new errors_1.PushChainExecutionError(publicMessage, {
+            decodedError: decodedForPayload,
+        });
+    }
+    if (!tx || tx.code !== 0) {
+        throw new Error(`sendUniversalTx — unreachable: loop exited without success or throw`);
+    }
+    const ethTxHashes = tx.events
+        ?.filter((e) => e.type === 'ethereum_tx')
+        .flatMap((e) => e.attributes
+        ?.filter((attr) => attr.key === 'ethereumTxHash')
+        .map((attr) => attr.value)) ?? [];
+    if (ethTxHashes.length === 0) {
+        throw new Error('No ethereumTxHash found in transaction events');
+    }
+    const evmTxs = await Promise.all(ethTxHashes.map(async (hash) => getIndexedPushTransaction(ctx, hash, 'sendUniversalTx')));
+    const responses = await Promise.all(evmTxs.map((tx, index) => transformFn(tx, index === evmTxs.length - 1 ? eventBuffer : [])));
+    return responses;
 }
 // ============================================================================
 // extractPcTxAndTransform
@@ -369,66 +362,63 @@ function sendUniversalTx(ctx, isUEADeployed, feeLockTxHash, universalPayload, ve
  * Validates Push Chain tx response, extracts last pcTx, fetches EVM tx,
  * and transforms to UniversalTxResponse.
  */
-function extractPcTxAndTransform(ctx, pushChainUniversalTx, gatewayTxHash, eventBuffer, label, transformFn) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        if (!((_a = pushChainUniversalTx === null || pushChainUniversalTx === void 0 ? void 0 : pushChainUniversalTx.pcTx) === null || _a === void 0 ? void 0 : _a.length)) {
-            throw new Error(`Failed to retrieve Push Chain transaction status for gateway tx: ${gatewayTxHash}. ` +
-                `The transaction may have failed on Push Chain or not been indexed yet.`);
+async function extractPcTxAndTransform(ctx, pushChainUniversalTx, gatewayTxHash, eventBuffer, label, transformFn) {
+    if (!pushChainUniversalTx?.pcTx?.length) {
+        throw new Error(`Failed to retrieve Push Chain transaction status for gateway tx: ${gatewayTxHash}. ` +
+            `The transaction may have failed on Push Chain or not been indexed yet.`);
+    }
+    const lastPcTransaction = pushChainUniversalTx.pcTx.at(-1);
+    (0, context_1.printLog)(ctx, `${label} — pcTx: ` + JSON.stringify(pushChainUniversalTx.pcTx.map((p) => ({ txHash: p.txHash, status: p.status, errorMsg: p.errorMsg })), null, 2));
+    (0, context_1.printLog)(ctx, `${label} — using lastPcTransaction: ` + JSON.stringify(lastPcTransaction, null, 2));
+    if (!lastPcTransaction?.txHash || lastPcTransaction.status === 'FAILED') {
+        const failedPcTx = lastPcTransaction?.status === 'FAILED'
+            ? lastPcTransaction
+            : pushChainUniversalTx.pcTx.find((pcTx) => pcTx.status === 'FAILED' && pcTx.errorMsg);
+        const rawFailedPcTxErrorMsg = failedPcTx?.errorMsg ?? '';
+        let failedPcTxErrorMsg = rawFailedPcTxErrorMsg
+            ? (0, formatters_1.normalizePublicErrorMessage)(rawFailedPcTxErrorMsg)
+            : '';
+        const errorDetails = failedPcTxErrorMsg ? `: ${failedPcTxErrorMsg}` : '';
+        // Decode known revert selectors and ABI-encoded `Error(string)` reverts
+        // into actionable hints. Unknown selectors are logged at INFO so the
+        // table can grow from real reverts.
+        let hint = '';
+        let decodedForPayload;
+        const decoded = (0, error_decoder_1.decodeRevert)(rawFailedPcTxErrorMsg);
+        if (decoded?.kind === 'custom') {
+            failedPcTxErrorMsg = (0, error_decoder_1.formatDecodedRevertForUser)(decoded);
+            hint = '';
+            decodedForPayload = {
+                name: decoded.name,
+                hint: decoded.hint,
+                selector: decoded.selector,
+            };
         }
-        const lastPcTransaction = pushChainUniversalTx.pcTx.at(-1);
-        (0, context_1.printLog)(ctx, `${label} — pcTx: ` + JSON.stringify(pushChainUniversalTx.pcTx.map((p) => ({ txHash: p.txHash, status: p.status, errorMsg: p.errorMsg })), null, 2));
-        (0, context_1.printLog)(ctx, `${label} — using lastPcTransaction: ` + JSON.stringify(lastPcTransaction, null, 2));
-        if (!(lastPcTransaction === null || lastPcTransaction === void 0 ? void 0 : lastPcTransaction.txHash) || lastPcTransaction.status === 'FAILED') {
-            const failedPcTx = (lastPcTransaction === null || lastPcTransaction === void 0 ? void 0 : lastPcTransaction.status) === 'FAILED'
-                ? lastPcTransaction
-                : pushChainUniversalTx.pcTx.find((pcTx) => pcTx.status === 'FAILED' && pcTx.errorMsg);
-            const rawFailedPcTxErrorMsg = (_b = failedPcTx === null || failedPcTx === void 0 ? void 0 : failedPcTx.errorMsg) !== null && _b !== void 0 ? _b : '';
-            let failedPcTxErrorMsg = rawFailedPcTxErrorMsg
-                ? (0, formatters_1.normalizePublicErrorMessage)(rawFailedPcTxErrorMsg)
-                : '';
-            const errorDetails = failedPcTxErrorMsg ? `: ${failedPcTxErrorMsg}` : '';
-            // Decode known revert selectors and ABI-encoded `Error(string)` reverts
-            // into actionable hints. Unknown selectors are logged at INFO so the
-            // table can grow from real reverts.
-            let hint = '';
-            let decodedForPayload;
-            const decoded = (0, error_decoder_1.decodeRevert)(rawFailedPcTxErrorMsg);
-            if ((decoded === null || decoded === void 0 ? void 0 : decoded.kind) === 'custom') {
-                failedPcTxErrorMsg = (0, error_decoder_1.formatDecodedRevertForUser)(decoded);
-                hint = '';
-                decodedForPayload = {
-                    name: decoded.name,
-                    hint: decoded.hint,
-                    selector: decoded.selector,
-                };
-            }
-            else if ((decoded === null || decoded === void 0 ? void 0 : decoded.kind) === 'string') {
-                failedPcTxErrorMsg = (0, error_decoder_1.formatDecodedRevertForUser)(decoded);
-                hint = '';
-                decodedForPayload = {
-                    decoded: decoded.decoded,
-                    selector: decoded.selector,
-                };
-            }
-            else if ((decoded === null || decoded === void 0 ? void 0 : decoded.kind) === 'unknown') {
-                (0, context_1.printLog)(ctx, `[error-decoder] unknown selector ${decoded.selector} — consider adding to KNOWN_ERROR_SELECTORS`);
-            }
-            const decodedErrorDetails = failedPcTxErrorMsg
-                ? `: ${failedPcTxErrorMsg}`
-                : errorDetails;
-            const fullMessage = `Push Chain transaction failed for gateway tx: ${gatewayTxHash}${decodedErrorDetails}${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, decodedForPayload, failedPcTx === null || failedPcTx === void 0 ? void 0 : failedPcTx.txHash);
-            throw new errors_1.PushChainExecutionError(fullMessage, {
-                gatewayTxHash,
-                decodedError: decodedForPayload,
-            });
+        else if (decoded?.kind === 'string') {
+            failedPcTxErrorMsg = (0, error_decoder_1.formatDecodedRevertForUser)(decoded);
+            hint = '';
+            decodedForPayload = {
+                decoded: decoded.decoded,
+                selector: decoded.selector,
+            };
         }
-        const tx = yield getIndexedPushTransaction(ctx, lastPcTransaction.txHash, label);
-        return transformFn(tx, eventBuffer);
-    });
+        else if (decoded?.kind === 'unknown') {
+            (0, context_1.printLog)(ctx, `[error-decoder] unknown selector ${decoded.selector} — consider adding to KNOWN_ERROR_SELECTORS`);
+        }
+        const decodedErrorDetails = failedPcTxErrorMsg
+            ? `: ${failedPcTxErrorMsg}`
+            : errorDetails;
+        const fullMessage = `Push Chain transaction failed for gateway tx: ${gatewayTxHash}${decodedErrorDetails}${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, decodedForPayload, failedPcTx?.txHash);
+        throw new errors_1.PushChainExecutionError(fullMessage, {
+            gatewayTxHash,
+            decodedError: decodedForPayload,
+        });
+    }
+    const tx = await getIndexedPushTransaction(ctx, lastPcTransaction.txHash, label);
+    return transformFn(tx, eventBuffer);
 }
 //# sourceMappingURL=push-chain-tx.js.map