@pushchain/core 6.0.20 → 6.0.21

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

@@ -13,6 +13,126 @@ export type ChainTarget = {
     address: string;
     chain: CHAIN;
 };
+/**
+ * A dynamic PC20 token, identified by chain and address alone.
+ *
+ * PC20 mappings live in UniversalCore's on-chain registry, not in the SDK's
+ * static token tables, so there is nothing to look a symbol up in — identity is
+ * address-and-chain, always.
+ *
+ * `chain` is where the token *is*, never where it is going:
+ *   - external wrapper → Push: the external chain the wrapper is deployed on
+ *   - Push → external:   the Push chain the canonical token lives on
+ * `to.chain` is the destination and is a separate field.
+ *
+ * The canonical form is `{ chain, address }` — nothing else. Discrimination
+ * from `MoveableToken` relies on what a PC20 reference does NOT have:
+ * `MoveableToken` requires `symbol` and `mechanism`, so their absence is the
+ * discriminator (see {@link isPC20Reference}, the single predicate). This
+ * stays sound even if `MoveableToken` grows optional fields, because the
+ * check keys on its required ones.
+ *
+ * Do NOT add `symbol` to a PC20 reference — a present `symbol` makes the
+ * object a `MoveableToken` and routes it down the static-table path (the
+ * route validator names this mistake explicitly when it happens).
+ */
+export type PC20TokenReference = {
+    chain: CHAIN;
+    /** Chain-native: checksummed hex on EVM, base58 on Solana. */
+    address: string;
+};
+/**
+ * Token accepted by `funds.token`.
+ *
+ * `MoveableToken` continues through the PRC20/native path unchanged;
+ * `PC20TokenReference` routes through the registry resolver.
+ */
+export type FundsToken = import('../constants').MoveableToken | PC20TokenReference;
+/**
+ * The single runtime discriminator for {@link FundsToken}.
+ *
+ * Every module must use this rather than re-deriving the check by inspecting
+ * fields — a second copy is how the two branches drift apart.
+ */
+export declare function isPC20Reference(token: FundsToken | undefined): token is PC20TokenReference;
+/**
+ * `ExecuteParams` after the PC20 gate has run.
+ *
+ * The public `funds.token` accepts either a `MoveableToken` or a
+ * `PC20TokenReference`. The legacy PRC20/native execution path only ever
+ * handles the former, so it types against this narrowed shape and a single
+ * gate (`resolveFundsToken` in the orchestrator) decides which branch a
+ * transaction takes.
+ *
+ * Narrowing here rather than at each of the ~24 `execute.funds!.token.symbol`
+ * call sites keeps the existing path provably untouched: if a PC20 reference
+ * ever reached it, that would be a type error, not a runtime `undefined`.
+ *
+ * Phase 2 adds the PC20 branch alongside this; it does not widen this type.
+ */
+export type LegacyExecuteParams = Omit<ExecuteParams, 'funds'> & {
+    funds?: {
+        amount: bigint;
+        token?: InternalFundsToken;
+    };
+    /**
+     * Set by the PC20 gate when `funds.token` was a `PC20TokenReference`.
+     * Authoritative for every PC20 behavioral decision — the `funds.token` view
+     * above only carries the display/encoding fields the shared path reads.
+     */
+    _pc20?: import('./internals/pc20/resolver').ResolvedPC20;
+};
+/**
+ * Internal view of a funds token inside the execution path.
+ *
+ * A PC20 gets a `'pc20-burn'` mechanism rather than being flattened into a fake
+ * `MoveableToken`. The distinction matters at three points, and a fake would be
+ * wrong at all of them:
+ *   - `'approve'` would make the SDK approve a wrapper that the gateway's
+ *     factory burns directly via `burnFrom` — an approval that is never used.
+ *   - `'native'` would attach the bridge amount as msg.value.
+ *   - the Push-side transfer must target the resolved PC20, not
+ *     `getPRC20Address`.
+ */
+export type InternalFundsToken = import('../constants').MoveableToken | {
+    symbol: string;
+    decimals: number;
+    address: string;
+    mechanism: 'pc20-burn';
+};
+/**
+ * One known address of a PC20 token — an external wrapper deployment, or the
+ * canonical Push-native token itself.
+ *
+ * Shape matches `getMoveableTokens`' entries (`chain` + `chainName`) so both
+ * token APIs read the same way.
+ */
+export type PC20RegistryEntry = {
+    /** Chain-native: checksummed hex on EVM, base58 on Solana. */
+    address: string;
+    /** CAIP-2 chain id, e.g. `'eip155:11155111'`. */
+    chain: CHAIN;
+    /** Human-readable chain key, e.g. `'ETHEREUM_SEPOLIA'`. */
+    chainName: string;
+};
+/** Result of `PushChain.utils.tokens.getPC20Address`. */
+export type PC20AddressResult = {
+    /** Canonical Push-native PC20 address. */
+    address: `0x${string}`;
+    name: string;
+    symbol: string;
+    decimals: number;
+    network: import('../constants/enums').PUSH_NETWORK;
+    /**
+     * Every confirmed address for this token: external wrapper deployments in
+     * SDK chain order, then the Push-native entry last.
+     *
+     * Confirmed only. A predicted first-export wrapper address never appears
+     * here — that stays internal to the outbound builder, because publishing an
+     * address that does not exist yet invites callers to send to it.
+     */
+    registry: PC20RegistryEntry[];
+};
 /**
  * Source chain for CEA-originated transactions (Routes 3, 4)
  * Specifies which CEA domain submits the transaction
@@ -126,7 +246,7 @@ export type ExecuteParams = {
      */
     funds?: {
         amount: bigint;
-        token?: import('../constants').MoveableToken;
+        token?: FundsToken;
     };
     /**
      * Internal: Pre-fetched UEA status to avoid redundant RPC calls.

package/src/lib/orchestrator/orchestrator.types.js

@@ -1,6 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPC20Reference = isPC20Reference;
 exports.parseUEAVersion = parseUEAVersion;
+/**
+ * The single runtime discriminator for {@link FundsToken}.
+ *
+ * Every module must use this rather than re-deriving the check by inspecting
+ * fields — a second copy is how the two branches drift apart.
+ */
+function isPC20Reference(token) {
+    if (!token)
+        return false;
+    const candidate = token;
+    // chain + address, and none of MoveableToken's required fields. Keying on
+    // the ABSENCE of required MoveableToken fields keeps this sound even if
+    // MoveableToken grows optional fields later.
+    return (typeof candidate.chain === 'string' &&
+        typeof candidate.address === 'string' &&
+        candidate.symbol === undefined &&
+        candidate.mechanism === undefined);
+}
 // ============================================================================
 // UEA Version Utilities
 // ============================================================================

