@pushchain/core 6.0.24 → 6.0.26

package/src/lib/read-state/svm-pda.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveIdlPda = deriveIdlPda;
+exports.isProgramSubject = isProgramSubject;
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("buffer");
+const normalize_address_1 = require("../orchestrator/svm-idl/normalize-address");
+const errors_1 = require("./errors");
+const svm_account_1 = require("./svm-account");
+/** Every instruction account named like `name` that carries PDA seeds. */
+function findSeedTemplates(idl, name) {
+    const key = (0, svm_account_1.idlNameKey)(name);
+    const out = [];
+    const visit = (instruction, accounts) => {
+        for (const a of accounts) {
+            if (a.accounts)
+                visit(instruction, a.accounts); // composite account groups
+            else if (a.pda && (0, svm_account_1.idlNameKey)(a.name) === key)
+                out.push({ pda: a.pda, instruction });
+        }
+    };
+    for (const ix of idl.instructions ?? [])
+        visit(ix, ix.accounts);
+    return out;
+}
+function toPublicKey(value, what) {
+    if (value instanceof web3_js_1.PublicKey)
+        return value;
+    try {
+        return new web3_js_1.PublicKey(buffer_1.Buffer.from((0, normalize_address_1.toSvmHexAddress)(value).slice(2), 'hex'));
+    }
+    catch (e) {
+        throw new errors_1.InvalidReadQueryError(`${what} must be a Solana pubkey (base58, 0x 32-byte hex, or PublicKey): ${e.message}`);
+    }
+}
+const INT_WIDTH = {
+    u8: [1, false], i8: [1, true], u16: [2, false], i16: [2, true], u32: [4, false], i32: [4, true],
+    u64: [8, false], i64: [8, true], u128: [16, false], i128: [16, true],
+};
+function encodeInt(value, type, what) {
+    const [bytes, signed] = INT_WIDTH[type];
+    let n;
+    try {
+        n = typeof value === 'bigint' ? value : BigInt(value);
+    }
+    catch {
+        throw new errors_1.InvalidReadQueryError(`${what} must be an integer for ${type}`);
+    }
+    const bits = BigInt(bytes * 8);
+    const min = signed ? -(1n << (bits - 1n)) : 0n;
+    const max = signed ? (1n << (bits - 1n)) - 1n : (1n << bits) - 1n;
+    if (n < min || n > max)
+        throw new errors_1.InvalidReadQueryError(`${what} out of ${type} range: ${n}`);
+    let u = n < 0n ? (1n << bits) + n : n;
+    const out = buffer_1.Buffer.alloc(bytes);
+    for (let i = 0; i < bytes; i++) {
+        out[i] = Number(u & 0xffn);
+        u >>= 8n;
+    }
+    return out;
+}
+function encodeSeed(value, type, what) {
+    if (type === 'pubkey')
+        return toPublicKey(value, what).toBuffer();
+    if (typeof type === 'string' && type in INT_WIDTH)
+        return encodeInt(value, type, what);
+    if (type === 'bool') {
+        if (typeof value !== 'boolean')
+            throw new errors_1.InvalidReadQueryError(`${what} must be a boolean`);
+        return buffer_1.Buffer.from([value ? 1 : 0]);
+    }
+    if (type === 'string') {
+        if (typeof value !== 'string')
+            throw new errors_1.InvalidReadQueryError(`${what} must be a string`);
+        return buffer_1.Buffer.from(value, 'utf8');
+    }
+    const isBytes = type === 'bytes' || (typeof type === 'object' && type !== null && 'array' in type && type.array[0] === 'u8');
+    if (isBytes) {
+        if (value instanceof Uint8Array)
+            return buffer_1.Buffer.from(value);
+        if (typeof value === 'string' && /^0x([0-9a-fA-F]{2})*$/.test(value))
+            return buffer_1.Buffer.from(value.slice(2), 'hex');
+        throw new errors_1.InvalidReadQueryError(`${what} must be bytes (Uint8Array or 0x-hex)`);
+    }
+    throw new errors_1.InvalidReadQueryError(`${what}: seed type ${JSON.stringify(type)} is not supported`);
+}
+function argType(ix, path) {
+    if (path.includes('.'))
+        throw new errors_1.InvalidReadQueryError(`seed arg path ${path} reads a struct field; only top-level instruction args are supported`);
+    const arg = ix.args.find(a => a.name === path) ?? ix.args.find(a => (0, svm_account_1.idlNameKey)(a.name) === (0, svm_account_1.idlNameKey)(path));
+    if (!arg)
+        throw new errors_1.InvalidReadQueryError(`seed arg ${path} is not an argument of ${ix.name}`);
+    return arg.type;
+}
+function describeSeeds(t) {
+    return t.pda.seeds.map(s => (s.kind === 'const' ? `"${buffer_1.Buffer.from(s.value).toString('utf8')}"` : `${s.kind}:${s.path}`)).join(', ');
+}
+/** Same seeds, same order: two instructions describing one PDA agree. */
+function sameLayout(a, b) {
+    return JSON.stringify([a.pda.seeds, a.pda.program]) === JSON.stringify([b.pda.seeds, b.pda.program]);
+}
+/** Derive the PDA of account layout `functionName` from its IDL seed template and positional `args`. */
+function deriveIdlPda(idl, functionName, args = []) {
+    const templates = findSeedTemplates(idl, functionName);
+    if (templates.length === 0) {
+        throw new errors_1.InvalidReadQueryError(`the IDL has no PDA seeds for ${functionName}; pass the account address as the subject instead of the program id`);
+    }
+    const [template] = templates;
+    if (templates.some(t => !sameLayout(t, template))) {
+        throw new errors_1.InvalidReadQueryError(`the IDL describes ${functionName} with different seeds in different instructions; pass the account address as the subject`);
+    }
+    const dynamic = template.pda.seeds.filter(s => s.kind !== 'const');
+    if (args.length !== dynamic.length) {
+        throw new errors_1.InvalidReadQueryError(`${functionName} is derived from seeds [${describeSeeds(template)}]: expected ${dynamic.length} args, got ${args.length}`);
+    }
+    let i = 0;
+    const seeds = template.pda.seeds.map((seed) => {
+        if (seed.kind === 'const')
+            return buffer_1.Buffer.from(seed.value);
+        const what = `args[${i}] (${seed.kind}:${seed.path})`;
+        const value = args[i++];
+        if (seed.kind === 'account') {
+            if (seed.path.includes('.'))
+                throw new errors_1.InvalidReadQueryError(`seed ${seed.path} reads another account's field; pass the account address as the subject`);
+            return encodeSeed(value, 'pubkey', what);
+        }
+        return encodeSeed(value, argType(template.instruction, seed.path), what);
+    });
+    let programId = new web3_js_1.PublicKey(idl.address);
+    const program = template.pda.program;
+    if (program) {
+        if (program.kind !== 'const')
+            throw new errors_1.InvalidReadQueryError(`${functionName} is derived under a non-constant program; pass the account address as the subject`);
+        programId = new web3_js_1.PublicKey(buffer_1.Buffer.from(program.value));
+    }
+    return web3_js_1.PublicKey.findProgramAddressSync(seeds, programId)[0];
+}
+/** Whether `subject` is the IDL's program id (base58 or 0x-hex). */
+function isProgramSubject(idl, subject) {
+    try {
+        return (0, normalize_address_1.toSvmHexAddress)(subject) === (0, normalize_address_1.toSvmHexAddress)(idl.address);
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=svm-pda.js.map

package/src/lib/read-state/validate.d.ts

@@ -0,0 +1,22 @@
+import { type ReadSpecViolation } from './errors';
+import type { ReadPreflight, ReadSpec } from './read-state.types';
+export interface ValidateReadSpecInput {
+    spec: ReadSpec;
+    /** msg.value the request will carry. */
+    value: bigint;
+    callbackGasLimit: bigint;
+    /** When present, the height / expiry / fee rules that need chain state are checked too. */
+    preflight?: ReadPreflight;
+}
+/**
+ * Client-side mirror of every revert in `UniversalCallback.requestExternalReadSelf`
+ * (feat-read-state f8d1a0c), plus two SDK invariants, so a developer gets a typed
+ * violation list instead of an opaque revert. Line numbers refer to the contract.
+ */
+export declare function validateReadSpec(input: ValidateReadSpecInput): {
+    ok: true;
+} | {
+    ok: false;
+    violations: ReadSpecViolation[];
+};
+export declare function assertValidReadSpec(input: ValidateReadSpecInput): void;

package/src/lib/read-state/validate.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateReadSpec = validateReadSpec;
+exports.assertValidReadSpec = assertValidReadSpec;
+const viem_1 = require("viem");
+const read_state_1 = require("../constants/read-state");
+const errors_1 = require("./errors");
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const UINT16_MAX = 65_535;
+const UINT64_MAX = (1n << 64n) - 1n;
+/**
+ * Client-side mirror of every revert in `UniversalCallback.requestExternalReadSelf`
+ * (feat-read-state f8d1a0c), plus two SDK invariants, so a developer gets a typed
+ * violation list instead of an opaque revert. Line numbers refer to the contract.
+ */
+function validateReadSpec(input) {
+    const { spec, value, callbackGasLimit, preflight } = input;
+    const v = [];
+    // :98-103 InvalidAccountId — every account field non-empty
+    const ownerLen = isHexLike(spec.account.owner) ? (0, viem_1.size)(spec.account.owner) : 0;
+    if (!spec.account.chainNamespace || !spec.account.chainId || ownerLen === 0)
+        v.push('INVALID_ACCOUNT_ID');
+    // :104-106 EmptyQuery
+    if (!isHexLike(spec.query) || (0, viem_1.size)(spec.query) === 0)
+        v.push('EMPTY_QUERY');
+    // :107-109 InvalidMinConfirmations (uint16)
+    if (!Number.isInteger(spec.minConfirmations) || spec.minConfirmations < read_state_1.MIN_CONFIRMATIONS_FLOOR || spec.minConfirmations > UINT16_MAX) {
+        v.push('INVALID_MIN_CONFIRMATIONS');
+    }
+    // :113-134 InvalidBlockNumber — heightless: must be 0; else 1..oracleHeight
+    if (spec.blockNumber < 0n || spec.blockNumber > UINT64_MAX) {
+        v.push('INVALID_BLOCK_NUMBER');
+    }
+    else if (preflight) {
+        const h = preflight.observedChainHeight;
+        const bad = h === 0n ? spec.blockNumber !== 0n : spec.blockNumber === 0n || spec.blockNumber > h;
+        if (bad)
+            v.push('INVALID_BLOCK_NUMBER');
+    }
+    // :119-121 InvalidExpiryHeight — strictly in the future
+    if (spec.expiryPushChainHeight < 0n || spec.expiryPushChainHeight > UINT64_MAX) {
+        v.push('INVALID_EXPIRY_HEIGHT');
+    }
+    else if (preflight && spec.expiryPushChainHeight <= preflight.pushBlockNumber) {
+        v.push('INVALID_EXPIRY_HEIGHT');
+    }
+    // :122-124 ZeroRevertRecipient
+    if (!(0, viem_1.isAddress)(spec.revertRecipient) || spec.revertRecipient.toLowerCase() === ZERO_ADDRESS)
+        v.push('ZERO_REVERT_RECIPIENT');
+    // :125-130 ZeroCallbackGasLimit / CallbackGasLimitExceeded
+    if (callbackGasLimit <= 0n)
+        v.push('ZERO_CALLBACK_GAS_LIMIT');
+    else if (callbackGasLimit > read_state_1.MAX_CALLBACK_GAS_LIMIT)
+        v.push('CALLBACK_GAS_LIMIT_EXCEEDED');
+    // :132-139 InsufficientFee / ExcessiveFee
+    if (preflight && value < preflight.protocolFee)
+        v.push('INSUFFICIENT_FEE');
+    if (value > spec.maxFee)
+        v.push('EXCESSIVE_FEE');
+    // SDK invariant (not a contract revert): a zero budget is never fulfilled by the node.
+    if (preflight && value - preflight.protocolFee <= 0n)
+        v.push('ZERO_CALLBACK_BUDGET');
+    // SDM invariant from svm/read_executor.go:29-32 — validators hard-reject any other length.
+    if (spec.account.chainNamespace === read_state_1.READ_NAMESPACE.SVM && ownerLen !== 32)
+        v.push('SVM_OWNER_NOT_32_BYTES');
+    return v.length === 0 ? { ok: true } : { ok: false, violations: v };
+}
+function assertValidReadSpec(input) {
+    const r = validateReadSpec(input);
+    if (!r.ok) {
+        throw new errors_1.InvalidReadSpecError(r.violations, {
+            destination: `${input.spec.account.chainNamespace}:${input.spec.account.chainId}`,
+            hint: 'See ReadSpecViolation names — each mirrors a UniversalCallback revert.',
+        });
+    }
+}
+function isHexLike(x) {
+    return typeof x === 'string' && /^0x[0-9a-fA-F]*$/.test(x);
+}
+//# sourceMappingURL=validate.js.map

package/src/lib/universal-tx-detector/child-inbounds.d.ts

@@ -7,7 +7,9 @@
  * See push-chain/x/uexecutor/types/keys.go:49-53 (GetInboundUniversalTxKey).
  *
  * For SVM sources, `<txHash>` is the 0x-prefixed hex encoding of the 64-byte
- * Solana signature and `<logIndex>` is the event's index in `meta.logMessages`.
+ * Solana signature and `<logIndex>` is the gateway-event ordinal. Current
+ * gateways derive it from authenticated `emit_cpi` inner instructions;
+ * legacy log-emitting gateways used the `meta.logMessages` index.
  *
  * For Push-initiated outbounds (pcTx entries) the formula drops the log index:
  *   utxId = sha256(`<pcChainCaip>:<pcTxHash>`)

package/src/lib/universal-tx-detector/child-inbounds.js

@@ -14,7 +14,9 @@ exports.resolveChildInboundsFromLogs = resolveChildInboundsFromLogs;
  * See push-chain/x/uexecutor/types/keys.go:49-53 (GetInboundUniversalTxKey).
  *
  * For SVM sources, `<txHash>` is the 0x-prefixed hex encoding of the 64-byte
- * Solana signature and `<logIndex>` is the event's index in `meta.logMessages`.
+ * Solana signature and `<logIndex>` is the gateway-event ordinal. Current
+ * gateways derive it from authenticated `emit_cpi` inner instructions;
+ * legacy log-emitting gateways used the `meta.logMessages` index.
  *
  * For Push-initiated outbounds (pcTx entries) the formula drops the log index:
  *   utxId = sha256(`<pcChainCaip>:<pcTxHash>`)
@@ -44,10 +46,7 @@ const OUTBOUND_STATUS_NAMES = {
     2: 'OBSERVED',
     3: 'REVERTED',
 };
-const INBOUND_EVENT_NAMES = new Set([
-    'UniversalTx',
-    'RevertUniversalTx',
-]);
+const INBOUND_EVENT_NAMES = new Set(['UniversalTx', 'RevertUniversalTx']);
 const HEX_64_BYTE_RE = /^(?:0x)?[0-9a-fA-F]{128}$/;
 function normalizeInboundTxHashForKey(sourceChainCaip, externalTxHash) {
     if (!sourceChainCaip.startsWith('solana:')) {

package/src/lib/universal-tx-detector/detector-svm.js

@@ -6,18 +6,17 @@ const tslib_1 = require("tslib");
 /**
  * detectUniversalTxSvm — SVM counterpart to the EVM detector.
  *
- * Fetches the tx via Solana RPC, walks `meta.logMessages`, decodes each
- * `Program data:` entry with Anchor's BorshEventCoder against the gateway
- * IDL, normalizes field names to match classify.ts's EVM-derived shape,
- * and hands the result to the same classifier used by the EVM branch.
+ * Fetches the tx via Solana RPC and decodes gateway events with Anchor's
+ * BorshEventCoder. Current gateways use authenticated `emit_cpi!` inner
+ * instructions; legacy `Program data:` log events remain as a fallback.
  *
  * Behavior deliberately mirrors detector.ts: same UniversalTxDetection
  * return, same universalTxId derivation strategy (primary-log fallback
  * via deriveChildUniversalTxId on source-chain inbounds).
  *
  * The Push keeper stores SVM inbound ids using the 0x-prefixed hex encoding
- * of the 64-byte Solana signature and the index of the Anchor event inside
- * `meta.logMessages`: `${caip}:${hexSig}:${logMessageIndex}`.
+ * of the 64-byte Solana signature and the gateway-event ordinal:
+ * `${caip}:${hexSig}:${eventIndex}`.
  */
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
@@ -86,17 +85,22 @@ async function detectUniversalTxSvm(signature, chain, opts = {}) {
     }
     const eventCoder = new anchor_1.BorshEventCoder(universalGatewayV0_json_1.default);
     const matchingLogs = [];
-    // Walk logMessages for `Program data:` entries. Each matched event keeps
-    // the actual Solana log-message index because that is the value validators
-    // submit as the inbound log_index and the keeper uses for the UTX key.
-    for (let logIndex = 0; logIndex < logMessages.length; logIndex++) {
-        const rawLog = logMessages[logIndex];
-        if (typeof rawLog !== 'string')
-            continue;
-        const prefix = 'Program data: ';
-        if (!rawLog.startsWith(prefix))
-            continue;
-        const base64Data = rawLog.slice(prefix.length).trim();
+    const cpiPayloads = (0, svm_events_1.getSvmEventCpiPayloads)(tx, emitterBase58);
+    const eventPayloads = cpiPayloads.length > 0
+        ? cpiPayloads.map(({ base64Data, eventIndex }) => ({
+            base64Data,
+            logIndex: eventIndex,
+        }))
+        : logMessages.flatMap((rawLog, logIndex) => {
+            const prefix = 'Program data: ';
+            return typeof rawLog === 'string' && rawLog.startsWith(prefix)
+                ? [{ base64Data: rawLog.slice(prefix.length).trim(), logIndex }]
+                : [];
+        });
+    if (cpiPayloads.length > 0) {
+        notes.push('svm: decoded gateway events from emit_cpi inner instructions');
+    }
+    for (const { base64Data, logIndex } of eventPayloads) {
         // Fast discriminator check — skip non-universal events without running
         // the full Borsh decode.
         let bytes;
@@ -141,7 +145,7 @@ async function detectUniversalTxSvm(signature, chain, opts = {}) {
     notes.push(...classified.notes);
     const decoded = { ...classified.decoded };
     // Inbound fallback for universalTxId: same formula the EVM branch uses,
-    // with the canonical 0x-hex Solana signature and log-message index.
+    // with the canonical 0x-hex Solana signature and gateway-event index.
     if (!decoded.universalTxId) {
         const caip = chain;
         if (INBOUND_KINDS.has(classified.kind) &&
@@ -245,7 +249,9 @@ function coerceArgValue(srcKey, renamedKey, value) {
         return (0, viem_1.bytesToHex)(new Uint8Array(value));
     }
     // BN from anchor — has toString().
-    if (value && typeof value === 'object' && typeof value.toString === 'function') {
+    if (value &&
+        typeof value === 'object' &&
+        typeof value.toString === 'function') {
         const proto = Object.getPrototypeOf(value);
         const ctorName = proto?.constructor?.name;
         if (ctorName === 'BN') {
@@ -259,7 +265,10 @@ function coerceArgValue(srcKey, renamedKey, value) {
     }
     // Anchor enum → { [variantName]: {} }. tx_type must be surfaced as a
     // numeric index to match classify.ts's setTxType expectations.
-    if (renamedKey === 'txType' && value && typeof value === 'object' && !Array.isArray(value)) {
+    if (renamedKey === 'txType' &&
+        value &&
+        typeof value === 'object' &&
+        !Array.isArray(value)) {
         return extractTxTypeIndex(value);
     }
     return value;

package/src/lib/universal-tx-detector/svm-events.d.ts

@@ -1,12 +1,24 @@
 /**
  * SVM-side universal-tx event metadata.
  *
- * Anchor programs emit events as base64-encoded `Program data:` log lines
- * prefixed with an 8-byte discriminator. The map below covers the four SVM
- * gateway events that have EVM parity (source: universalGatewayV0.json
- * events section). The discriminator bytes come from the IDL and are
- * converted to lowercase hex for matching.
+ * Current Anchor programs emit events through `emit_cpi!`: an inner
+ * instruction whose data is EVENT_IX_TAG || event discriminator || Borsh
+ * body. Older deployments emitted the discriminator + body as a base64
+ * `Program data:` log line. Helpers in this module support both transports.
  */
+export declare const SVM_EVENT_IX_TAG: Uint8Array;
+export interface SvmGatewayEventPayload {
+    /** Base64 discriminator + Borsh body accepted by BorshEventCoder. */
+    base64Data: string;
+    /** Gateway-event ordinal used by the Push keeper as log_index. */
+    eventIndex: number;
+}
+/**
+ * Extract authenticated gateway events from Anchor `emit_cpi!` inner
+ * instructions. Only self-CPIs whose program id equals `gatewayAddress` are
+ * accepted; matching a discriminator alone is not proof of the emitter.
+ */
+export declare function getSvmEventCpiPayloads(txResp: any, gatewayAddress: string): SvmGatewayEventPayload[];
 /**
  * Mapping: 8-byte discriminator (lowercase hex, no 0x) → Anchor event name.
  * Only events with EVM classifier parity are listed; the keeper-agnostic

package/src/lib/universal-tx-detector/svm-events.js

@@ -2,15 +2,90 @@
 /**
  * SVM-side universal-tx event metadata.
  *
- * Anchor programs emit events as base64-encoded `Program data:` log lines
- * prefixed with an 8-byte discriminator. The map below covers the four SVM
- * gateway events that have EVM parity (source: universalGatewayV0.json
- * events section). The discriminator bytes come from the IDL and are
- * converted to lowercase hex for matching.
+ * Current Anchor programs emit events through `emit_cpi!`: an inner
+ * instruction whose data is EVENT_IX_TAG || event discriminator || Borsh
+ * body. Older deployments emitted the discriminator + body as a base64
+ * `Program data:` log line. Helpers in this module support both transports.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SVM_EVENT_FIELD_ALIASES = exports.SVM_FIELD_RENAMES = exports.SVM_EVENT_DISCRIMINATORS = void 0;
+exports.SVM_EVENT_FIELD_ALIASES = exports.SVM_FIELD_RENAMES = exports.SVM_EVENT_DISCRIMINATORS = exports.SVM_EVENT_IX_TAG = void 0;
+exports.getSvmEventCpiPayloads = getSvmEventCpiPayloads;
 exports.discriminatorHex = discriminatorHex;
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = require("../internal/bs58");
+exports.SVM_EVENT_IX_TAG = Uint8Array.from([
+    0xe4, 0x45, 0xa5, 0x2e, 0x51, 0xcb, 0x9a, 0x1d,
+]);
+/**
+ * Extract authenticated gateway events from Anchor `emit_cpi!` inner
+ * instructions. Only self-CPIs whose program id equals `gatewayAddress` are
+ * accepted; matching a discriminator alone is not proof of the emitter.
+ */
+function getSvmEventCpiPayloads(txResp, gatewayAddress) {
+    const groups = txResp?.meta?.innerInstructions;
+    if (!Array.isArray(groups) || groups.length === 0)
+        return [];
+    let gateway;
+    try {
+        gateway = new web3_js_1.PublicKey(gatewayAddress);
+    }
+    catch {
+        return [];
+    }
+    const message = txResp?.transaction?.message;
+    const loadedAddresses = txResp?.meta?.loadedAddresses;
+    const accountKeyAt = (index) => {
+        try {
+            if (typeof message?.getAccountKeys === 'function') {
+                return message
+                    .getAccountKeys({
+                    accountKeysFromLookups: loadedAddresses,
+                })
+                    .get(index);
+            }
+            const keys = [
+                ...(message?.accountKeys ?? message?.staticAccountKeys ?? []),
+                ...(loadedAddresses?.writable ?? []),
+                ...(loadedAddresses?.readonly ?? loadedAddresses?.readOnly ?? []),
+            ];
+            const key = keys[index];
+            return key instanceof web3_js_1.PublicKey
+                ? key
+                : key
+                    ? new web3_js_1.PublicKey(key)
+                    : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const payloads = [];
+    for (const group of groups) {
+        for (const instruction of group?.instructions ?? []) {
+            const programId = accountKeyAt(Number(instruction?.programIdIndex));
+            if (!programId?.equals(gateway) ||
+                typeof instruction?.data !== 'string') {
+                continue;
+            }
+            let raw;
+            try {
+                raw = bs58_1.bs58.decode(instruction.data);
+            }
+            catch {
+                continue;
+            }
+            if (raw.length < exports.SVM_EVENT_IX_TAG.length + 8 ||
+                !exports.SVM_EVENT_IX_TAG.every((byte, i) => raw[i] === byte)) {
+                continue;
+            }
+            payloads.push({
+                base64Data: Buffer.from(raw.subarray(exports.SVM_EVENT_IX_TAG.length)).toString('base64'),
+                eventIndex: payloads.length,
+            });
+        }
+    }
+    return payloads;
+}
 const toHex = (bytes) => bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
 /**
  * Mapping: 8-byte discriminator (lowercase hex, no 0x) → Anchor event name.

package/src/lib/vm-client/evm-client.js

@@ -202,18 +202,35 @@ class EvmClient {
      * console.log(`ETH transfer sent: ${txHash}`);
      */
     async sendTransaction({ to, data, value = BigInt(0), signer, nonce: explicitNonce, gas: explicitGas, }) {
+        const resolveGas = async () => {
+            if (explicitGas)
+                return explicitGas;
+            const estimate = () => this.publicClient.estimateGas({
+                account: signer.account.address,
+                to,
+                data,
+                value,
+            });
+            if (data !== '0x')
+                return estimate();
+            // A plain native transfer to a code-free EOA always costs 21k. Empty
+            // calldata is not sufficient to identify that case, though: contracts
+            // and EIP-7702 delegated accounts still execute code and need estimation.
+            // If the code lookup is unavailable, prefer estimation over submitting
+            // a transaction that can deterministically run out of gas.
+            try {
+                const targetCode = await this.publicClient.getCode({ address: to });
+                if (!targetCode || targetCode === '0x')
+                    return BigInt(21000);
+            }
+            catch {
+                // Fall through to estimateGas.
+            }
+            return estimate();
+        };
         // Estimate gas and fees first (can run in parallel)
         const [gas, feePerGas, chainId] = await Promise.all([
-            explicitGas
-                ? Promise.resolve(explicitGas)
-                : data === '0x'
-                    ? Promise.resolve(BigInt(21000))
-                    : this.publicClient.estimateGas({
-                        account: signer.account.address,
-                        to,
-                        data,
-                        value,
-                    }),
+            resolveGas(),
             this.publicClient.estimateFeesPerGas(),
             this.publicClient.getChainId(),
         ]);