@pushchain/core 6.0.17 → 6.0.19

package/src/lib/orchestrator/orchestrator.js

@@ -6,6 +6,7 @@ const chain_1 = require("../constants/chain");
 const enums_1 = require("../constants/enums");
 const progress_hook_types_1 = require("../progress-hook/progress-hook.types");
 const push_client_1 = require("../push-client/push-client");
+const formatters_1 = require("../formatters");
 const route_detector_1 = require("./route-detector");
 const data_utils_1 = require("./data-utils");
 const internals_1 = require("./internals");
@@ -216,11 +217,7 @@ class Orchestrator {
                         // 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 = err instanceof Error
-                                ? err.message
-                                : typeof err === 'string'
-                                    ? err
-                                    : 'Unknown error';
+                            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
@@ -261,18 +258,7 @@ class Orchestrator {
                     return attachPerCallHookForWait(yield (0, internals_1.executeStandardPayload)(this.ctx, execute, eventBuffer, rcb));
                 }
                 catch (err) {
-                    const errMessage = err instanceof Error
-                        ? err.message
-                        : typeof err === 'string'
-                            ? err
-                            : (() => {
-                                try {
-                                    return JSON.stringify(err);
-                                }
-                                catch (_a) {
-                                    return 'Unknown error';
-                                }
-                            })();
+                    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.

package/src/lib/orchestrator/orchestrator.types.d.ts

@@ -225,6 +225,13 @@ export interface UniversalTxResponse {
     _setProgressHookNoReplay?: (callback: (event: import('../progress-hook/progress-hook.types').ProgressEvent) => void) => void;
     type: string;
     typeVerbose: string;
+    /**
+     * Whether the transaction executed atomically (all-or-nothing).
+     * `true` for a single tx, an EIP-7702 batch, or a UEA `UEA_MULTICALL` batch;
+     * `false` only when a multicall fell back to the non-atomic sequential loop
+     * (separate per-call txs — an earlier call can commit while a later one reverts).
+     */
+    atomic: boolean;
     signature: Signature;
     raw?: {
         from: string;

package/src/lib/progress-hook/progress-hook.js

@@ -203,25 +203,25 @@ const RAW_HOOKS_R1 = {
         },
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03]: (required) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03]: (required, txHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03,
         title: 'Awaiting Confirmations',
         message: `Waiting for ${required} confirmations`,
-        response: { current: 0, required },
+        response: Object.assign({ current: 0, required }, (txHash ? { txHash } : {})),
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_01]: (current, required) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_01]: (current, required, txHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_01,
         title: `Confirmation ${current}/${required} Received`,
         message: `${current}/${required} confirmations received`,
-        response: { current, required },
+        response: Object.assign({ current, required }, (txHash ? { txHash } : {})),
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02]: (current, required) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02]: (current, required, txHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_03_02,
         title: `Confirmation ${current}/${required} Received`,
         message: `${current}/${required} confirmations received`,
-        response: { current, required },
+        response: Object.assign({ current, required }, (txHash ? { txHash } : {})),
         level: 'SUCCESS',
     }),
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_106_04]: (txHash) => ({
@@ -264,13 +264,13 @@ const RAW_HOOKS_R1 = {
             level: 'SUCCESS',
         };
     },
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_02]: (errMessage, decodedError) => {
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_02]: (errMessage, decodedError, txHash) => {
         const normalizedErrMessage = (0, formatters_1.normalizePcInsufficientFundsError)(errMessage);
         return {
             id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_199_02,
             title: 'Push Chain Tx Failed',
             message: normalizedErrMessage,
-            response: Object.assign({ error: normalizedErrMessage }, (decodedError ? { decodedError } : {})),
+            response: Object.assign(Object.assign({ error: normalizedErrMessage }, (txHash ? { txHash } : {})), (decodedError ? { decodedError } : {})),
             level: 'ERROR',
         };
     },
