@pushchain/core 5.1.4-alpha.9 → 5.1.5-alpha.0

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/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.
  *

package/src/lib/universal/account/account.js

@@ -6,6 +6,7 @@ exports.fromChainAgnostic = fromChainAgnostic;
 exports.convertOriginToExecutor = convertOriginToExecutor;
 exports.convertExecutorToOriginAccount = convertExecutorToOriginAccount;
 exports.convertExecutorToOrigin = convertExecutorToOrigin;
+exports.deriveSvmCeaPda = deriveSvmCeaPda;
 exports.deriveExecutorAccount = deriveExecutorAccount;
 exports.resolveControllerAccount = resolveControllerAccount;
 const tslib_1 = require("tslib");

package/src/lib/utils.d.ts

@@ -3,6 +3,7 @@ import { construct, toUniversal as toUniversalSigner, toUniversalFromKeypair } f
 import { CHAIN, PUSH_NETWORK } from './constants/enums';
 import { type MoveableToken } from './constants/tokens';
 import type { PushChain } from './push-chain/push-chain';
+import { registerIdl as registerSvmIdl, getRegisteredIdls as getRegisteredSvmIdls, getIdl as getSvmIdl } from './orchestrator/svm-idl/registry';
 /**
  * @dev - THESE UTILS ARE EXPORTED TO SDK CONSUMER
  * @dev - Make sure each exported fn has good comments to help out sdk consumer
@@ -32,6 +33,24 @@ export declare class Utils {
         deriveExecutorAccount: typeof deriveExecutorAccount;
         resolveControllerAccount: typeof resolveControllerAccount;
     };
+    /**
+     * SVM (Solana) utilities for registering program Anchor IDLs.
+     *
+     * Register your program's Anchor IDL once per process; `prepareTransaction`
+     * then resolves accounts, PDAs, and signers from the IDL so you only need
+     * to pass `data` (discriminator + Borsh args), the same shape used for EVM.
+     *
+     * @example
+     * PushChain.utils.svm.registerIdl(
+     *   PROGRAM_ADDRESS_HEX,
+     *   testCounterIdl
+     * );
+     */
+    static svm: {
+        registerIdl: typeof registerSvmIdl;
+        getRegisteredIdls: typeof getRegisteredSvmIdls;
+        getIdl: typeof getSvmIdl;
+    };
     static signer: {
         /**
          * Converts various signer types (viem, ethers v6, Solana) into a UniversalSigner.
@@ -98,7 +117,7 @@ export declare class Utils {
          */
         getChainName: (chainName: string) => string | undefined;
         encodeTxData({ abi, functionName, args, }: {
-            abi: any[];
+            abi: any;
             functionName: string;
             args?: any[];
         }): `0x${string}`;

package/src/lib/utils.js

@@ -7,6 +7,9 @@ const enums_1 = require("./constants/enums");
 const tokens_1 = require("./constants/tokens");
 const chain_1 = require("./constants/chain");
 const viem_1 = require("viem");
+const buffer_1 = require("buffer");
+const ix_encoder_1 = require("./orchestrator/svm-idl/ix-encoder");
+const registry_1 = require("./orchestrator/svm-idl/registry");
 /**
  * @dev - THESE UTILS ARE EXPORTED TO SDK CONSUMER
  * @dev - Make sure each exported fn has good comments to help out sdk consumer
@@ -74,6 +77,24 @@ Utils.account = {
     deriveExecutorAccount: account_1.deriveExecutorAccount,
     resolveControllerAccount: account_1.resolveControllerAccount,
 };
+/**
+ * SVM (Solana) utilities for registering program Anchor IDLs.
+ *
+ * Register your program's Anchor IDL once per process; `prepareTransaction`
+ * then resolves accounts, PDAs, and signers from the IDL so you only need
+ * to pass `data` (discriminator + Borsh args), the same shape used for EVM.
+ *
+ * @example
+ * PushChain.utils.svm.registerIdl(
+ *   PROGRAM_ADDRESS_HEX,
+ *   testCounterIdl
+ * );
+ */
+Utils.svm = {
+    registerIdl: registry_1.registerIdl,
+    getRegisteredIdls: registry_1.getRegisteredIdls,
+    getIdl: registry_1.getIdl,
+};
 Utils.signer = {
     /**
      * Converts various signer types (viem, ethers v6, Solana) into a UniversalSigner.
@@ -207,6 +228,13 @@ Utils.helpers = {
         };
     })(),
     encodeTxData({ abi, functionName, args = [], }) {
+        if ((0, ix_encoder_1.isAnchorIdl)(abi)) {
+            if (!Array.isArray(args)) {
+                throw new Error('Arguments must be an array');
+            }
+            const bytes = (0, ix_encoder_1.encodeAnchorIxData)(abi, functionName, args);
+            return `0x${buffer_1.Buffer.from(bytes).toString('hex')}`;
+        }
         // Validate inputs
         if (!Array.isArray(abi)) {
             throw new Error('ABI must be an array');