@pushchain/core 5.1.4 → 5.1.5-alpha.1

package/src/lib/orchestrator/internals/route-handlers.js

@@ -35,6 +35,7 @@ const utils_1 = require("../../utils");
 const price_fetch_1 = require("../../price-fetch/price-fetch");
 const route_detector_1 = require("../route-detector");
 const cea_utils_1 = require("../cea-utils");
+const build_payload_1 = require("../svm-idl/build-payload");
 const payload_builders_1 = require("../payload-builders");
 const selectors_1 = require("../../constants/selectors");
 const erc20_evm_1 = require("../../constants/abi/erc20.evm");
@@ -393,22 +394,15 @@ function executeUoaToCeaSvm(ctx, params, target, executeFn) {
         const targetChain = target.chain;
         const targetAddress = target.address; // 0x-prefixed, 32 bytes
         const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
-        const hasSvmExecute = !!params.svmExecute;
+        const { svmPayload, targetBytes, hasExecute: hasSvmExecute, } = (0, build_payload_1.buildSvmPayloadFromParams)({
+            data: params.data,
+            to: target,
+            senderUea: ueaAddress,
+        });
         (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — target: ${targetAddress}, chain: ${targetChain}, ` +
             `hasSvmExecute: ${hasSvmExecute}, value: ${(_b = (_a = params.value) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '0'}`);
-        // --- Build SVM payload ---
-        let svmPayload = '0x'; // empty for withdraw (SOL/SPL)
         if (hasSvmExecute) {
-            // Execute case: encode the CPI payload
-            const exec = params.svmExecute;
-            svmPayload = (0, payload_builders_1.encodeSvmExecutePayload)({
-                targetProgram: exec.targetProgram,
-                accounts: exec.accounts,
-                ixData: exec.ixData,
-                instructionId: 2,
-            });
-            (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — encoded execute payload: ${(svmPayload.length - 2) / 2} bytes, ` +
-                `${exec.accounts.length} accounts`);
+            (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — encoded execute payload: ${(svmPayload.length - 2) / 2} bytes`);
         }
         // --- Determine PRC-20 token and burn amount ---
         let prc20Token = selectors_1.ZERO_ADDRESS;
@@ -439,13 +433,8 @@ function executeUoaToCeaSvm(ctx, params, target, executeFn) {
             burnAmount = BigInt(0);
             (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — EXECUTE-only: using PRC-20 ${prc20Token} with zero burn amount`);
         }
-        // --- Determine target bytes ---
-        // For withdraw: target is the Solana recipient pubkey
-        // For execute: target is the target Solana program
-        const targetBytes = hasSvmExecute
-            ? params.svmExecute.targetProgram
-            : targetAddress;
         // --- Build outbound request ---
+        // targetBytes: for execute = program id (resolver output); for withdraw = to.address
         const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_d = params.gasLimit) !== null && _d !== void 0 ? _d : BigInt(0), svmPayload, ueaAddress // revert recipient is the UEA
         );
         (0, context_1.printLog)(ctx, `executeUoaToCeaSvm — outbound request: ${JSON.stringify({
@@ -972,7 +961,7 @@ function executeCeaToCea(ctx, params, executeFn) {
  */
 function buildPayloadForRoute(ctx, params, route, nonce) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
         switch (route) {
             case route_detector_1.TransactionRoute.UOA_TO_PUSH: {
@@ -995,20 +984,15 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                 const target = params.to;
                 // Branch: SVM vs EVM
                 if ((0, payload_builders_1.isSvmChain)(target.chain)) {
-                    // SVM: build SVM payload (binary or empty for withdraw)
-                    let payload = '0x';
-                    if (params.svmExecute) {
-                        payload = (0, payload_builders_1.encodeSvmExecutePayload)({
-                            targetProgram: params.svmExecute.targetProgram,
-                            accounts: params.svmExecute.accounts,
-                            ixData: params.svmExecute.ixData,
-                            instructionId: 2,
-                        });
-                    }
-                    const targetBytes = (_b = (_a = params.svmExecute) === null || _a === void 0 ? void 0 : _a.targetProgram) !== null && _b !== void 0 ? _b : target.address;
+                    // SVM: build SVM payload (binary or empty for withdraw) via IDL resolver
+                    const { svmPayload: payload, targetBytes, hasExecute, } = (0, build_payload_1.buildSvmPayloadFromParams)({
+                        data: params.data,
+                        to: target,
+                        senderUea: ueaAddress,
+                    });
                     let prc20Token = selectors_1.ZERO_ADDRESS;
                     let burnAmount = BigInt(0);
-                    if ((_c = params.funds) === null || _c === void 0 ? void 0 : _c.amount) {
+                    if ((_a = params.funds) === null || _a === void 0 ? void 0 : _a.amount) {
                         const token = params.funds.token;
                         if (token) {
                             prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
@@ -1019,15 +1003,15 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                         prc20Token = (0, helpers_1.getNativePRC20ForChain)(target.chain, ctx.pushNetwork);
                         burnAmount = params.value;
                     }
-                    else if (params.svmExecute) {
+                    else if (hasExecute) {
                         prc20Token = (0, helpers_1.getNativePRC20ForChain)(target.chain, ctx.pushNetwork);
                         burnAmount = BigInt(1);
                     }
-                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_d = params.gasLimit) !== null && _d !== void 0 ? _d : BigInt(0), payload, ueaAddress);
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_b = params.gasLimit) !== null && _b !== void 0 ? _b : BigInt(0), payload, ueaAddress);
                     return { payload, gatewayRequest: outboundReq };
                 }
                 // EVM path: Resolve CEA address first (needed for self-transfer check)
-                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, target.chain, (_e = ctx.rpcUrls[target.chain]) === null || _e === void 0 ? void 0 : _e[0]);
+                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, target.chain, (_c = ctx.rpcUrls[target.chain]) === null || _c === void 0 ? void 0 : _c[0]);
                 // Build CEA outbound payload
                 const multicalls = [];
                 if (params.data) {
@@ -1060,7 +1044,7 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                 const payload = (0, payload_builders_1.buildCeaMulticallPayload)(multicalls);
                 let prc20Token = selectors_1.ZERO_ADDRESS;
                 let burnAmount = BigInt(0);
-                if ((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) {
+                if ((_d = params.funds) === null || _d === void 0 ? void 0 : _d.amount) {
                     const token = params.funds.token;
                     if (token) {
                         prc20Token = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
@@ -1068,13 +1052,13 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                     }
                 }
                 const targetBytes = ceaAddress;
-                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_g = params.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), payload, ueaAddress);
+                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, (_e = params.gasLimit) !== null && _e !== void 0 ? _e : BigInt(0), payload, ueaAddress);
                 return { payload, gatewayRequest: outboundReq };
             }
             case route_detector_1.TransactionRoute.CEA_TO_PUSH: {
                 // Route 3: CEA -> Push Chain
                 // Build CEA multicall (approve + sendUniversalTxFromCEA) and wrap in outbound
-                if (!((_h = params.from) === null || _h === void 0 ? void 0 : _h.chain)) {
+                if (!((_f = params.from) === null || _f === void 0 ? void 0 : _f.chain)) {
                     throw new Error('Route 3 (CEA -> Push) requires from.chain');
                 }
                 const sourceChain = params.from.chain;
@@ -1089,7 +1073,7 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                     const gatewayProgramHex = ('0x' + Buffer.from(programPk.toBytes()).toString('hex'));
                     let drainAmount = BigInt(0);
                     let tokenMintHex;
-                    if (((_j = params.funds) === null || _j === void 0 ? void 0 : _j.amount) && params.funds.amount > BigInt(0)) {
+                    if (((_g = params.funds) === null || _g === void 0 ? void 0 : _g.amount) && params.funds.amount > BigInt(0)) {
                         drainAmount = params.funds.amount;
                         const token = params.funds.token;
                         if (token && token.address) {
@@ -1114,10 +1098,10 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                     });
                     // burnAmount = 1 (minimum for precompile; drain amount lives inside the ixData)
                     const burnAmount = BigInt(1);
-                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, prc20Token, burnAmount, (_k = params.gasLimit) !== null && _k !== void 0 ? _k : BigInt(0), svmPayload, ueaAddress);
+                    const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, prc20Token, burnAmount, (_h = params.gasLimit) !== null && _h !== void 0 ? _h : BigInt(0), svmPayload, ueaAddress);
                     return { payload: svmPayload, gatewayRequest: outboundReq };
                 }
-                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_l = ctx.rpcUrls[sourceChain]) === null || _l === void 0 ? void 0 : _l[0]);
+                const { cea: ceaAddress } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, sourceChain, (_j = ctx.rpcUrls[sourceChain]) === null || _j === void 0 ? void 0 : _j[0]);
                 // CEA auto-deploys on-chain: Vault.finalizeUniversalTx calls CEAFactory.deployCEA()
                 // if CEA doesn't exist yet. No SDK-side blocking needed.
                 const gatewayAddr = chain_1.UNIVERSAL_GATEWAY_ADDRESSES[sourceChain];
@@ -1128,7 +1112,7 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                 const ceaMulticalls = [];
                 let tokenAddress = selectors_1.ZERO_ADDRESS;
                 let amount = BigInt(0);
-                if ((_m = params.funds) === null || _m === void 0 ? void 0 : _m.amount) {
+                if ((_k = params.funds) === null || _k === void 0 ? void 0 : _k.amount) {
                     const token = params.funds.token;
                     if (token) {
                         if (token.mechanism === 'native') {
@@ -1192,7 +1176,7 @@ function buildPayloadForRoute(ctx, params, route, nonce) {
                 // Route 3: CEA uses its own pre-existing balance — no PRC-20 burn needed.
                 // burnAmount = 0 makes this a payload-only outbound relay.
                 const burnAmount = BigInt(0);
-                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, prc20Token, burnAmount, (_o = params.gasLimit) !== null && _o !== void 0 ? _o : BigInt(0), ceaPayload, ueaAddress);
+                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, prc20Token, burnAmount, (_l = params.gasLimit) !== null && _l !== void 0 ? _l : BigInt(0), ceaPayload, ueaAddress);
                 return { payload: ceaPayload, gatewayRequest: outboundReq };
             }
             default:

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

@@ -110,7 +110,7 @@ export type ExecuteParams = {
      * Internal: Minimum fee-locking deposit in USD (8 decimals).
      * Overrides the default $1 floor when the caller needs a larger deposit
      * (e.g., Route 2 needs enough UPC for the outbound swap).
-     * Still capped at $10 by lockFee.
+     * Still capped at $1000 by lockFee.
      * @internal
      */
     _minimumDepositUsd?: bigint;
@@ -138,7 +138,10 @@ export interface UniversalTxResponse {
     wait: () => Promise<UniversalTxReceipt>;
     /**
      * Register a progress callback for events during wait().
-     * Call this BEFORE calling wait() to receive tracking events.
+     * Call this BEFORE calling wait() to receive tracking events, including
+     * the SEND-TX-08-xx / SEND-TX-99-03/04/05 external chain polling events
+     * emitted on outbound routes. Registering after wait() resolves will
+     * replay the pre-execution event buffer but miss outbound polling events.
      * @param callback - Function called with each progress event
      */
     progressHook: (callback: (event: import('../progress-hook/progress-hook.types').ProgressEvent) => void) => void;
@@ -291,16 +294,9 @@ export type UniversalExecuteParams = Omit<ExecuteParams, 'to'> & {
      * - ChainTarget: External chain target (Routes 2, 3, 4)
      */
     to: UniversalTo;
-    /**
-     * SVM-specific: CPI execution parameters for Solana targets (Route 2).
-     * When present, the outbound transaction will execute a Cross-Program Invocation
-     * on the specified Solana program with the given accounts and instruction data.
-     * Only applicable when `to.chain` is a Solana chain.
-     */
-    svmExecute?: SvmExecuteParams;
     /**
      * When true, sends MIGRATION_SELECTOR as raw CEA payload (no multicall wrapping).
-     * Used for CEA contract upgrades. Incompatible with value/funds/data/svmExecute.
+     * Used for CEA contract upgrades. Incompatible with value/funds/data.
      * Only applicable for Route 2 (UOA_TO_CEA) on EVM chains.
      */
     migration?: boolean;
@@ -329,18 +325,6 @@ export interface SvmExecutePayloadFields {
     /** Instruction ID: 2 = execute (default) */
     instructionId?: number;
 }
-/**
- * User-facing parameters for CPI execution on a Solana program via Route 2.
- * Passed as `svmExecute` in UniversalExecuteParams when targeting SVM chains.
- */
-export interface SvmExecuteParams {
-    /** Target Solana program to CPI into (32 bytes, 0x-prefixed hex) */
-    targetProgram: `0x${string}`;
-    /** Accounts required for the CPI call */
-    accounts: SvmGatewayAccountMeta[];
-    /** Raw instruction data for the target program */
-    ixData: Uint8Array;
-}
 /**
  * Request structure for sendUniversalTxOutbound on Push Chain
  * Used for Routes 2, 3, 4 (outbound from Push)
@@ -534,8 +518,14 @@ export interface CascadeTrackOptions {
     pollingIntervalMs?: number;
     /** Total timeout (default: 600000ms = 10 min) */
     timeout?: number;
-    /** Progress callback */
+    /** Per-hop progress callback */
     progressHook?: (event: CascadeProgressEvent) => void;
+    /**
+     * Unified ProgressEvent stream for SEND-TX-08/99_03-05 telemetry.
+     * Fires per outbound hop during external chain polling. Use alongside
+     * `progressHook` — they emit complementary views of the same events.
+     */
+    eventHook?: (event: import('../progress-hook/progress-hook.types').ProgressEvent) => void;
 }
 /**
  * Progress event emitted during cascade tracking

package/src/lib/orchestrator/route-detector.js

@@ -249,9 +249,6 @@ function validateRouteParams(params, context) {
         if (params.data) {
             throw new RouteValidationError('migration is incompatible with data');
         }
-        if (params.svmExecute) {
-            throw new RouteValidationError('migration is incompatible with svmExecute');
-        }
         if (isChainTarget(params.to) && (0, payload_builders_1.isSvmChain)(params.to.chain)) {
             throw new RouteValidationError('migration is not supported on SVM chains');
         }

package/src/lib/orchestrator/svm-idl/build-payload.d.ts

@@ -0,0 +1,11 @@
+import type { ChainTarget } from '../orchestrator.types';
+export interface SvmPayloadBundle {
+    svmPayload: `0x${string}`;
+    targetBytes: `0x${string}`;
+    hasExecute: boolean;
+}
+export declare function buildSvmPayloadFromParams(params: {
+    data?: `0x${string}` | unknown;
+    to: ChainTarget;
+    senderUea: `0x${string}`;
+}): SvmPayloadBundle;

package/src/lib/orchestrator/svm-idl/build-payload.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSvmPayloadFromParams = buildSvmPayloadFromParams;
+const viem_1 = require("viem");
+const payload_builders_1 = require("../payload-builders");
+const resolve_1 = require("./resolve");
+function buildSvmPayloadFromParams(params) {
+    const hasExecute = typeof params.data === 'string' &&
+        params.data.startsWith('0x') &&
+        params.data.length > 2;
+    if (!hasExecute) {
+        return {
+            svmPayload: '0x',
+            targetBytes: params.to.address,
+            hasExecute: false,
+        };
+    }
+    const resolved = (0, resolve_1.resolveSvmCall)({
+        programAddress: params.to.address,
+        data: (0, viem_1.hexToBytes)(params.data),
+        senderUea: params.senderUea,
+        targetChain: params.to.chain,
+    });
+    const svmPayload = (0, payload_builders_1.encodeSvmExecutePayload)({
+        targetProgram: resolved.targetProgram,
+        accounts: resolved.accounts,
+        ixData: resolved.ixData,
+        instructionId: 2,
+    });
+    return {
+        svmPayload,
+        targetBytes: resolved.targetProgram,
+        hasExecute: true,
+    };
+}
+//# sourceMappingURL=build-payload.js.map

package/src/lib/orchestrator/svm-idl/ix-encoder.d.ts

@@ -0,0 +1,3 @@
+import { type Idl } from '@coral-xyz/anchor';
+export declare function encodeAnchorIxData(idl: Idl, functionName: string, positionalArgs?: unknown[]): Uint8Array;
+export declare function isAnchorIdl(value: unknown): value is Idl;

package/src/lib/orchestrator/svm-idl/ix-encoder.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeAnchorIxData = encodeAnchorIxData;
+exports.isAnchorIdl = isAnchorIdl;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("buffer");
+function encodeAnchorIxData(idl, functionName, positionalArgs = []) {
+    var _a, _b;
+    const ix = findInstruction(idl, functionName);
+    if (!ix) {
+        throw new Error(`Instruction '${functionName}' not found in IDL '${(_b = (_a = idl.metadata) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'unknown'}'`);
+    }
+    if (positionalArgs.length !== ix.args.length) {
+        throw new Error(`Arg count mismatch for '${ix.name}': IDL expects ${ix.args.length}, got ${positionalArgs.length}`);
+    }
+    const named = {};
+    for (let i = 0; i < ix.args.length; i++) {
+        named[ix.args[i].name] = normalizeArg(positionalArgs[i], ix.args[i]);
+    }
+    const coder = new anchor_1.BorshInstructionCoder(idl);
+    return new Uint8Array(coder.encode(ix.name, named));
+}
+function findInstruction(idl, name) {
+    const snake = name.replace(/([A-Z])/g, (_, c) => '_' + c.toLowerCase());
+    const camel = name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+    return idl.instructions.find((i) => i.name === name || i.name === snake || i.name === camel);
+}
+function normalizeArg(value, field) {
+    if (typeof value === 'bigint') {
+        return new anchor_1.BN(value.toString());
+    }
+    if (field.type === 'pubkey' &&
+        typeof value === 'string' &&
+        value.startsWith('0x') &&
+        value.length === 66) {
+        return new web3_js_1.PublicKey(buffer_1.Buffer.from(value.slice(2), 'hex'));
+    }
+    return value;
+}
+function isAnchorIdl(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const maybe = value;
+    return Array.isArray(maybe['instructions']) && typeof maybe['address'] === 'string';
+}
+//# sourceMappingURL=ix-encoder.js.map

package/src/lib/orchestrator/svm-idl/registry.d.ts

@@ -0,0 +1,10 @@
+import type { Idl } from '@coral-xyz/anchor';
+type AddressKey = `0x${string}`;
+export declare function registerIdl(programAddress: string, idl: unknown): void;
+export declare function getIdl(programAddress: string): Idl | undefined;
+export declare function getRegisteredIdls(): Array<{
+    address: AddressKey;
+    idl: Idl;
+}>;
+export declare function clearRegistry(): void;
+export {};

package/src/lib/orchestrator/svm-idl/registry.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerIdl = registerIdl;
+exports.getIdl = getIdl;
+exports.getRegisteredIdls = getRegisteredIdls;
+exports.clearRegistry = clearRegistry;
+const ix_encoder_1 = require("./ix-encoder");
+const store = new Map();
+function normalizeKey(address) {
+    if (typeof address !== 'string' || !address.startsWith('0x')) {
+        throw new Error(`registerIdl: programAddress must be 0x-prefixed 32-byte hex, got '${address}'`);
+    }
+    const body = address.slice(2);
+    if (body.length !== 64 || !/^[0-9a-fA-F]+$/.test(body)) {
+        throw new Error(`registerIdl: programAddress must be 32 bytes (66 chars incl. 0x), got length ${address.length}`);
+    }
+    return ('0x' + body.toLowerCase());
+}
+function registerIdl(programAddress, idl) {
+    const key = normalizeKey(programAddress);
+    if (!(0, ix_encoder_1.isAnchorIdl)(idl)) {
+        throw new Error(`registerIdl: idl for ${programAddress} is not a recognized Anchor IDL (missing 'instructions' or 'address')`);
+    }
+    store.set(key, idl);
+}
+function getIdl(programAddress) {
+    const key = normalizeKey(programAddress);
+    return store.get(key);
+}
+function getRegisteredIdls() {
+    return Array.from(store.entries()).map(([address, idl]) => ({ address, idl }));
+}
+function clearRegistry() {
+    store.clear();
+}
+//# sourceMappingURL=registry.js.map

package/src/lib/orchestrator/svm-idl/resolve.d.ts

@@ -0,0 +1,14 @@
+import { CHAIN } from '../../constants/enums';
+import type { SvmGatewayAccountMeta } from '../orchestrator.types';
+export interface ResolveInput {
+    programAddress: `0x${string}`;
+    data: Uint8Array;
+    senderUea: `0x${string}`;
+    targetChain: CHAIN;
+}
+export interface ResolvedSvmCall {
+    targetProgram: `0x${string}`;
+    accounts: SvmGatewayAccountMeta[];
+    ixData: Uint8Array;
+}
+export declare function resolveSvmCall(input: ResolveInput): ResolvedSvmCall;

package/src/lib/orchestrator/svm-idl/resolve.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSvmCall = resolveSvmCall;
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("buffer");
+const account_1 = require("../../universal/account/account");
+const registry_1 = require("./registry");
+const CEA_AUTHORITY_NAMES = new Set([
+    'cea_authority',
+    'ceaAuthority',
+    'cea',
+    'cea_signer',
+    'ceaSigner',
+]);
+function resolveSvmCall(input) {
+    var _a, _b;
+    const idl = (0, registry_1.getIdl)(input.programAddress);
+    if (!idl) {
+        throw new Error(`resolveSvmCall: no IDL registered for ${input.programAddress}. ` +
+            `Call PushChain.utils.svm.registerIdl(${input.programAddress}, idl) first.`);
+    }
+    if (input.data.length < 8) {
+        throw new Error('resolveSvmCall: data must be at least 8 bytes (Anchor discriminator)');
+    }
+    const disc = input.data.slice(0, 8);
+    const ix = idl.instructions.find((i) => buffer_1.Buffer.from(i.discriminator).equals(buffer_1.Buffer.from(disc)));
+    if (!ix) {
+        throw new Error(`resolveSvmCall: no instruction in IDL '${(_b = (_a = idl.metadata) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : idl.address}' matches discriminator [${Array.from(disc).join(',')}]`);
+    }
+    const programPk = new web3_js_1.PublicKey(buffer_1.Buffer.from(input.programAddress.slice(2), 'hex'));
+    const { address: ceaPdaHex } = (0, account_1.deriveSvmCeaPda)(input.senderUea, input.targetChain, true);
+    const accounts = [];
+    for (const item of ix.accounts) {
+        if ('accounts' in item) {
+            throw new Error(`resolveSvmCall: nested account group '${item.name}' in '${ix.name}' not supported`);
+        }
+        const flat = item;
+        const pubkey = resolveAccountPubkey(flat, programPk, ceaPdaHex, ix.name);
+        accounts.push({ pubkey, isWritable: Boolean(flat.writable) });
+    }
+    return {
+        targetProgram: input.programAddress,
+        accounts,
+        ixData: input.data,
+    };
+}
+function resolveAccountPubkey(spec, programPk, ceaPdaHex, ixName) {
+    if (spec.address) {
+        return pkToHex(new web3_js_1.PublicKey(spec.address));
+    }
+    if (spec.pda) {
+        const seeds = resolveConstSeeds(spec.pda.seeds, spec.name, ixName);
+        const programForPda = spec.pda.program
+            ? new web3_js_1.PublicKey(resolveConstSeedValue(spec.pda.program, spec.name, ixName))
+            : programPk;
+        const [pda] = web3_js_1.PublicKey.findProgramAddressSync(seeds, programForPda);
+        return pkToHex(pda);
+    }
+    if (CEA_AUTHORITY_NAMES.has(spec.name)) {
+        return ceaPdaHex;
+    }
+    throw new Error(`resolveSvmCall: cannot resolve account '${spec.name}' in '${ixName}'. ` +
+        `Add 'address' or 'pda.seeds' to the IDL, or rename to a CEA convention (cea_authority).`);
+}
+function resolveConstSeeds(seeds, accountName, ixName) {
+    return seeds.map((seed, idx) => {
+        if (seed.kind !== 'const') {
+            throw new Error(`resolveSvmCall: non-const PDA seed (kind='${seed.kind}') on account '${accountName}' in '${ixName}' not supported yet`);
+        }
+        if (!Array.isArray(seed.value)) {
+            throw new Error(`resolveSvmCall: const seed at index ${idx} on '${accountName}' is malformed`);
+        }
+        return buffer_1.Buffer.from(seed.value);
+    });
+}
+function resolveConstSeedValue(seed, accountName, ixName) {
+    if (seed.kind !== 'const' || !Array.isArray(seed.value)) {
+        throw new Error(`resolveSvmCall: only const program-seed supported on '${accountName}' in '${ixName}'`);
+    }
+    return buffer_1.Buffer.from(seed.value);
+}
+function pkToHex(pk) {
+    return ('0x' + buffer_1.Buffer.from(pk.toBytes()).toString('hex'));
+}
+//# sourceMappingURL=resolve.js.map

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

@@ -158,6 +158,25 @@ const RAW_HOOKS = {
         response: null,
         level: 'INFO',
     }),
+    // External chain polling (08-x) — emitted from .wait() / cascade.waitForAll()
+    // after Push Chain tx success, while the SDK polls the relay for the
+    // external chain tx hash on outbound routes.
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_08_01]: (destinationChain) => ({
+        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_08_01,
+        title: 'Awaiting External Chain',
+        message: destinationChain
+            ? `Waiting for relay to dispatch to ${destinationChain}...`
+            : 'Waiting for relay to dispatch to external chain...',
+        response: null,
+        level: 'INFO',
+    }),
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_08_02]: (elapsedMs) => ({
+        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_08_02,
+        title: 'Polling External Chain',
+        message: `Polling relay for external transaction hash (elapsed: ${Math.round(elapsedMs / 1000)}s)`,
+        response: null,
+        level: 'INFO',
+    }),
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_01]: (txResponse) => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_01,
         title: 'Push Chain Tx Success',
@@ -172,6 +191,27 @@ const RAW_HOOKS = {
         response: null,
         level: 'ERROR',
     }),
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_03]: (details) => ({
+        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_03,
+        title: 'External Chain Tx Confirmed',
+        message: `External tx confirmed on ${details.destinationChain}: ${details.externalTxHash}`,
+        response: details,
+        level: 'SUCCESS',
+    }),
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_04]: (elapsedMs) => ({
+        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_04,
+        title: 'External Chain Tx Timeout',
+        message: `Timed out waiting for external chain tx after ${Math.round(elapsedMs / 1000)}s. Push Chain tx succeeded; the relay may still be processing.`,
+        response: null,
+        level: 'WARNING',
+    }),
+    [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_05]: (errorMessage) => ({
+        id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_05,
+        title: 'External Chain Tx Failed',
+        message: errorMessage,
+        response: null,
+        level: 'ERROR',
+    }),
     // UEA Migration hooks
     [progress_hook_types_1.PROGRESS_HOOK.UEA_MIG_01]: () => ({
         id: progress_hook_types_1.PROGRESS_HOOK.UEA_MIG_01,

package/src/lib/progress-hook/progress-hook.types.d.ts

@@ -34,8 +34,13 @@ export declare enum PROGRESS_HOOK {
     SEND_TX_06_05 = "SEND-TX-06-05",// Syncing with Push Chain
     SEND_TX_06_06 = "SEND-TX-06-06",// Funds Credited on Push Chain (was 06_05)
     SEND_TX_07 = "SEND-TX-07",// Broadcasting to Push Chain
+    SEND_TX_08_01 = "SEND-TX-08-01",// Awaiting External Chain
+    SEND_TX_08_02 = "SEND-TX-08-02",// Polling External Chain
     SEND_TX_99_01 = "SEND-TX-99-01",
     SEND_TX_99_02 = "SEND-TX-99-02",
+    SEND_TX_99_03 = "SEND-TX-99-03",// External Chain Tx Confirmed (SUCCESS)
+    SEND_TX_99_04 = "SEND-TX-99-04",// External Chain Tx Timeout (WARNING)
+    SEND_TX_99_05 = "SEND-TX-99-05",// External Chain Tx Failed (ERROR)
     UEA_MIG_01 = "UEA-MIG-01",
     UEA_MIG_02 = "UEA-MIG-02",
     UEA_MIG_03 = "UEA-MIG-03",

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

@@ -28,9 +28,15 @@ var PROGRESS_HOOK;
     PROGRESS_HOOK["SEND_TX_06_06"] = "SEND-TX-06-06";
     // 07-x: Execution / broadcasting flow
     PROGRESS_HOOK["SEND_TX_07"] = "SEND-TX-07";
+    // 08-x: External chain polling (after Push Chain tx success, outbound routes)
+    PROGRESS_HOOK["SEND_TX_08_01"] = "SEND-TX-08-01";
+    PROGRESS_HOOK["SEND_TX_08_02"] = "SEND-TX-08-02";
     // 99-x: Final outcome
     PROGRESS_HOOK["SEND_TX_99_01"] = "SEND-TX-99-01";
     PROGRESS_HOOK["SEND_TX_99_02"] = "SEND-TX-99-02";
+    PROGRESS_HOOK["SEND_TX_99_03"] = "SEND-TX-99-03";
+    PROGRESS_HOOK["SEND_TX_99_04"] = "SEND-TX-99-04";
+    PROGRESS_HOOK["SEND_TX_99_05"] = "SEND-TX-99-05";
     // UEA Migration hooks
     PROGRESS_HOOK["UEA_MIG_01"] = "UEA-MIG-01";
     PROGRESS_HOOK["UEA_MIG_02"] = "UEA-MIG-02";

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

@@ -396,15 +396,25 @@ class PushChain {
              */
             validatedUniversalSigner, (_c = options === null || options === void 0 ? void 0 : options.network) !== null && _c !== void 0 ? _c : enums_1.PUSH_NETWORK.TESTNET_DONUT, (_d = options === null || options === void 0 ? void 0 : options.rpcUrls) !== null && _d !== void 0 ? _d : {}, (_e = options === null || options === void 0 ? void 0 : options.printTraces) !== null && _e !== void 0 ? _e : false, options === null || options === void 0 ? void 0 : options.progressHook);
             const instance = new _a(orchestrator, validatedUniversalSigner, blockExplorers, isReadOnly);
-            // Background fetch account status (non-blocking, 30s timeout)
-            // Stored on instance so consumers can await it if needed: await client.accountStatusReady
+            // Background fetch account status (non-blocking, 30s timeout).
+            // The timer must be cleared once the race settles — otherwise the
+            // unref'd setTimeout keeps the Node event loop alive for the full
+            // 30s after the caller's work is done, making scripts appear "stuck".
             const ACCOUNT_STATUS_TIMEOUT = 30000;
+            let accountStatusTimer;
             instance.accountStatusReady = Promise.race([
                 // eslint-disable-next-line @typescript-eslint/no-empty-function
                 instance.getAccountStatus().then(() => { }),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Account status fetch timed out')), ACCOUNT_STATUS_TIMEOUT)),
-            ]).catch(() => {
+                new Promise((_, reject) => {
+                    accountStatusTimer = setTimeout(() => reject(new Error('Account status fetch timed out')), ACCOUNT_STATUS_TIMEOUT);
+                }),
+            ])
+                .catch(() => {
                 // Silently ignore — lazy check in execute() will retry if needed
+            })
+                .finally(() => {
+                if (accountStatusTimer)
+                    clearTimeout(accountStatusTimer);
             });
             // Let execute() await the background fetch instead of re-fetching
             orchestrator.accountStatusReadyPromise = instance.accountStatusReady;

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

@@ -68,6 +68,19 @@ export declare function convertExecutorToOrigin(executorAddress: string, options
     /** @internal Skip deprecation warning for SDK-internal calls */
     _internal?: boolean;
 }): Promise<OriginAccountInfo>;
+/**
+ * Derive the SVM CEA (PDA) for a UEA address on a Solana-based chain.
+ *
+ * Solana doesn't use a CEAFactory contract — instead, the CEA is a
+ * Program Derived Address (PDA) with seeds: ["push_identity", ueaBytes]
+ * and the SVM gateway program as the program ID.
+ *
+ * @param ueaAddress - The UEA (or Push EOA) hex address (20 bytes).
+ * @param targetChain - The SVM target chain.
+ * @param skipNetworkCheck - Whether to skip deployment status check.
+ * @returns The derived 32-byte Solana PDA address (as 0x-prefixed hex) and deployment status.
+ */
+export declare function deriveSvmCeaPda(ueaAddress: `0x${string}`, targetChain: CHAIN, skipNetworkCheck: boolean): DerivedExecutorAccount;
 /**
  * Derive the executor account (UEA or CEA) for a given account.
  *