@@ -435,18 +435,18 @@ const RAW_HOOKS_R2 = {
         response: { chain: targetChain },
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_209_01]: (targetChain) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_209_01]: (targetChain, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_209_01,
         title: 'Awaiting Push Chain Relay',
         message: `Waiting for UGPC to relay execution to ${targetChain}`,
-        response: { chain: targetChain },
+        response: Object.assign({ chain: targetChain }, (pushTxHash ? { pushTxHash } : {})),
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_209_02]: (targetChain, elapsedMs) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_209_02]: (targetChain, elapsedMs, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_209_02,
         title: `Syncing State with ${friendlyChain(targetChain)}`,
         message: `Polling ${targetChain} for CEA execution`,
-        response: { chain: targetChain, elapsedMs },
+        response: Object.assign({ chain: targetChain, elapsedMs }, (pushTxHash ? { pushTxHash } : {})),
         level: 'INFO',
     }),
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_01]: (details) => ({
@@ -456,18 +456,18 @@ const RAW_HOOKS_R2 = {
         response: Object.assign({ txHash: details.externalTxHash }, details),
         level: 'SUCCESS',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_02]: (targetChain, errorMessage, decodedError) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_02]: (targetChain, errorMessage, decodedError, pushTxHash, txHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_02,
         title: `${friendlyChain(targetChain)} Tx Failed`,
         message: errorMessage,
-        response: Object.assign({ error: errorMessage, chain: targetChain }, (decodedError ? { decodedError } : {})),
+        response: Object.assign(Object.assign(Object.assign({ error: errorMessage, chain: targetChain }, (pushTxHash ? { pushTxHash } : {})), (txHash ? { txHash } : {})), (decodedError ? { decodedError } : {})),
         level: 'ERROR',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_03]: (targetChain, elapsedMs) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_03]: (targetChain, elapsedMs, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_03,
         title: `Syncing State with ${friendlyChain(targetChain)} Timeout`,
         message: `Timed out waiting for UGPC relay to ${targetChain}`,
-        response: { error: 'relay timeout', chain: targetChain, elapsedMs },
+        response: Object.assign({ error: 'relay timeout', chain: targetChain, elapsedMs }, (pushTxHash ? { pushTxHash } : {})),
         level: 'ERROR',
     }),
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_299_99]: (targetChain, txHash) => ({
@@ -646,18 +646,18 @@ const RAW_HOOKS_R3 = {
         response: { chain: sourceChain },
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_01]: (sourceChain) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_01]: (sourceChain, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_01,
         title: `Awaiting ${friendlyChain(sourceChain)} Relay`,
         message: `Waiting for UGPC to relay to CEA on ${sourceChain}`,
-        response: { chain: sourceChain },
+        response: Object.assign({ chain: sourceChain }, (pushTxHash ? { pushTxHash } : {})),
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_02]: (sourceChain, elapsedMs) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_02]: (sourceChain, elapsedMs, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_02,
         title: `Syncing State with ${friendlyChain(sourceChain)}`,
         message: `Polling ${sourceChain} for CEA execution`,
-        response: { chain: sourceChain, elapsedMs },
+        response: Object.assign({ chain: sourceChain, elapsedMs }, (pushTxHash ? { pushTxHash } : {})),
         level: 'INFO',
     }),
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_309_03]: (sourceChain, txHash) => ({
@@ -667,18 +667,18 @@ const RAW_HOOKS_R3 = {
         response: { chain: sourceChain, txHash },
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_01]: (sourceChain) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_01]: (sourceChain, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_01,
         title: `${friendlyChain(sourceChain)} → Push Chain Inbound Tx Submitted`,
         message: `CEA initiated return — waiting for Push Chain inbound from ${sourceChain}`,
-        response: { chain: sourceChain },
+        response: Object.assign({ chain: sourceChain }, (pushTxHash ? { pushTxHash } : {})),
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_02]: (sourceChain, elapsedMs) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_02]: (sourceChain, elapsedMs, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_310_02,
         title: 'Syncing State with Push Chain for Inbound Tx',
         message: `Polling Push Chain for inbound from ${sourceChain}`,
-        response: { chain: sourceChain, elapsedMs },
+        response: Object.assign({ chain: sourceChain, elapsedMs }, (pushTxHash ? { pushTxHash } : {})),
         level: 'INFO',
     }),
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_01]: (sourceChain, txHash, receipt) => ({
@@ -695,7 +695,7 @@ const RAW_HOOKS_R3 = {
     // Phase is passed by the emission site so the title matches the leg that
     // actually failed. Default stays 'inbound' for callers that don't specify
     // (backwards-compat with fixtures + response-builder's inbound block).
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02]: (errorMessage, phase = 'inbound', chain, decodedError) => {
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_02]: (errorMessage, phase = 'inbound', chain, decodedError, pushTxHash, txHash) => {
         const normalizedErrorMessage = phase === 'push'
             ? (0, formatters_1.normalizePcInsufficientFundsError)(errorMessage)
             : errorMessage;
@@ -707,11 +707,11 @@ const RAW_HOOKS_R3 = {
                     ? 'Push Chain Tx Failed'
                     : 'Push Chain Inbound Tx Failed',
             message: normalizedErrorMessage,
-            response: Object.assign({ error: normalizedErrorMessage, phase, chain: chain !== null && chain !== void 0 ? chain : null }, (decodedError ? { decodedError } : {})),
+            response: Object.assign(Object.assign(Object.assign({ error: normalizedErrorMessage, phase, chain: chain !== null && chain !== void 0 ? chain : null }, (pushTxHash ? { pushTxHash } : {})), (txHash ? { txHash } : {})), (decodedError ? { decodedError } : {})),
             level: 'ERROR',
         };
     },
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_03]: (sourceChain, elapsedMs, phase = 'inbound') => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_03]: (sourceChain, elapsedMs, phase = 'inbound', pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_03,
         title: 'Push Chain Inbound Tx Timeout',
         message: phase === 'outbound'
@@ -719,16 +719,11 @@ const RAW_HOOKS_R3 = {
             : phase === 'push'
                 ? `Timed out waiting for Push Chain tx`
                 : `Timed out waiting for inbound from ${sourceChain}`,
-        response: {
-            error: phase === 'outbound'
+        response: Object.assign({ error: phase === 'outbound'
                 ? 'outbound timeout'
                 : phase === 'push'
                     ? 'push timeout'
-                    : 'inbound timeout',
-            phase,
-            chain: sourceChain,
-            elapsedMs,
-        },
+                    : 'inbound timeout', phase, chain: sourceChain, elapsedMs }, (pushTxHash ? { pushTxHash } : {})),
         level: 'ERROR',
     }),
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_399_99]: (sourceChain, txHash) => ({
@@ -877,25 +872,27 @@ const RAW_HOOKS_MULTICHAIN = {
         response: { quoted, threshold, gasToken, pathTag },
         level: 'INFO',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_01]: (hopCount) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_01]: (hopCount, txHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_01,
         title: 'All Multichain Transactions Successful',
         message: `${hopCount}-hop transaction confirmed across all chains`,
-        response: { hopCount },
+        response: Object.assign({ hopCount }, (txHash ? { txHash } : {})),
         level: 'SUCCESS',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_02]: (failedAt, total, errorMessage) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_02]: (failedAt, total, errorMessage, txHash, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_02,
         title: 'Multichain Transactions Failed',
         message: `Multichain failed at hop ${failedAt} of ${total}: ${errorMessage}`,
-        response: { failedAt, total, error: errorMessage },
+        response: Object.assign(Object.assign({ failedAt,
+            total, error: errorMessage }, (txHash ? { txHash } : {})), (pushTxHash ? { pushTxHash } : {})),
         level: 'ERROR',
     }),