package/src/lib/orchestrator/payload-builders.d.ts

@@ -1,7 +1,7 @@
 import { CHAIN } from '../constants/enums';
-import type { ExecuteParams, MultiCall, UniversalOutboundTxRequest, SvmExecutePayloadFields } from './orchestrator.types';
+import type { LegacyExecuteParams, MultiCall, UniversalOutboundTxRequest, SvmExecutePayloadFields } from './orchestrator.types';
 export declare function buildExecuteMulticall({ execute, ueaAddress, logger, allowSelfValueCall, }: {
-    execute: ExecuteParams;
+    execute: LegacyExecuteParams;
     ueaAddress: `0x${string}`;
     logger?: (msg: string) => void;
     allowSelfValueCall?: boolean;

package/src/lib/orchestrator/payload-builders.js

@@ -30,23 +30,22 @@ const data_utils_1 = require("./data-utils");
 const tx_1 = require("../generated/v1/tx");
 const signing_1 = require("./internals/signing");
 function buildExecuteMulticall({ execute, ueaAddress, logger, allowSelfValueCall = false, }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
-    const log = (msg) => logger === null || logger === void 0 ? void 0 : logger(msg);
+    const log = (msg) => logger?.(msg);
     const hasData = (0, data_utils_1.hasExecutablePayloadData)(execute.data);
     log('buildExecuteMulticall — input: ' + JSON.stringify({
         to: execute.to,
-        value: (_b = (_a = execute.value) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : 'undefined',
+        value: execute.value?.toString() ?? 'undefined',
         data: execute.data ? (Array.isArray(execute.data) ? `Array(${execute.data.length})` : execute.data.slice(0, 20) + '...') : 'undefined',
         hasData,
-        fundsAmount: (_e = (_d = (_c = execute.funds) === null || _c === void 0 ? void 0 : _c.amount) === null || _d === void 0 ? void 0 : _d.toString()) !== null && _e !== void 0 ? _e : 'undefined',
-        fundsTokenSymbol: (_h = (_g = (_f = execute.funds) === null || _f === void 0 ? void 0 : _f.token) === null || _g === void 0 ? void 0 : _g.symbol) !== null && _h !== void 0 ? _h : 'undefined',
-        fundsTokenMechanism: (_l = (_k = (_j = execute.funds) === null || _j === void 0 ? void 0 : _j.token) === null || _k === void 0 ? void 0 : _k.mechanism) !== null && _l !== void 0 ? _l : 'undefined',
+        fundsAmount: execute.funds?.amount?.toString() ?? 'undefined',
+        fundsTokenSymbol: execute.funds?.token?.symbol ?? 'undefined',
+        fundsTokenMechanism: execute.funds?.token?.mechanism ?? 'undefined',
         ueaAddress,
     }, null, 2));
     const multicallData = [];
     // *** We will pass the value alongside with the data in a single message now ***
     const branch1 = !hasData && execute.value;
-    log(`buildExecuteMulticall — Branch 1 (!data && value): ${branch1} | !hasData: ${!hasData} | execute.value: ${(_o = (_m = execute.value) === null || _m === void 0 ? void 0 : _m.toString()) !== null && _o !== void 0 ? _o : 'undefined'}`);
+    log(`buildExecuteMulticall — Branch 1 (!data && value): ${branch1} | !hasData: ${!hasData} | execute.value: ${execute.value?.toString() ?? 'undefined'}`);
     if (!hasData && execute.value) {
         const isValueToSelf = execute.to.toLowerCase() === ueaAddress.toLowerCase();
         if (isValueToSelf && !allowSelfValueCall) {
@@ -61,7 +60,7 @@ function buildExecuteMulticall({ execute, ueaAddress, logger, allowSelfValueCall
             log(`buildExecuteMulticall — Branch 1 ENTERED: pushed native value transfer to ${execute.to}`);
         }
     }
-    if ((_p = execute.funds) === null || _p === void 0 ? void 0 : _p.amount) {
+    if (execute.funds?.amount) {
         const token = execute.funds.token;
         const isArrayMulticall = Array.isArray(execute.data) && execute.data.length > 0;
         const isNative = token.mechanism === 'native';
@@ -80,9 +79,16 @@ function buildExecuteMulticall({ execute, ueaAddress, logger, allowSelfValueCall
             const erc20Transfer = (0, viem_1.encodeFunctionData)({
                 abi: erc20_evm_1.ERC20_EVM,
                 functionName: 'transfer',
-                args: [execute.to, (_q = execute.funds) === null || _q === void 0 ? void 0 : _q.amount],
+                args: [execute.to, execute.funds?.amount],
             });
-            const { address: pushChainTo } = push_chain_1.PushChain.utils.tokens.getPRC20Address(token);
+            // A PC20 unlocks as its canonical Push-native token, which the resolver
+            // already established. `getPRC20Address` must not run for it — there is
+            // no static synthetic mapping to look up, and the symbol carries no
+            // authority.
+            const pc20 = execute._pc20;
+            const pushChainTo = pc20
+                ? pc20.pushAddress
+                : push_chain_1.PushChain.utils.tokens.getPRC20Address(token).address;
             multicallData.push({
                 to: pushChainTo,
                 value: BigInt(0),
@@ -181,7 +187,6 @@ function buildCeaMulticallPayload(multicalls) {
  * @returns ABI-encoded UniversalPayload struct
  */
 function buildInboundUniversalPayload(multicallData, opts) {
-    var _a, _b, _c;
     return (0, viem_1.encodeAbiParameters)([
         {
             type: 'tuple',
@@ -202,11 +207,11 @@ function buildInboundUniversalPayload(multicallData, opts) {
             to: selectors_1.ZERO_ADDRESS,
             value: BigInt(0),
             data: multicallData,
-            gasLimit: (_a = opts === null || opts === void 0 ? void 0 : opts.gasLimit) !== null && _a !== void 0 ? _a : BigInt(10e7),
+            gasLimit: opts?.gasLimit ?? BigInt(10e7),
             maxFeePerGas: BigInt(1e10),
             maxPriorityFeePerGas: BigInt(0),
-            nonce: (_b = opts === null || opts === void 0 ? void 0 : opts.nonce) !== null && _b !== void 0 ? _b : BigInt(0),
-            deadline: (_c = opts === null || opts === void 0 ? void 0 : opts.deadline) !== null && _c !== void 0 ? _c : BigInt(9999999999),
+            nonce: opts?.nonce ?? BigInt(0),
+            deadline: opts?.deadline ?? BigInt(9999999999),
             vType: 1, // universalTxVerification
         },
     ]);
@@ -218,16 +223,15 @@ function buildInboundUniversalPayload(multicallData, opts) {
  * DecodeUniversalPayloadSolana, not the EVM ABI decoder used for EVM origins.
  */
 function buildInboundUniversalPayloadSvm(multicallData, opts) {
-    var _a, _b, _c;
     const payload = {
         to: selectors_1.ZERO_ADDRESS,
         value: BigInt(0).toString(),
         data: multicallData,
-        gasLimit: ((_a = opts === null || opts === void 0 ? void 0 : opts.gasLimit) !== null && _a !== void 0 ? _a : BigInt(100000000)).toString(),
-        maxFeePerGas: BigInt(10000000000).toString(),
+        gasLimit: (opts?.gasLimit ?? BigInt(100_000_000)).toString(),
+        maxFeePerGas: BigInt(10_000_000_000).toString(),
         maxPriorityFeePerGas: BigInt(0).toString(),
-        nonce: ((_b = opts === null || opts === void 0 ? void 0 : opts.nonce) !== null && _b !== void 0 ? _b : BigInt(0)).toString(),
-        deadline: ((_c = opts === null || opts === void 0 ? void 0 : opts.deadline) !== null && _c !== void 0 ? _c : BigInt(9999999999)).toString(),
+        nonce: (opts?.nonce ?? BigInt(0)).toString(),
+        deadline: (opts?.deadline ?? BigInt(9_999_999_999)).toString(),
         vType: tx_1.VerificationType.universalTxVerification,
     };
     return `0x${(0, signing_1.encodeUniversalPayloadSvm)(payload).toString('hex')}`;
@@ -355,7 +359,6 @@ function buildMigrationPayload() {
  * @returns Array of MultiCall operations (approvals + outbound call)
  */
 function buildOutboundApprovalAndCall(opts) {
-    var _a;
     const { prc20Token, gasFee, gatewayPcAddress, outboundRequest } = opts;
     const multicalls = [];
     // ERC20 approve for burn amount (contract calls transferFrom for PRC20 burn)
@@ -390,7 +393,7 @@ function buildOutboundApprovalAndCall(opts) {
         args: [outboundRequest],
     });
     // Use pre-computed nativeValueForGas (from Uniswap quoter) or fallback to 5x gasFee
-    const nativeValue = (_a = opts.nativeValueForGas) !== null && _a !== void 0 ? _a : (gasFee * BigInt(5));
+    const nativeValue = opts.nativeValueForGas ?? (gasFee * BigInt(5));
     multicalls.push({
         to: gatewayPcAddress,
         value: nativeValue,
@@ -405,8 +408,7 @@ function buildOutboundApprovalAndCall(opts) {
  * Check if a chain targets the SVM (Solana) virtual machine
  */
 function isSvmChain(chain) {
-    var _a;
-    return ((_a = chain_1.CHAIN_INFO[chain]) === null || _a === void 0 ? void 0 : _a.vm) === enums_1.VM.SVM;
+    return chain_1.CHAIN_INFO[chain]?.vm === enums_1.VM.SVM;
 }
 /**
  * Validate a Solana address in 0x-prefixed hex format.
@@ -528,7 +530,7 @@ function encodeSvmCeaToUeaPayload({ gatewayProgramHex, drainAmount, tokenMintHex
     const amountView = new DataView(amountBuf.buffer);
     amountView.setBigUint64(0, drainAmount, true); // LE
     // Extra payload (Vec<u8>: u32 LE length + bytes)
-    const payloadData = extraPayload !== null && extraPayload !== void 0 ? extraPayload : new Uint8Array(0);
+    const payloadData = extraPayload ?? new Uint8Array(0);
     const payloadLenBuf = new Uint8Array(4);
     const payloadLenView = new DataView(payloadLenBuf.buffer);
     payloadLenView.setUint32(0, payloadData.length, true); // LE

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

@@ -20,6 +20,7 @@ exports.validateRouteParams = validateRouteParams;
 exports.getRouteInfo = getRouteInfo;
 const enums_1 = require("../constants/enums");
 const tokens_1 = require("../constants/tokens");
+const orchestrator_types_1 = require("./orchestrator.types");
 const payload_builders_1 = require("./payload-builders");
 const data_utils_1 = require("./data-utils");
 const normalize_address_1 = require("./svm-idl/normalize-address");
@@ -57,6 +58,7 @@ exports.RouteValidationError = RouteValidationError;
  * Error thrown when a chain is not supported for CEA operations
  */
 class ChainNotSupportedError extends Error {
+    chain;
     constructor(chain) {
         super(`Chain ${chain} is not supported for CEA operations`);
         this.chain = chain;
@@ -128,7 +130,7 @@ function chainEnumToName(chain) {
  */
 function findTokenChain(token) {
     for (const [chain, tokens] of Object.entries(tokens_1.MOVEABLE_TOKENS)) {
-        if (tokens === null || tokens === void 0 ? void 0 : tokens.some(t => t.address.toLowerCase() === token.address.toLowerCase() && t.symbol === token.symbol)) {
+        if (tokens?.some(t => t.address.toLowerCase() === token.address.toLowerCase() && t.symbol === token.symbol)) {
             return chain;
         }
     }
@@ -166,8 +168,7 @@ function isChainTarget(to) {
  * @throws RouteValidationError if parameters are invalid
  */
 function detectRoute(params) {
-    var _a;
-    const hasFromChain = ((_a = params.from) === null || _a === void 0 ? void 0 : _a.chain) !== undefined;
+    const hasFromChain = params.from?.chain !== undefined;
     const toIsChainTarget = isChainTarget(params.to);
     // Case 1: No from.chain, to is simple string → Route 1 (UOA → Push)
     if (!hasFromChain && !toIsChainTarget) {
@@ -213,10 +214,9 @@ function detectRoute(params) {
  * @throws ChainNotSupportedError if chain is not supported
  */
 function validateRouteParams(params, context) {
-    var _a, _b, _c;
     const route = detectRoute(params);
     // Validate from.chain is supported external chain (Routes 3, 4)
-    if ((_a = params.from) === null || _a === void 0 ? void 0 : _a.chain) {
+    if (params.from?.chain) {
         if (!isSupportedExternalChain(params.from.chain)) {
             throw new ChainNotSupportedError(params.from.chain);
         }
@@ -261,9 +261,18 @@ function validateRouteParams(params, context) {
     // - Route 3/4 (CEA_TO_PUSH, CEA_TO_CEA): validate against from.chain.
     // For a Push-registered PRC-20 the token's own `sourceChain` must match; for a
     // non-Push token, the token's symbol must be registered on the chain.
-    if ((_b = params.funds) === null || _b === void 0 ? void 0 : _b.token) {
+    // PC20 funds skip the moveable-token validation (and only that — the address
+    // checks below still run). The static table is symbol-keyed and PC20 identity
+    // is never symbol-based; the PC20 gate validates chain ownership against the
+    // live registry, which is strictly stronger than anything this block can
+    // check. Two shapes qualify: an unresolved `PC20TokenReference`
+    // (validateRouteParams can run before the gate, e.g. in prepareTransaction)
+    // and the gate's resolved output (`_pc20` descriptor present).
+    const isPc20Funds = params._pc20 !== undefined ||
+        (0, orchestrator_types_1.isPC20Reference)(params.funds?.token);
+    if (params.funds?.token && !isPc20Funds) {
         const token = params.funds.token;
-        const clientLabel = (context === null || context === void 0 ? void 0 : context.clientChain)
+        const clientLabel = context?.clientChain
             ? chainEnumToName(context.clientChain)
             : 'unknown';
         const registeredOn = findTokenChain(token);
@@ -278,7 +287,8 @@ function validateRouteParams(params, context) {
             ? (tokens_1.MOVEABLE_TOKENS[registeredOn] || []).find(t => t.address.toLowerCase() === token.address.toLowerCase() &&
                 t.symbol === token.symbol)
             : undefined;
-        const effectiveSourceChain = (_c = token.sourceChain) !== null && _c !== void 0 ? _c : registrySourceChain === null || registrySourceChain === void 0 ? void 0 : registrySourceChain.sourceChain;
+        const effectiveSourceChain = token.sourceChain ??
+            registrySourceChain?.sourceChain;
         const validateAgainst = (chain, direction) => {
             if (isPushChain(chain))
                 return;
@@ -286,10 +296,17 @@ function validateRouteParams(params, context) {
                 ? effectiveSourceChain === chain
                 : (tokens_1.MOVEABLE_TOKENS[chain] || []).some(t => t.symbol === token.symbol);
             if (!ok) {
+                // A PC20 reference is { chain, address } ONLY. If a caller added a
+                // symbol to one, it classified as a MoveableToken and landed here —
+                // say so instead of leaving them to puzzle over the static table.
+                const pc20Hint = 'chain' in token
+                    ? '\nIf this is a PC20 token, pass { chain, address } only — no symbol or mechanism.'
+                    : '';
                 throw new RouteValidationError(`Unsupported moveable token for current client and route:\n` +
                     `token=${tokenLabel}\n` +
                     `clientChain=${clientLabel}\n` +
-                    `${direction}=${chainEnumToName(chain)}`);
+                    `${direction}=${chainEnumToName(chain)}` +
+                    pc20Hint);
             }
         };
         switch (route) {

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

@@ -6,10 +6,9 @@ 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'}'`);
+        throw new Error(`Instruction '${functionName}' not found in IDL '${idl.metadata?.name ?? 'unknown'}'`);
     }
     if (positionalArgs.length !== ix.args.length) {
         throw new Error(`Arg count mismatch for '${ix.name}': IDL expects ${ix.args.length}, got ${positionalArgs.length}`);

package/src/lib/orchestrator/svm-idl/normalize-address.js

@@ -26,7 +26,7 @@ function toSvmHexAddress(input) {
     try {
         decoded = bs58_1.bs58.decode(input);
     }
-    catch (_a) {
+    catch {
         throw new Error(`SVM address '${input}' is not valid base58 and does not start with 0x. ` +
             `Expected base58 (e.g. 'So11111111111111111111111111111111111111112') ` +
             `or 0x-prefixed 32-byte hex.`);
@@ -49,7 +49,7 @@ function isValidSvmAddress(input) {
         toSvmHexAddress(input);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }

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

@@ -13,7 +13,6 @@ const CEA_AUTHORITY_NAMES = new Set([
     'ceaSigner',
 ]);
 function resolveSvmCall(input) {
-    var _a, _b;
     const idl = (0, registry_1.getIdl)(input.programAddress);
     if (!idl) {
         throw new Error(`resolveSvmCall: no IDL found for ${input.programAddress}. ` +
@@ -28,7 +27,7 @@ function resolveSvmCall(input) {
     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(',')}]`);
+        throw new Error(`resolveSvmCall: no instruction in IDL '${idl.metadata?.name ?? 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);

package/src/lib/price-fetch/price-fetch.js

@@ -13,84 +13,83 @@ const web3_js_2 = require("@solana/web3.js");
 const anchor_2 = require("@coral-xyz/anchor");
 // Module-level price cache — survives across PriceFetch instances.
 // Chainlink feeds update every 1-2h or on 0.5% price move; 30s TTL is safe.
-const PRICE_CACHE_TTL_MS = 30000;
+const PRICE_CACHE_TTL_MS = 30_000;
 const priceCache = new Map();
 class PriceFetch {
+    rpcUrls;
     constructor(rpcUrls = {}) {
         this.rpcUrls = rpcUrls;
     }
-    getPrice(chain) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const cached = priceCache.get(chain);
-            if (cached && Date.now() < cached.expiry) {
-                return cached.price;
+    async getPrice(chain) {
+        const cached = priceCache.get(chain);
+        if (cached && Date.now() < cached.expiry) {
+            return cached.price;
+        }
+        const rpcUrls = this.rpcUrls[chain] || chain_1.CHAIN_INFO[chain].defaultRPC;
+        const vm = chain_1.CHAIN_INFO[chain].vm;
+        const { lockerContract } = chain_1.CHAIN_INFO[chain];
+        if (!lockerContract) {
+            throw new Error(`Locker contract not configured for chain: ${chain}`);
+        }
+        let price;
+        switch (vm) {
+            case enums_1.VM.EVM: {
+                const evmClient = new evm_client_1.EvmClient({ rpcUrls });
+                const result = await evmClient.readContract({
+                    abi: feeLocker_evm_1.FEE_LOCKER_EVM,
+                    address: lockerContract,
+                    functionName: 'getEthUsdPrice',
+                });
+                // getEthUsdPrice returns price scaled to 1e18 and the chainlink feed decimals.
+                // Downstream lockFee math expects the price in 8 decimals, so scale down from 1e18 to 1e8.
+                const [price1e18] = result;
+                price = price1e18 / BigInt(10 ** 10); // 1e18 -> 1e8
+                break;
             }
-            const rpcUrls = this.rpcUrls[chain] || chain_1.CHAIN_INFO[chain].defaultRPC;
-            const vm = chain_1.CHAIN_INFO[chain].vm;
-            const { lockerContract } = chain_1.CHAIN_INFO[chain];
-            if (!lockerContract) {
-                throw new Error(`Locker contract not configured for chain: ${chain}`);
-            }
-            let price;
-            switch (vm) {
-                case enums_1.VM.EVM: {
-                    const evmClient = new evm_client_1.EvmClient({ rpcUrls });
-                    const result = yield evmClient.readContract({
-                        abi: feeLocker_evm_1.FEE_LOCKER_EVM,
-                        address: lockerContract,
-                        functionName: 'getEthUsdPrice',
-                    });
-                    // getEthUsdPrice returns price scaled to 1e18 and the chainlink feed decimals.
-                    // Downstream lockFee math expects the price in 8 decimals, so scale down from 1e18 to 1e8.
-                    const [price1e18] = result;
-                    price = price1e18 / BigInt(Math.pow(10, 10)); // 1e18 -> 1e8
-                    break;
+            case enums_1.VM.SVM: {
+                const PRICE_ACCOUNT = new web3_js_2.PublicKey('7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE');
+                const connection = new web3_js_1.Connection(rpcUrls[0], 'confirmed');
+                const provider = new anchor_2.AnchorProvider(connection, {
+                    publicKey: new web3_js_2.PublicKey('EfQYRThwBu4MsU7Lf3D2e68tCtdwfYj6f66ot1e2HNrq'),
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }, { commitment: 'confirmed' });
+                const program = new anchor_1.Program(feeLocker_json_1.default, provider);
+                let result;
+                try {
+                    result = await program.methods['getSolPrice']()
+                        .accounts({
+                        priceUpdate: PRICE_ACCOUNT,
+                    })
+                        .view();
                 }
-                case enums_1.VM.SVM: {
-                    const PRICE_ACCOUNT = new web3_js_2.PublicKey('7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE');
-                    const connection = new web3_js_1.Connection(rpcUrls[0], 'confirmed');
-                    const provider = new anchor_2.AnchorProvider(connection, {
-                        publicKey: new web3_js_2.PublicKey('EfQYRThwBu4MsU7Lf3D2e68tCtdwfYj6f66ot1e2HNrq'),
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }, { commitment: 'confirmed' });
-                    const program = new anchor_1.Program(feeLocker_json_1.default, provider);
-                    let result;
-                    try {
-                        result = yield program.methods['getSolPrice']()
-                            .accounts({
-                            priceUpdate: PRICE_ACCOUNT,
-                        })
-                            .view();
-                    }
-                    catch (err) {
-                        const e = err;
-                        console.error('[price-fetch][SVM getSolPrice] FAILED');
-                        console.error('  rpc:', rpcUrls[0]);
-                        console.error('  locker:', lockerContract);
-                        console.error('  priceAccount:', PRICE_ACCOUNT.toBase58());
-                        console.error('  message:', e === null || e === void 0 ? void 0 : e.message);
-                        if (e === null || e === void 0 ? void 0 : e.logs)
-                            console.error('  logs:', e.logs);
-                        if (e === null || e === void 0 ? void 0 : e.simulationResponse)
-                            console.error('  simulationResponse:', JSON.stringify(e.simulationResponse, null, 2));
-                        if (e === null || e === void 0 ? void 0 : e.programErrorStack)
-                            console.error('  programErrorStack:', e.programErrorStack);
-                        throw err;
-                    }
-                    if (!result || !result.price) {
-                        throw new Error('Invalid price data returned');
-                    }
-                    // Exponent on this function is always NEGATIVE
-                    price = BigInt(result.price.toNumber());
-                    break;
+                catch (err) {
+                    const e = err;
+                    console.error('[price-fetch][SVM getSolPrice] FAILED');
+                    console.error('  rpc:', rpcUrls[0]);
+                    console.error('  locker:', lockerContract);
+                    console.error('  priceAccount:', PRICE_ACCOUNT.toBase58());
+                    console.error('  message:', e?.message);
+                    if (e?.logs)
+                        console.error('  logs:', e.logs);
+                    if (e?.simulationResponse)
+                        console.error('  simulationResponse:', JSON.stringify(e.simulationResponse, null, 2));
+                    if (e?.programErrorStack)
+                        console.error('  programErrorStack:', e.programErrorStack);
+                    throw err;
                 }
-                default: {
-                    throw new Error(`Unsupported VM ${vm}`);
+                if (!result || !result.price) {
+                    throw new Error('Invalid price data returned');
                 }
+                // Exponent on this function is always NEGATIVE
+                price = BigInt(result.price.toNumber());
+                break;
+            }
+            default: {
+                throw new Error(`Unsupported VM ${vm}`);
             }
-            priceCache.set(chain, { price, expiry: Date.now() + PRICE_CACHE_TTL_MS });
-            return price;
-        });
+        }
+        priceCache.set(chain, { price, expiry: Date.now() + PRICE_CACHE_TTL_MS });
+        return price;
     }
 }
 exports.PriceFetch = PriceFetch;