@5ive-tech/sdk 1.1.10 → 1.1.13

package/README.md

@@ -13,7 +13,7 @@ npm install @5ive-tech/sdk @solana/web3.js
 ### 1) Compile to `.five`
 
 ```bash
-5ive compile src/main.v -o build/my-program.five
+5ive build
 ```
 
 ### 1b) Compile directly with SDK (optional)

package/dist/FiveSDK.d.ts

@@ -98,10 +98,7 @@ export declare class FiveSDK {
     static compile(source: FiveScriptSource | string, options?: CompilationOptions & {
         debug?: boolean;
     }): Promise<CompilationResult>;
-    static compileModules(mainSource: FiveScriptSource | string, modules: Array<{
-        name: string;
-        source: string;
-    }>, options?: CompilationOptions & {
+    static compileProject(projectPath?: string, options?: CompilationOptions & {
         debug?: boolean;
     }): Promise<CompilationResult>;
     static compileWithDiscovery(entryPoint: string, options?: CompilationOptions & {
@@ -175,6 +172,8 @@ export declare class FiveSDK {
             isWritable: boolean;
             isSystemAccount?: boolean;
         }>;
+        feeShardIndex?: number;
+        payerAccount?: string;
     }): Promise<SerializedExecution>;
     static getVMState(connection: any, fiveVMProgramId?: string): Promise<{
         authority: string;

package/dist/FiveSDK.js

@@ -1,6 +1,8 @@
 /**
  * Five SDK client for Five VM scripts.
  */
+import { dirname, isAbsolute, join, resolve, } from "path";
+import { readFile, } from "fs/promises";
 import { FiveSDKError, } from "./types.js";
 import { BytecodeCompiler } from "./compiler/BytecodeCompiler.js";
 import { ParameterEncoder } from "./encoding/ParameterEncoder.js";
@@ -16,6 +18,8 @@ import * as Accounts from "./modules/accounts.js";
 import * as StateDiff from "./modules/state-diff.js";
 import * as Namespaces from "./modules/namespaces.js";
 import * as Admin from "./modules/admin.js";
+import { parseToml } from "./project/toml.js";
+import { parseProjectConfig } from "./project/config.js";
 /**
  * Main Five SDK class - entry point for all Five VM interactions
  */
@@ -130,7 +134,11 @@ export class FiveSDK {
                     parameters: func.parameters?.map((param) => ({
                         name: param.name,
                         type: param.type,
+                        param_type: param.param_type,
                         optional: param.optional ?? false,
+                        is_account: param.is_account ?? param.isAccount ?? false,
+                        isAccount: param.isAccount ?? param.is_account ?? false,
+                        attributes: Array.isArray(param.attributes) ? [...param.attributes] : [],
                     })) || [],
                     returnType: func.returnType,
                 }));
@@ -155,16 +163,50 @@ export class FiveSDK {
             return result;
         }
         catch (error) {
-            throw new FiveSDKError(`Compilation failed: ${error instanceof Error ? error.message : "Unknown error"}`, "COMPILATION_ERROR");
+            if (error instanceof FiveSDKError) {
+                throw error;
+            }
+            const inheritedDetails = error && typeof error === "object" && error.details
+                ? error.details
+                : undefined;
+            throw new FiveSDKError(`Compilation failed: ${error instanceof Error ? error.message : "Unknown error"}`, "COMPILATION_ERROR", {
+                ...(inheritedDetails || {}),
+                cause: error instanceof Error ? error.message : String(error),
+            });
         }
     }
-    static async compileModules(mainSource, modules, options = {}) {
-        const mainSourceObj = typeof mainSource === 'string' ? { content: mainSource, filename: 'main.v' } : mainSource;
+    static async compileProject(projectPath = process.cwd(), options = {}) {
         Validators.options(options);
         await this.initializeComponents(options.debug);
-        if (!this.compiler)
+        if (!this.compiler) {
             throw new FiveSDKError("Compiler not initialized", "COMPILER_ERROR");
-        return this.compiler.compileModules(mainSourceObj, modules, options);
+        }
+        const normalizedProjectPath = isAbsolute(projectPath)
+            ? projectPath
+            : resolve(process.cwd(), projectPath);
+        const configPath = normalizedProjectPath.endsWith(".toml")
+            ? normalizedProjectPath
+            : join(normalizedProjectPath, "five.toml");
+        const rootDir = dirname(configPath);
+        const rawToml = await readFile(configPath, "utf8");
+        const parsed = parseToml(rawToml);
+        const projectConfig = parseProjectConfig(parsed);
+        if (!projectConfig.entryPoint) {
+            throw new FiveSDKError(`Missing required project.entry_point in ${configPath}`, "PROJECT_CONFIG_ERROR");
+        }
+        const entryPoint = isAbsolute(projectConfig.entryPoint)
+            ? projectConfig.entryPoint
+            : resolve(rootDir, projectConfig.entryPoint);
+        return this.compiler.compileWithDiscovery(entryPoint, {
+            ...options,
+            target: options.target || projectConfig.target || "vm",
+            optimizationLevel: options.optimizationLevel ||
+                projectConfig.optimizations?.optimizationLevel ||
+                "production",
+            includeMetrics: options.includeMetrics,
+            metricsFormat: options.metricsFormat || "json",
+            errorFormat: options.errorFormat || "terminal",
+        });
     }
     static async compileWithDiscovery(entryPoint, options = {}) {
         Validators.options(options);

package/dist/accounts/index.js

@@ -5,6 +5,7 @@
  * and account size calculations. Uses serialization instead of direct blockchain calls.
  */
 import { PDAUtils, SolanaPublicKeyUtils, RentCalculator, AccountValidator } from '../crypto/index.js';
+import { ProgramIdResolver } from '../config/ProgramIdResolver.js';
 /**
  * AccountType enum for test compatibility
  */
@@ -22,8 +23,8 @@ export const AccountType = {
  * Account manager for Five VM scripts (serialization-based)
  */
 export class FiveAccountManager {
-    constructor(programId = 'FiveProgramID11111111111111111111111111111') {
-        this.programId = programId;
+    constructor(programId) {
+        this.programId = ProgramIdResolver.resolve(programId);
     }
     /**
      * Encode System Program CreateAccount instruction

package/dist/assets/vm/five_vm_wasm_bg.wasm.d.ts

@@ -227,19 +227,19 @@ export const bytecodeencoder_encoded_size_u32: (a: number) => number;
 export const bytecodeencoder_encoded_size_u16: (a: number) => number;
 export const parameterencoder_encode_execute: (a: number, b: number, c: number) => void;
 export const get_wasm_compiler_info: () => number;
+export const __wbg_set_wasmsuggestion_confidence: (a: number, b: number) => void;
+export const __wbg_set_wasmenhancedcompilationresult_compilation_time: (a: number, b: number) => void;
+export const __wbg_set_wasmcompilationwithmetrics_compilation_time: (a: number, b: number) => void;
+export const __wbg_set_wasmcompilationresult_compilation_time: (a: number, b: number) => void;
 export const __wbg_get_wasmsuggestion_confidence: (a: number) => number;
 export const __wbg_get_wasmenhancedcompilationresult_compilation_time: (a: number) => number;
 export const __wbg_get_wasmcompilationwithmetrics_compilation_time: (a: number) => number;
 export const __wbg_get_wasmcompilationresult_compilation_time: (a: number) => number;
 export const __wbg_set_wasmenhancedcompilationresult_success: (a: number, b: number) => void;
 export const __wbg_get_wasmenhancedcompilationresult_success: (a: number) => number;
-export const __wbg_set_wasmsuggestion_confidence: (a: number, b: number) => void;
-export const __wbg_set_wasmenhancedcompilationresult_compilation_time: (a: number, b: number) => void;
-export const __wbg_set_wasmcompilationwithmetrics_compilation_time: (a: number, b: number) => void;
-export const __wbg_set_wasmcompilationresult_compilation_time: (a: number, b: number) => void;
 export const __wbg_wasmfivecompiler_free: (a: number, b: number) => void;
-export const __wbg_parameterencoder_free: (a: number, b: number) => void;
 export const __wbg_bytecodeencoder_free: (a: number, b: number) => void;
+export const __wbg_parameterencoder_free: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/dist/compiler/BytecodeCompiler.d.ts

@@ -26,13 +26,7 @@ export declare class BytecodeCompiler {
      * Compile Five script source to bytecode
      */
     compile(source: FiveScriptSource | string, options?: CompilationOptions): Promise<CompilationResult>;
-    /**
-     * Compile multiple modules (entry + dependencies)
-     */
-    compileModules(mainSource: FiveScriptSource, modules: Array<{
-        name: string;
-        source: string;
-    }>, options?: CompilationOptions): Promise<CompilationResult>;
+    compileWithDiscovery(entryPoint: string, options?: CompilationOptions): Promise<CompilationResult>;
     /**
      * Compile script from file path
      */

package/dist/compiler/BytecodeCompiler.js

@@ -39,6 +39,7 @@ export class BytecodeCompiler {
                 debug: options.debug || false,
                 maxSize: options.maxSize || 1048576, // 1MB default
                 optimizationLevel: options.optimizationLevel || "production", // Default to Production
+                sourceFile: sourceFilename,
                 // Pass through metrics options
                 metricsFormat: options.metricsFormat,
                 metricsOutput: options.metricsOutput,
@@ -87,7 +88,7 @@ export class BytecodeCompiler {
                 };
             }
             else {
-                const errors = this.transformErrors(result.errors || []);
+                const errors = this.transformErrors(result.diagnostics || result.errors || []);
                 if (this.debug) {
                     console.log(`[BytecodeCompiler] Compilation failed with ${errors.length} errors`);
                     errors.forEach((error) => {
@@ -97,74 +98,96 @@ export class BytecodeCompiler {
                 return {
                     success: false,
                     errors,
+                    diagnostics: errors,
+                    formattedErrorsTerminal: result.formattedErrorsTerminal,
+                    formattedErrorsJson: result.formattedErrorsJson,
                     metricsReport: result.metricsReport,
                 };
             }
         }
         catch (error) {
-            throw new CompilationSDKError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, { source: sourceContent.substring(0, 200), options });
+            if (error instanceof CompilationSDKError) {
+                throw error;
+            }
+            const inheritedDetails = error && typeof error === "object" && error.details
+                ? error.details
+                : undefined;
+            throw new CompilationSDKError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, {
+                ...(inheritedDetails || {}),
+                source: sourceContent.substring(0, 200),
+                options,
+            });
         }
     }
-    /**
-     * Compile multiple modules (entry + dependencies)
-     */
-    async compileModules(mainSource, modules, options = {}) {
+    async compileWithDiscovery(entryPoint, options = {}) {
         const startTime = Date.now();
         try {
             if (!this.wasmCompiler) {
                 await this.loadWasmCompiler();
             }
-            if (!this.wasmCompiler?.compile_multi) {
-                throw new CompilationSDKError("Multi-file compilation is not supported in this build");
+            if (!this.wasmCompiler?.compileWithDiscovery) {
+                throw new CompilationSDKError("Compiler discovery API is not supported in this build");
             }
-            const compilerOptions = {
-                optimize: options.optimize || false,
-                target: options.target || "vm",
-                debug: options.debug || false,
-                maxSize: options.maxSize || 1048576,
-                optimizationLevel: options.optimizationLevel || "production",
-                includeMetrics: options.includeMetrics || options.metricsOutput !== undefined,
-                metricsFormat: options.metricsFormat || "json",
-                errorFormat: options.errorFormat || "terminal",
-                comprehensiveMetrics: options.comprehensiveMetrics || false,
-            };
-            const result = await this.wasmCompiler.compile_multi(mainSource.content, modules, compilerOptions);
+            const result = await this.wasmCompiler.compileWithDiscovery(entryPoint, {
+                ...options,
+                sourceFile: entryPoint,
+            });
             const compilationTime = Date.now() - startTime;
             if (result.success && result.bytecode) {
                 const compilerInfo = await this.getCompilerInfo();
+                let abiData = result.abi;
+                if (!abiData) {
+                    abiData = await this.generateABI(typeof entryPoint === 'string' ? await readFile(entryPoint, 'utf8') : entryPoint);
+                }
+                const normalizedFunctions = normalizeAbiFunctions(abiData?.functions ?? abiData);
+                const normalizedAbi = {
+                    ...abiData,
+                    functions: normalizedFunctions,
+                };
                 return {
                     success: true,
                     bytecode: result.bytecode,
-                    abi: result.abi,
+                    abi: normalizedAbi,
                     disassembly: result.disassembly || [],
                     metadata: {
-                        sourceFile: mainSource.filename || 'main.v',
+                        sourceFile: entryPoint,
                         timestamp: new Date().toISOString(),
-                        compilerVersion: compilerInfo.version || '1.0.0',
-                        target: (options.target || 'vm'),
+                        compilerVersion: compilerInfo.version || "1.0.0",
+                        target: (options.target || "vm"),
                         optimizations: [],
-                        originalSize: mainSource.content.length,
+                        originalSize: 0,
                         compressedSize: result.bytecode.length,
                         compressionRatio: 1.0,
-                        sourceSize: mainSource.content.length,
+                        sourceSize: 0,
                         bytecodeSize: result.bytecode.length,
-                        functions: [],
+                        functions: this.extractFunctions(normalizedAbi),
                         compilationTime,
                     },
                     metricsReport: result.metricsReport,
                 };
             }
-            else {
-                const errors = this.transformErrors(result.errors || result.compiler_errors || []);
-                return {
-                    success: false,
-                    errors,
-                    metricsReport: result.metricsReport,
-                };
-            }
+            const errors = this.transformErrors(result.diagnostics || result.errors || []);
+            return {
+                success: false,
+                errors,
+                diagnostics: errors,
+                formattedErrorsTerminal: result.formattedErrorsTerminal,
+                formattedErrorsJson: result.formattedErrorsJson,
+                metricsReport: result.metricsReport,
+            };
         }
         catch (error) {
-            throw new CompilationSDKError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, { options });
+            if (error instanceof CompilationSDKError) {
+                throw error;
+            }
+            const inheritedDetails = error && typeof error === "object" && error.details
+                ? error.details
+                : undefined;
+            throw new CompilationSDKError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, {
+                ...(inheritedDetails || {}),
+                entryPoint,
+                options,
+            });
         }
     }
     /**
@@ -176,7 +199,13 @@ export class BytecodeCompiler {
         }
         try {
             const source = await readFile(filePath, "utf-8");
-            return this.compile(source, options);
+            return this.compile({
+                filename: filePath,
+                content: source,
+            }, {
+                ...options,
+                sourceFile: filePath,
+            });
         }
         catch (error) {
             throw new CompilationSDKError(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`, { filePath, options });
@@ -282,13 +311,45 @@ export class BytecodeCompiler {
      * Transform compiler errors to SDK format
      */
     transformErrors(errors) {
-        return errors.map((error) => ({
-            type: 'compiler',
-            message: error.message || error.toString(),
-            line: error.line,
-            column: error.column,
-            severity: error.severity || "error",
-        }));
+        return errors.map((error) => {
+            const normalized = typeof error === "string" ? { message: error } : (error || {});
+            const location = normalized.location || {};
+            const lineValue = normalized.line ?? location.line;
+            const columnValue = normalized.column ?? location.column;
+            const line = typeof lineValue === "number"
+                ? lineValue
+                : typeof lineValue === "string"
+                    ? Number(lineValue)
+                    : undefined;
+            const column = typeof columnValue === "number"
+                ? columnValue
+                : typeof columnValue === "string"
+                    ? Number(columnValue)
+                    : undefined;
+            return {
+                type: normalized.type || "compiler",
+                message: normalized.message || String(error),
+                line: Number.isFinite(line) ? line : undefined,
+                column: Number.isFinite(column) ? column : undefined,
+                severity: normalized.severity || "error",
+                code: normalized.code,
+                category: normalized.category,
+                description: normalized.description,
+                location: normalized.location,
+                sourceLocation: normalized.sourceLocation || location.file,
+                suggestion: normalized.suggestion ||
+                    (Array.isArray(normalized.suggestions) && normalized.suggestions.length > 0
+                        ? typeof normalized.suggestions[0] === "string"
+                            ? normalized.suggestions[0]
+                            : normalized.suggestions[0]?.message
+                        : undefined),
+                suggestions: normalized.suggestions,
+                sourceLine: normalized.sourceLine || normalized.source_line,
+                sourceSnippet: normalized.sourceSnippet || normalized.source_snippet,
+                rendered: normalized.rendered,
+                raw: normalized.raw || error,
+            };
+        });
     }
     /**
      * Extract function definitions from ABI

package/dist/config/ProgramIdResolver.d.ts

@@ -1,12 +1,7 @@
 /**
  * Centralized program ID resolution for Five SDK.
- * Implements consistent precedence: explicit → default → env → baked → error
+ * Implements strict precedence: explicit → SDK default → cluster config → error
  */
-/**
- * Baked program ID injected at release time (set by scripts/set-default-program-id.sh)
- * Empty string by default; overridden in npm published packages.
- */
-export declare const FIVE_BAKED_PROGRAM_ID = "4Qxf3pbCse2veUgZVMiAm3nWqJrYo2pT4suxHKMJdK1d";
 /**
  * Centralized resolver for program IDs across all SDK operations.
  * Ensures consistent validation and error messaging.

package/dist/config/ProgramIdResolver.js

@@ -1,13 +1,9 @@
 /**
  * Centralized program ID resolution for Five SDK.
- * Implements consistent precedence: explicit → default → env → baked → error
+ * Implements strict precedence: explicit → SDK default → cluster config → error
  */
 import { validator } from '../validation/index.js';
-/**
- * Baked program ID injected at release time (set by scripts/set-default-program-id.sh)
- * Empty string by default; overridden in npm published packages.
- */
-export const FIVE_BAKED_PROGRAM_ID = '4Qxf3pbCse2veUgZVMiAm3nWqJrYo2pT4suxHKMJdK1d';
+import { VmClusterConfigResolver } from './VmClusterConfigResolver.js';
 /**
  * Centralized resolver for program IDs across all SDK operations.
  * Ensures consistent validation and error messaging.
@@ -49,8 +45,7 @@ export class ProgramIdResolver {
      * ```
      */
     static resolve(explicit, options) {
-        // Precedence: explicit → default → env → baked
-        // Note: Must check for explicit empty string differently from undefined
+        // Precedence: explicit → default → cluster-config
         let resolved;
         if (explicit) {
             resolved = explicit;
@@ -58,20 +53,20 @@ export class ProgramIdResolver {
         else if (this.defaultProgramId) {
             resolved = this.defaultProgramId;
         }
-        else if (process.env.FIVE_PROGRAM_ID) {
-            resolved = process.env.FIVE_PROGRAM_ID;
-        }
-        else if (FIVE_BAKED_PROGRAM_ID) {
-            resolved = FIVE_BAKED_PROGRAM_ID;
+        else {
+            try {
+                resolved = VmClusterConfigResolver.loadClusterConfig().programId;
+            }
+            catch {
+                resolved = undefined;
+            }
         }
         if (!resolved && !options?.allowUndefined) {
             throw new Error(`No program ID resolved for Five VM. ` +
                 `Set via one of: ` +
                 `(1) explicit call parameter, ` +
                 `(2) FiveSDK.setDefaultProgramId(), ` +
-                `(3) FIVE_PROGRAM_ID environment variable, ` +
-                `(4) released package default. ` +
-                `For setup guidance, see: https://docs.five.build/cli/program-id-setup`);
+                `(3) five-solana/constants.vm.toml cluster profile.`);
         }
         if (resolved) {
             validator.validateBase58Address(resolved, 'programId');

package/dist/config/VmClusterConfigResolver.d.ts

@@ -0,0 +1,27 @@
+export interface VmClusterProfile {
+    cluster: 'localnet' | 'devnet' | 'mainnet';
+    configPath: string;
+    programId: string;
+    feeVaultShardCount: number;
+}
+export interface VmClusterAddresses {
+    cluster: VmClusterProfile['cluster'];
+    programId: string;
+    feeVaultShardCount: number;
+    vmStatePda: string;
+    vmStateBump: number;
+    feeVaultPdas: Array<{
+        shardIndex: number;
+        address: string;
+        bump: number;
+    }>;
+}
+export declare class VmClusterConfigResolver {
+    static resolveClusterFromEnvOrDefault(): VmClusterProfile['cluster'];
+    static getDefaultConfigPath(): string;
+    static loadClusterConfig(input?: {
+        cluster?: string;
+        configPath?: string;
+    }): VmClusterProfile;
+    static deriveVmAddresses(profile: VmClusterProfile): VmClusterAddresses;
+}

package/dist/config/VmClusterConfigResolver.js

@@ -0,0 +1,111 @@
+import fs from 'fs';
+import path from 'path';
+import { PublicKey } from '@solana/web3.js';
+const VM_STATE_SEED = Buffer.from('vm_state', 'utf-8');
+const FEE_VAULT_SEED = Buffer.from([
+    0xff, 0x66, 0x69, 0x76, 0x65, 0x5f, 0x76, 0x6d, 0x5f, 0x66, 0x65, 0x65,
+    0x5f, 0x76, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x76, 0x31,
+]);
+const VALID_CLUSTERS = new Set(['localnet', 'devnet', 'mainnet']);
+function resolveDefaultConfigPath() {
+    if (process.env.FIVE_VM_CONSTANTS_CONFIG) {
+        return path.resolve(process.env.FIVE_VM_CONSTANTS_CONFIG);
+    }
+    const candidates = [
+        path.resolve(process.cwd(), 'five-solana/constants.vm.toml'),
+        path.resolve(process.cwd(), '../five-solana/constants.vm.toml'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function parseSimpleVmToml(raw) {
+    const clusters = {};
+    let current = null;
+    for (const lineRaw of raw.split('\n')) {
+        const line = lineRaw.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const sec = line.match(/^\[clusters\.(localnet|devnet|mainnet)\]$/);
+        if (sec) {
+            current = sec[1];
+            clusters[current] = {};
+            continue;
+        }
+        if (!current)
+            continue;
+        const kv = line.match(/^([a-z_]+)\s*=\s*(.+)$/);
+        if (!kv)
+            continue;
+        const key = kv[1];
+        const rawVal = kv[2].trim();
+        if (rawVal.startsWith('"') && rawVal.endsWith('"')) {
+            clusters[current][key] = rawVal.slice(1, -1);
+        }
+        else if (/^\d+$/.test(rawVal)) {
+            clusters[current][key] = Number(rawVal);
+        }
+        else {
+            throw new Error(`Unsupported TOML value: ${line}`);
+        }
+    }
+    return { clusters };
+}
+export class VmClusterConfigResolver {
+    static resolveClusterFromEnvOrDefault() {
+        const cluster = (process.env.FIVE_VM_CLUSTER || 'localnet').trim();
+        if (!VALID_CLUSTERS.has(cluster)) {
+            throw new Error(`Invalid FIVE_VM_CLUSTER: ${cluster} (expected localnet|devnet|mainnet)`);
+        }
+        return cluster;
+    }
+    static getDefaultConfigPath() {
+        return resolveDefaultConfigPath();
+    }
+    static loadClusterConfig(input = {}) {
+        const cluster = (input.cluster || this.resolveClusterFromEnvOrDefault()).trim();
+        if (!VALID_CLUSTERS.has(cluster)) {
+            throw new Error(`Invalid cluster: ${cluster}`);
+        }
+        const configPath = path.resolve(input.configPath || this.getDefaultConfigPath());
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`VM constants config not found: ${configPath}`);
+        }
+        const parsed = parseSimpleVmToml(fs.readFileSync(configPath, 'utf-8'));
+        const entry = parsed.clusters?.[cluster];
+        if (!entry)
+            throw new Error(`Cluster missing in VM constants config: ${cluster}`);
+        if (!entry.program_id)
+            throw new Error(`Missing program_id for cluster ${cluster}`);
+        if (!Number.isInteger(entry.fee_vault_shard_count) || entry.fee_vault_shard_count < 1) {
+            throw new Error(`Invalid fee_vault_shard_count for cluster ${cluster}`);
+        }
+        const programId = new PublicKey(entry.program_id).toBase58();
+        return {
+            cluster: cluster,
+            configPath,
+            programId,
+            feeVaultShardCount: entry.fee_vault_shard_count,
+        };
+    }
+    static deriveVmAddresses(profile) {
+        const programPk = new PublicKey(profile.programId);
+        const [vmStatePda, vmStateBump] = PublicKey.findProgramAddressSync([VM_STATE_SEED], programPk);
+        const feeVaultPdas = [];
+        for (let i = 0; i < profile.feeVaultShardCount; i++) {
+            const [vault, bump] = PublicKey.findProgramAddressSync([FEE_VAULT_SEED, Buffer.from([i])], programPk);
+            feeVaultPdas.push({ shardIndex: i, address: vault.toBase58(), bump });
+        }
+        return {
+            cluster: profile.cluster,
+            programId: profile.programId,
+            feeVaultShardCount: profile.feeVaultShardCount,
+            vmStatePda: vmStatePda.toBase58(),
+            vmStateBump,
+            feeVaultPdas,
+        };
+    }
+}

package/dist/index.d.ts

@@ -17,5 +17,5 @@ export * from './wasm/loader.js';
 export * from './testing/index.js';
 export * from './program/index.js';
 export * from './modules/namespaces.js';
-export { ProgramIdResolver, FIVE_BAKED_PROGRAM_ID } from './config/ProgramIdResolver.js';
+export { ProgramIdResolver } from './config/ProgramIdResolver.js';
 export { FIVE_VM_PROGRAM_ID } from './types.js';

package/dist/index.js

@@ -21,7 +21,7 @@ export * from './testing/index.js';
 export * from './program/index.js';
 export * from './modules/namespaces.js';
 // ==================== Program ID Resolution ====================
-export { ProgramIdResolver, FIVE_BAKED_PROGRAM_ID } from './config/ProgramIdResolver.js';
+export { ProgramIdResolver } from './config/ProgramIdResolver.js';
 // ==================== Constants ====================
 export { FIVE_VM_PROGRAM_ID } from './types.js';
 // Default export disabled for minimal build

package/dist/modules/accounts.js

@@ -2,6 +2,7 @@ import { ScriptMetadataParser } from "../metadata/index.js";
 import { normalizeAbiFunctions } from "../utils/abi.js";
 import { loadWasmVM } from "../wasm/instance.js";
 import { SolanaPublicKeyUtils } from "../crypto/index.js";
+import { getAccountInfoWithRetry } from "../utils/transaction.js";
 export async function fetchAccountAndDeserialize(accountAddress, connection, // Solana Connection object
 options = {}) {
     try {
@@ -27,7 +28,12 @@ options = {}) {
                 logs: [],
             };
         }
-        const accountInfo = await connection.getAccountInfo(accountPubkey, "confirmed");
+        const accountInfo = await getAccountInfoWithRetry(connection, accountPubkey, {
+            commitment: "finalized",
+            retries: 2,
+            delayMs: 1000,
+            debug: options.debug,
+        });
         if (!accountInfo) {
             return {
                 success: false,