-    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_03]: (failedAt, total) => ({
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_03]: (failedAt, total, txHash, pushTxHash) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_999_03,
         title: 'Multichain Transactions Timeout',
         message: `Multichain timed out at hop ${failedAt} of ${total}`,
-        response: { failedAt, total, error: 'multichain timeout' },
+        response: Object.assign(Object.assign({ failedAt,
+            total, error: 'multichain timeout' }, (txHash ? { txHash } : {})), (pushTxHash ? { pushTxHash } : {})),
         level: 'ERROR',
     }),
 };

package/src/lib/push-client/push-client.d.ts

@@ -1,3 +1,4 @@
+import { TransactionReceipt } from 'viem';
 import { MsgDeployUEA, MsgExecutePayload, MsgMintPC, MsgMigrateUEA } from '../generated/v1/tx';
 import { Any } from 'cosmjs-types/google/protobuf/any';
 import { TxBody, TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
@@ -6,6 +7,7 @@ import { QueryGetUniversalTxResponse } from '../generated/uexecutor/v1/query';
 import { QueryGetUniversalTxResponseV2 } from '../generated/uexecutor/v2/query';
 import { EvmClient } from '../vm-client/evm-client';
 import { PushClientOptions } from './push-client.types';
+import { TxResponse } from '../vm-client/vm-client.types';
 export declare class PushClient extends EvmClient {
     /** Gas limit for Cosmos transactions on Push Chain */
     private static readonly COSMOS_GAS_LIMIT;
@@ -15,6 +17,7 @@ export declare class PushClient extends EvmClient {
         lockerContract?: string;
         gatewayVersion?: "v0" | "v1";
         defaultRPC: string[];
+        archiveRPC?: string[];
         confirmations: number;
         fastConfirmations: number;
         timeout: number;
@@ -28,6 +31,7 @@ export declare class PushClient extends EvmClient {
     } & {
         denom: string;
         tendermintRpc: string[];
+        archiveTendermintRpc?: string[];
         prefix: string;
         factoryAddress: `0x${string}`;
         pushDecimals: bigint;
@@ -38,12 +42,35 @@ export declare class PushClient extends EvmClient {
     private readonly ephemeralKey;
     private readonly ephemeralAccount;
     private currentRpcIndex;
+    /**
+     * Archive (full-history) endpoints. History-sensitive reads fall back from
+     * the prune RPC to these on a pruned-history miss. Resolved from the chain's
+     * configured archive endpoints — empty/undefined for chains without one
+     * (mainnet/localnet), where the fallback is a no-op (prune-only behaviour).
+     */
+    private readonly archiveTendermintRpc;
+    private readonly archivePublicClient?;
     constructor(clientOptions: PushClientOptions);
     /**
      * Executes an operation with automatic fallback to next RPC endpoint on failure.
      * Follows the same pattern as SvmClient.executeWithFallback().
      */
     private executeWithRpcFallback;
+    /**
+     * Runs a history-sensitive Tendermint operation over the prune pool first and,
+     * only when prune can't serve it (the op threw on all prune attempts, or
+     * returned an `isEmpty` result), re-queries the archive pool. This is the
+     * explicit "prune miss → archive" fallback the existing per-URL machinery
+     * can't do on its own, because a pruned tx comes back as a *successful*
+     * empty/not-found rather than a transport error.
+     *
+     * When no archive is configured (mainnet/localnet, or `enableArchiveFallback`
+     * off) this is a pass-through: the original throw or empty result is returned
+     * unchanged — behaviour identical to before.
+     */
+    private executeWithArchiveFallback;
+    /** True when this client has a usable archive EVM endpoint configured. */
+    private get hasArchiveEvm();
     /**
      * Converts nPUSH (1e18) to USDC (1e8), fixed rate: 1 PUSH = 0.1 USDC
      */
@@ -89,4 +116,16 @@ export declare class PushClient extends EvmClient {
      * @throws If the tx isn't found.
      */
     getCosmosTx(txHash: string): Promise<DeliverTxResponse>;
+    /**
+     * EVM `getTransaction` with archive fallback. Prune first; on a not-found
+     * (pruned, or not yet indexed) and an archive EVM endpoint configured, retry
+     * the archive client. Without archive this is exactly `super.getTransaction`.
+     */
+    getTransaction(txHash: `0x${string}`): Promise<TxResponse>;
+    /**
+     * EVM `getTransactionReceipt` with archive fallback. Used by the inbound
+     * tracker to fetch a Push-leg receipt that may predate the prune window.
+     * Prune first; on not-found, retry the archive EVM client if configured.
+     */
+    getTransactionReceiptWithArchiveFallback(txHash: `0x${string}`): Promise<TransactionReceipt>;
 }

package/src/lib/push-client/push-client.js

@@ -27,11 +27,23 @@ function pushNetworkToChain(network) {
 }
 class PushClient extends evm_client_1.EvmClient {
     constructor(clientOptions) {
-        var _a;
+        var _a, _b, _c;
         const pushChainKey = pushNetworkToChain(clientOptions.network);
-        super(Object.assign(Object.assign({}, clientOptions), { chain: (_a = clientOptions.chain) !== null && _a !== void 0 ? _a : (0, chain_1.getPushViemChain)(pushChainKey) }));
+        const chain = (_a = clientOptions.chain) !== null && _a !== void 0 ? _a : (0, chain_1.getPushViemChain)(pushChainKey);
+        super(Object.assign(Object.assign({}, clientOptions), { chain }));
         this.currentRpcIndex = 0;
         this.pushChainInfo = chain_1.PUSH_CHAIN_INFO[pushChainKey];
+        // Archive fallback is always set up; it's inert for chains without an
+        // archive endpoint (mainnet/localnet → empty lists), and otherwise lets
+        // history-sensitive reads recover a pruned tx from the archive node.
+        this.archiveTendermintRpc = (_b = this.pushChainInfo.archiveTendermintRpc) !== null && _b !== void 0 ? _b : [];
+        const archiveEvmUrls = (_c = chain_1.CHAIN_INFO[pushChainKey].archiveRPC) !== null && _c !== void 0 ? _c : [];
+        if (archiveEvmUrls.length > 0) {
+            this.archivePublicClient = (0, viem_1.createPublicClient)({
+                chain,
+                transport: (0, viem_1.fallback)(archiveEvmUrls.map((url) => (0, viem_1.http)(url, { retryCount: 5, retryDelay: 500 }))),
+            });
+        }
         this.ephemeralKey = (0, accounts_1.generatePrivateKey)();
         this.ephemeralAccount = (0, accounts_1.privateKeyToAccount)(this.ephemeralKey);
     }
@@ -40,8 +52,11 @@ class PushClient extends evm_client_1.EvmClient {
      * Follows the same pattern as SvmClient.executeWithFallback().
      */
     executeWithRpcFallback(operation_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* (operation, operationName = 'operation') {
-            const rpcUrls = this.pushChainInfo.tendermintRpc;
+        return tslib_1.__awaiter(this, arguments, void 0, function* (operation, operationName = 'operation', rpcUrls = this.pushChainInfo.tendermintRpc, 
+        // Sticky cursor (`currentRpcIndex`) is only meaningful for the primary
+        // prune pool; the archive pass passes `sticky=false` so a single archive
+        // URL can't pin the prune cursor.
+        sticky = true) {
             let lastError = null;
             // Cycle the RPC URLs, but also RETRY transient failures (5xx / network /
             // "HTTP request failed") with backoff — otherwise a single 502 on a
@@ -62,11 +77,12 @@ class PushClient extends evm_client_1.EvmClient {
                     m.includes('fetch failed'));
             };
             for (let attempt = 0; attempt < totalAttempts; attempt++) {
-                const rpcIndex = (this.currentRpcIndex + attempt) % rpcUrls.length;
+                const baseIndex = sticky ? this.currentRpcIndex : 0;
+                const rpcIndex = (baseIndex + attempt) % rpcUrls.length;
                 const rpcUrl = rpcUrls[rpcIndex];
                 try {
                     const result = yield operation(rpcUrl);
-                    if (rpcIndex !== this.currentRpcIndex) {
+                    if (sticky && rpcIndex !== this.currentRpcIndex) {
                         this.currentRpcIndex = rpcIndex;
                     }
                     return result;
@@ -88,6 +104,47 @@ class PushClient extends evm_client_1.EvmClient {
             throw new Error(`All RPC endpoints failed for ${operationName}. Last error: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`);
         });
     }
+    /**
+     * Runs a history-sensitive Tendermint operation over the prune pool first and,
+     * only when prune can't serve it (the op threw on all prune attempts, or
+     * returned an `isEmpty` result), re-queries the archive pool. This is the
+     * explicit "prune miss → archive" fallback the existing per-URL machinery
+     * can't do on its own, because a pruned tx comes back as a *successful*
+     * empty/not-found rather than a transport error.
+     *
+     * When no archive is configured (mainnet/localnet, or `enableArchiveFallback`
+     * off) this is a pass-through: the original throw or empty result is returned
+     * unchanged — behaviour identical to before.
+     */
+    executeWithArchiveFallback(operation, operationName, isEmpty) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let pruneResult;
+            let pruneError;
+            try {
+                pruneResult = yield this.executeWithRpcFallback(operation, operationName);
+            }
+            catch (error) {
+                pruneError = error;
+            }
+            const pruneMissed = pruneError !== undefined ||
+                (pruneResult !== undefined && isEmpty(pruneResult));
+            if (!pruneMissed) {
+                return pruneResult;
+            }
+            if (this.archiveTendermintRpc.length === 0) {
+                // No archive: preserve original behaviour (re-throw, or return empty).
+                if (pruneError !== undefined)
+                    throw pruneError;
+                return pruneResult;
+            }
+            // Prune missed + archive available → re-query archive (non-sticky).
+            return this.executeWithRpcFallback(operation, `${operationName} (archive)`, this.archiveTendermintRpc, false);
+        });
+    }
+    /** True when this client has a usable archive EVM endpoint configured. */
+    get hasArchiveEvm() {
+        return this.archivePublicClient !== undefined;
+    }
     /**
      * Converts nPUSH (1e18) to USDC (1e8), fixed rate: 1 PUSH = 0.1 USDC
      */
@@ -224,14 +281,26 @@ class PushClient extends evm_client_1.EvmClient {
      */
     getUniversalTxByIdV2(id) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return this.executeWithRpcFallback((rpcUrl) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const operation = (rpcUrl) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 const tmClient = yield tendermint_rpc_1.Tendermint34Client.connect(rpcUrl);
                 const queryClient = new stargate_1.QueryClient(tmClient);
                 const rpc = (0, stargate_1.createProtobufRpcClient)(queryClient);
                 const request = query_2.QueryGetUniversalTxRequestV2.fromPartial({ id });
                 const responseBytes = yield rpc.request('uexecutor.v2.Query', 'GetUniversalTx', query_2.QueryGetUniversalTxRequestV2.encode(request).finish());
                 return query_2.QueryGetUniversalTxResponseV2.decode(responseBytes);
-            }), 'getUniversalTxByIdV2');
+            });
+            // This is a current-STATE query (abci_query), so prune is always
+            // authoritative — an empty `universalTx` is a real "doesn't exist", not a
+            // pruned-history miss. Only fall back to archive on a hard error (all prune
+            // attempts failed); never on an empty result (would double-load on polls).
+            try {
+                return yield this.executeWithRpcFallback(operation, 'getUniversalTxByIdV2');
+            }
+            catch (error) {
+                if (this.archiveTendermintRpc.length === 0)
+                    throw error;
+                return this.executeWithRpcFallback(operation, 'getUniversalTxByIdV2 (archive)', this.archiveTendermintRpc, false);
+            }
         });
     }
     /**
@@ -241,11 +310,14 @@ class PushClient extends evm_client_1.EvmClient {
      */
     searchCosmosByQuery(query) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return this.executeWithRpcFallback((rpcUrl) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const operation = (rpcUrl) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 const client = yield stargate_1.StargateClient.connect(rpcUrl);
                 const results = yield client.searchTx(query);
                 return results.map((result) => JSON.parse(JSON.stringify(result, (_key, value) => typeof value === 'bigint' ? value.toString() : value)));
-            }), 'searchCosmosByQuery');
+            });
+            // History-sensitive (tx_search): an empty result on prune may just mean the
+            // matching tx is outside the prune window → retry archive.
+            return this.executeWithArchiveFallback(operation, 'searchCosmosByQuery', (results) => results.length === 0);
         });
     }
     /**
@@ -256,7 +328,7 @@ class PushClient extends evm_client_1.EvmClient {
      */
     getCosmosTx(txHash) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return this.executeWithRpcFallback((rpcUrl) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const operation = (rpcUrl) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 const client = yield stargate_1.StargateClient.connect(rpcUrl);
                 const query = `ethereum_tx.ethereumTxHash='${txHash}'`;
                 const results = yield client.searchTx(query);
@@ -268,7 +340,53 @@ class PushClient extends evm_client_1.EvmClient {
                     throw new Error(`No Cosmos-indexed tx for EVM hash ${txHash}`);
                 }
                 return Object.assign(Object.assign({}, convertedResults[0]), { transactionHash: txHash });
-            }), 'getCosmosTx');
+            });
+            // History-sensitive (tx_search). The op throws on an empty result, so the
+            // pruned-history miss surfaces as a thrown error — `isEmpty` stays false and
+            // the wrapper retries archive via its caught-error path.
+            return this.executeWithArchiveFallback(operation, 'getCosmosTx', () => false);
+        });
+    }
+    /**
+     * EVM `getTransaction` with archive fallback. Prune first; on a not-found
+     * (pruned, or not yet indexed) and an archive EVM endpoint configured, retry
+     * the archive client. Without archive this is exactly `super.getTransaction`.
+     */
+    getTransaction(txHash) {
+        const _super = Object.create(null, {
+            getTransaction: { get: () => super.getTransaction }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield _super.getTransaction.call(this, txHash);
+            }
+            catch (error) {
+                if (!this.hasArchiveEvm)
+                    throw error;
+                const archiveClient = this.archivePublicClient;
+                const tx = yield archiveClient.getTransaction({ hash: txHash });
+                const wait = (...args_1) => tslib_1.__awaiter(this, [...args_1], void 0, function* (confirmations = 1) { return archiveClient.waitForTransactionReceipt({ hash: txHash, confirmations }); });
+                return Object.assign(Object.assign({}, tx), { wait });
+            }
+        });
+    }
+    /**
+     * EVM `getTransactionReceipt` with archive fallback. Used by the inbound
+     * tracker to fetch a Push-leg receipt that may predate the prune window.
+     * Prune first; on not-found, retry the archive EVM client if configured.
+     */
+    getTransactionReceiptWithArchiveFallback(txHash) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.publicClient.getTransactionReceipt({ hash: txHash });
+            }
+            catch (error) {
+                if (!this.hasArchiveEvm)
+                    throw error;
+                return this.archivePublicClient.getTransactionReceipt({
+                    hash: txHash,
+                });
+            }
         });
     }
 }

package/src/lib/universal/signer/signer.d.ts

@@ -22,7 +22,7 @@ import { CHAIN, LIBRARY } from '../../constants/enums';
  *   signAndSendTransaction: async (data) => signRawTx(data),
  * });
  */
-export declare function createUniversalSigner({ account, signMessage, signAndSendTransaction, signTypedData, }: UniversalSigner): UniversalSigner;
+export declare function createUniversalSigner({ account, signMessage, signAndSendTransaction, signTypedData, signAuthorization, }: UniversalSigner): UniversalSigner;
 /**
  * Creates a UniversalSigner from either a viem, ethers, solana WalletClient or Account instance.
  *