@pushchain/core 6.0.25 → 6.0.26

package/src/lib/read-state/result-decoder.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeReadResult = decodeReadResult;
 const viem_1 = require("viem");
 const errors_1 = require("./errors");
+const buffer_1 = require("buffer");
+const svm_account_1 = require("./svm-account");
 const WEB2_ABI_TYPE = {
     uint256: 'uint256',
     int256: 'int256',
@@ -29,6 +31,10 @@ function decodeReadResult(resultData, shape) {
     const len = (0, viem_1.size)(resultData);
     try {
         switch (shape.kind) {
+            case 'svmAccount': {
+                const { accountName, value } = (0, svm_account_1.decodeIdlAccount)(shape.idl, buffer_1.Buffer.from(resultData.slice(2), 'hex'), shape.accountName);
+                return { kind: 'svmAccount', value, accountName };
+            }
             case 'uint256': {
                 if (len !== 32)
                     throw new errors_1.ReadDecodeError(`expected 32 bytes for uint256, got ${len}`);

package/src/lib/read-state/spec-builder.js

@@ -185,7 +185,7 @@ function toCallData(prepared, target) {
  */
 async function simulateRead(deps, prepared, opts) {
     const age = Date.now() - prepared.preflight.fetchedAt;
-    if (age > (opts.staleAfterMs ?? 60_000)) {
+    if (age > (opts.staleAfterMs ?? read_state_1.READ_PREFLIGHT_STALE_MS)) {
         prepared.warnings.push(`preflight is ${Math.round(age / 1000)} s old — pushBlockNumber moves every block; rebuild before sending`);
     }
     try {

package/src/lib/read-state/svm-account.d.ts

@@ -0,0 +1,20 @@
+import { type Idl } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import type { CHAIN } from '../constants/enums';
+/** snake_case, camelCase and PascalCase spellings of one name share a key. */
+export declare function idlNameKey(name: string): string;
+/** Structural checks the coder does not make, so a bad IDL fails at prepare time. */
+export declare function validateIdl(idl: Idl): void;
+/** The IDL's own spelling of an account layout name given in any case style. */
+export declare function resolveAccountName(idl: Idl, name: string): string;
+/**
+ * Decode account bytes with the IDL. With `accountName`, the data's discriminator
+ * must match that layout; without it, the layout is the one whose discriminator
+ * prefixes the data.
+ */
+export declare function decodeIdlAccount(idl: Idl, data: Uint8Array, accountName?: string): {
+    accountName: string;
+    value: unknown;
+};
+/** Inspect the mint owner; the chain alone cannot distinguish SPL Token and Token-2022. */
+export declare function detectTokenProgram(mint: string, chain: CHAIN, rpcUrls?: string[]): Promise<PublicKey>;

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idlNameKey = idlNameKey;
+exports.validateIdl = validateIdl;
+exports.resolveAccountName = resolveAccountName;
+exports.decodeIdlAccount = decodeIdlAccount;
+exports.detectTokenProgram = detectTokenProgram;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const chain_1 = require("../constants/chain");
+const buffer_1 = require("buffer");
+const errors_1 = require("./errors");
+const svm_1 = require("./envelopes/svm");
+/** snake_case, camelCase and PascalCase spellings of one name share a key. */
+function idlNameKey(name) {
+    return name.replace(/_/g, '').toLowerCase();
+}
+/** Structural checks the coder does not make, so a bad IDL fails at prepare time. */
+function validateIdl(idl) {
+    try {
+        if (!idl || typeof idl !== 'object')
+            throw new Error('idl must be an Anchor IDL object');
+        new web3_js_1.PublicKey(idl.address);
+        if (!idl.accounts?.length)
+            throw new Error('the IDL declares no accounts');
+        for (const a of idl.accounts) {
+            const d = a.discriminator;
+            if (!Array.isArray(d) || d.length === 0 || d.some(b => !Number.isInteger(b) || b < 0 || b > 255)) {
+                throw new Error(`account ${a.name}: discriminator must be a non-empty byte array`);
+            }
+        }
+        new anchor_1.BorshAccountsCoder(idl);
+    }
+    catch (error) {
+        throw new errors_1.InvalidReadQueryError(`invalid Solana account IDL: ${error.message}`);
+    }
+}
+/** The IDL's own spelling of an account layout name given in any case style. */
+function resolveAccountName(idl, name) {
+    const accounts = idl.accounts ?? [];
+    const exact = accounts.find(a => a.name === name);
+    if (exact)
+        return exact.name;
+    const key = idlNameKey(name);
+    const matches = accounts.filter(a => idlNameKey(a.name) === key);
+    if (matches.length === 1)
+        return matches[0].name;
+    const known = accounts.map(a => a.name).join(', ') || 'none';
+    throw new errors_1.InvalidReadQueryError(matches.length > 1 ? `functionName ${name} is ambiguous in the IDL (${matches.map(a => a.name).join(', ')})` : `functionName ${name} is not an account in the IDL (accounts: ${known})`);
+}
+function hasDiscriminator(a, data) {
+    return data.length >= a.discriminator.length && a.discriminator.every((b, i) => data[i] === b);
+}
+/**
+ * Decode account bytes with the IDL. With `accountName`, the data's discriminator
+ * must match that layout; without it, the layout is the one whose discriminator
+ * prefixes the data.
+ */
+function decodeIdlAccount(idl, data, accountName) {
+    const accounts = idl.accounts ?? [];
+    let def;
+    if (accountName !== undefined) {
+        def = accounts.find(a => a.name === resolveAccountName(idl, accountName));
+        if (def && !hasDiscriminator(def, data)) {
+            throw new errors_1.ReadDecodeError(`account data discriminator does not match ${def.name}`);
+        }
+    }
+    else {
+        const found = accounts.filter(a => hasDiscriminator(a, data));
+        // Longest match wins if one discriminator prefixes another.
+        def = found.sort((x, y) => y.discriminator.length - x.discriminator.length)[0];
+        if (!def) {
+            const head = buffer_1.Buffer.from(data.subarray(0, 8)).toString('hex');
+            throw new errors_1.ReadDecodeError(`no IDL account discriminator matches the account data (0x${head})`);
+        }
+    }
+    if (!def)
+        throw new errors_1.ReadDecodeError('account not found in the IDL');
+    return { accountName: def.name, value: new anchor_1.BorshAccountsCoder(idl).decode(def.name, buffer_1.Buffer.from(data)) };
+}
+/** Inspect the mint owner; the chain alone cannot distinguish SPL Token and Token-2022. */
+async function detectTokenProgram(mint, chain, rpcUrls) {
+    const address = new web3_js_1.PublicKey(mint);
+    const urls = rpcUrls ?? chain_1.CHAIN_INFO[chain]?.defaultRPC;
+    if (!urls?.length)
+        throw new errors_1.InvalidReadQueryError(`no Solana RPC configured for ${chain}`);
+    let lastError;
+    for (const url of urls) {
+        let info;
+        try {
+            info = await new web3_js_1.Connection(url, 'finalized').getAccountInfo(address, 'finalized');
+        }
+        catch (error) {
+            lastError = error;
+            continue;
+        }
+        if (!info)
+            throw new errors_1.InvalidReadQueryError(`token mint does not exist: ${mint}`);
+        if (!info.owner.equals(svm_1.TOKEN_PROGRAM_ID) && !info.owner.equals(svm_1.TOKEN_2022_PROGRAM_ID)) {
+            throw new errors_1.InvalidReadQueryError('mint is not owned by SPL Token or Token-2022');
+        }
+        // Mint base layout: 82 bytes, initialized flag at byte 45. Token-2022
+        // extensions pad to 165 bytes and carry AccountType.Mint (1) at byte 165.
+        if (info.executable || info.data.length < 82 || info.data[45] !== 1 ||
+            (info.owner.equals(svm_1.TOKEN_PROGRAM_ID) && info.data.length !== 82) ||
+            (info.owner.equals(svm_1.TOKEN_2022_PROGRAM_ID) && info.data.length !== 82 &&
+                (info.data.length < 166 || info.data[165] !== 1))) {
+            throw new errors_1.InvalidReadQueryError('token address is not an initialized mint');
+        }
+        return info.owner;
+    }
+    throw lastError;
+}
+//# sourceMappingURL=svm-account.js.map

package/src/lib/read-state/svm-pda.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PDA derivation for `read(programId, { idl, functionName, args })`.
+ *
+ * The seed layout comes from the IDL, never from a guessed encoding: Anchor
+ * records each PDA's seeds on the instruction accounts that use it. `args` fill
+ * the non-constant seeds in order, encoded as the IDL declares them.
+ */
+import type { Idl } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+/** Derive the PDA of account layout `functionName` from its IDL seed template and positional `args`. */
+export declare function deriveIdlPda(idl: Idl, functionName: string, args?: readonly unknown[]): PublicKey;
+/** Whether `subject` is the IDL's program id (base58 or 0x-hex). */
+export declare function isProgramSubject(idl: Idl, subject: string): boolean;

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