@5ive-tech/sdk 1.1.13 → 1.1.15

package/README.md

@@ -2,12 +2,34 @@
 
 Client-agnostic TypeScript SDK for interacting with 5ive DSL programs on Solana.
 
+## Mainnet Program ID
+
+**Program**: `5ive58PJUPaTyAe7tvU1bvBi25o7oieLLTRsJDoQNJst`
+
+The Five VM is deployed and running on Solana mainnet. Use this program ID for production applications.
+
 ## Install
 
 ```bash
 npm install @5ive-tech/sdk @solana/web3.js
 ```
 
+## Localnet Validator Integration Test
+
+The localnet integration suite is intentionally environment-gated. Before running:
+
+1. Rebuild the localnet SBF artifact:
+   - `./scripts/build-five-solana-cluster.sh --cluster localnet`
+2. Start a local validator and deploy the rebuilt localnet-compatible program.
+3. Export the deployed VM program id:
+   - `export FIVE_VM_PROGRAM_ID=<local-program-id>`
+
+Then run:
+
+```bash
+npm run test:localnet
+```
+
 ## Quick Start
 
 ### 1) Compile to `.five`

package/dist/FiveSDK.d.ts

@@ -5,6 +5,25 @@ import { FiveSDKConfig, FiveScriptSource, FiveBytecode, CompilationOptions, Comp
 import { ScriptMetadata } from "./metadata/index.js";
 import * as Namespaces from "./modules/namespaces.js";
 import * as Admin from "./modules/admin.js";
+export type ExecuteAccountMetadata = Map<string, {
+    isSigner: boolean;
+    isWritable: boolean;
+    isSystemAccount?: boolean;
+}>;
+export interface ExecuteOnSolanaOptions {
+    debug?: boolean;
+    network?: string;
+    computeUnitLimit?: number;
+    computeUnitPrice?: number;
+    maxRetries?: number;
+    skipPreflight?: boolean;
+    vmStateAccount?: string;
+    fiveVMProgramId?: string;
+    abi?: any;
+    accountMetadata?: ExecuteAccountMetadata;
+    feeShardIndex?: number;
+    payerAccount?: string;
+}
 /**
  * Main Five SDK class - entry point for all Five VM interactions
  */
@@ -95,6 +114,29 @@ export declare class FiveSDK {
         resolvedScript?: string;
         bindingAddress: string;
     }>;
+    static setNamespaceSymbolPriceOnChain(symbol: string, priceLamports: number, options: {
+        managerScriptAccount: string;
+        connection: any;
+        signerKeypair: any;
+        fiveVMProgramId?: string;
+        debug?: boolean;
+    }): Promise<{
+        transactionId?: string;
+        symbol: Namespaces.ScopedNamespace["symbol"];
+        priceLamports: number;
+    }>;
+    static getNamespaceSymbolPriceOnChain(symbol: string, options: {
+        managerScriptAccount: string;
+        connection: any;
+        signerKeypair: any;
+        fiveVMProgramId?: string;
+        debug?: boolean;
+    }): Promise<{
+        transactionId?: string;
+        symbol: Namespaces.ScopedNamespace["symbol"];
+        priceLamports: number;
+        priceSol: number;
+    }>;
     static compile(source: FiveScriptSource | string, options?: CompilationOptions & {
         debug?: boolean;
     }): Promise<CompilationResult>;
@@ -209,7 +251,7 @@ export declare class FiveSDK {
     static getCachedScriptMetadata(scriptAccount: string, connection: any, cacheTTL?: number): Promise<ScriptMetadata>;
     static invalidateMetadataCache(scriptAccount: string): void;
     static getMetadataCacheStats(): any;
-    static executeOnSolana(scriptAccount: string, connection: any, signerKeypair: any, functionName: string | number, parameters?: any[], accounts?: string[], options?: any): Promise<{
+    static executeOnSolana(scriptAccount: string, connection: any, signerKeypair: any, functionName: string | number, parameters?: any[], accounts?: string[], options?: ExecuteOnSolanaOptions): Promise<{
         success: boolean;
         result?: any;
         transactionId?: string;

package/dist/FiveSDK.js

@@ -105,6 +105,12 @@ export class FiveSDK {
     static async resolveNamespaceOnChain(namespaceValue, options) {
         return Namespaces.resolveNamespaceOnChain(namespaceValue, options);
     }
+    static async setNamespaceSymbolPriceOnChain(symbol, priceLamports, options) {
+        return Namespaces.setNamespaceSymbolPriceOnChain(symbol, priceLamports, options);
+    }
+    static async getNamespaceSymbolPriceOnChain(symbol, options) {
+        return Namespaces.getNamespaceSymbolPriceOnChain(symbol, options);
+    }
     // ==================== Script Compilation ====================
     static async compile(source, options = {}) {
         const sourceContent = typeof source === 'string' ? source : source.content;

package/dist/accounts/index.d.ts

@@ -105,19 +105,14 @@ export interface AccountValidationResult {
 /**
  * Account creation parameters
  */
-export interface CreateAccountParams {
-    /** Account size in bytes */
-    size: number;
-    /** Owner program ID */
-    owner: string;
-    /** Whether to make rent-exempt */
-    rentExempt: boolean;
-    /** Additional lamports beyond rent exemption */
-    additionalLamports?: number;
+export interface ProvisioningPlan {
+    address: string;
+    bump: number;
+    rentLamports: number;
+    creationMode: 'program_init_required';
+    ownerProgramId: string;
+    createInstruction: null;
 }
-/**
- * Solana transaction instruction interface
- */
 export interface TransactionInstruction {
     /** Program ID to invoke */
     programId: string;
@@ -136,10 +131,7 @@ export interface TransactionInstruction {
 export declare class FiveAccountManager {
     private programId;
     constructor(programId?: string);
-    /**
-     * Encode System Program CreateAccount instruction
-     */
-    private encodeCreateAccountInstruction;
+    private serializeInstruction;
     /**
      * Create script account PDA and return serialized instruction
      */
@@ -152,21 +144,11 @@ export declare class FiveAccountManager {
     /**
      * Create metadata account for script
      */
-    createMetadataAccount(scriptAccount: string, payerAddress: string): Promise<{
-        address: string;
-        bump: number;
-        createInstruction: TransactionInstruction;
-        rentLamports: number;
-    }>;
+    createMetadataAccount(scriptAccount: string, _payerAddress: string): Promise<ProvisioningPlan>;
     /**
      * Create user state account for script interaction
      */
-    createUserStateAccount(userPublicKey: string, scriptAccount: string): Promise<{
-        address: string;
-        bump: number;
-        createInstruction: any;
-        rentLamports: number;
-    }>;
+    createUserStateAccount(userPublicKey: string, scriptAccount: string): Promise<ProvisioningPlan>;
     /**
      * Validate account constraints for script execution
      */

package/dist/accounts/index.js

@@ -6,6 +6,7 @@
  */
 import { PDAUtils, SolanaPublicKeyUtils, RentCalculator, AccountValidator } from '../crypto/index.js';
 import { ProgramIdResolver } from '../config/ProgramIdResolver.js';
+import { PublicKey, SystemProgram } from '@solana/web3.js';
 /**
  * AccountType enum for test compatibility
  */
@@ -26,44 +27,35 @@ export class FiveAccountManager {
     constructor(programId) {
         this.programId = ProgramIdResolver.resolve(programId);
     }
-    /**
-     * Encode System Program CreateAccount instruction
-     */
-    encodeCreateAccountInstruction(params) {
-        // Encoding for CreateAccount instruction
-        // In a real implementation, this would use proper Solana instruction encoding
-        const buffer = new ArrayBuffer(32);
-        const view = new DataView(buffer);
-        // Instruction discriminator for CreateAccount (0)
-        view.setUint32(0, 0, true);
-        // Account size
-        view.setUint32(4, params.size, true);
-        // Rent lamports (calculated)
-        const rentLamports = params.rentExempt ? RentCalculator.calculateRentExemption(params.size) : 0;
-        view.setBigUint64(8, BigInt(rentLamports), true);
-        // Owner program ID would be encoded here in real implementation
-        // Return the basic instruction data
-        return new Uint8Array(buffer);
+    serializeInstruction(instruction) {
+        return {
+            programId: instruction.programId.toBase58(),
+            accounts: instruction.keys.map((key) => ({
+                pubkey: key.pubkey.toBase58(),
+                isSigner: key.isSigner,
+                isWritable: key.isWritable,
+            })),
+            data: new Uint8Array(instruction.data),
+        };
     }
     /**
      * Create script account PDA and return serialized instruction
      */
     async createScriptAccount(bytecode, payerAddress) {
-        const pda = await PDAUtils.deriveScriptAccount(bytecode, this.programId);
+        const pda = await PDAUtils.deriveScriptAccount(bytecode, payerAddress, this.programId);
         const rentLamports = RentCalculator.getScriptAccountRent(bytecode.length);
-        // Create serialized instruction for System Program CreateAccount
-        const createInstruction = {
-            programId: '11111111111111111111111111111112', // System Program
-            accounts: [
-                { pubkey: payerAddress, isSigner: true, isWritable: true },
-                { pubkey: pda.address, isSigner: false, isWritable: true }
-            ],
-            data: this.encodeCreateAccountInstruction({
-                size: bytecode.length + 256, // Bytecode + metadata
-                owner: this.programId,
-                rentExempt: true
-            })
-        };
+        const payerPubkey = new PublicKey(payerAddress);
+        const scriptPubkey = new PublicKey(pda.address);
+        const programPubkey = new PublicKey(this.programId);
+        const createInstruction = this.serializeInstruction(SystemProgram.createAccountWithSeed({
+            fromPubkey: payerPubkey,
+            newAccountPubkey: scriptPubkey,
+            basePubkey: payerPubkey,
+            seed: pda.seed,
+            lamports: rentLamports,
+            space: bytecode.length + 256,
+            programId: programPubkey,
+        }));
         return {
             address: pda.address,
             bump: pda.bump,
@@ -74,26 +66,16 @@ export class FiveAccountManager {
     /**
      * Create metadata account for script
      */
-    async createMetadataAccount(scriptAccount, payerAddress) {
+    async createMetadataAccount(scriptAccount, _payerAddress) {
         const pda = await PDAUtils.deriveMetadataAccount(scriptAccount, this.programId);
         const rentLamports = RentCalculator.getMetadataAccountRent();
-        const createInstruction = {
-            programId: '11111111111111111111111111111112', // System Program
-            accounts: [
-                { pubkey: payerAddress, isSigner: true, isWritable: true },
-                { pubkey: pda.address, isSigner: false, isWritable: true }
-            ],
-            data: this.encodeCreateAccountInstruction({
-                size: 1024, // 1KB for metadata
-                owner: this.programId,
-                rentExempt: true
-            })
-        };
         return {
             address: pda.address,
             bump: pda.bump,
-            createInstruction,
-            rentLamports
+            rentLamports,
+            creationMode: 'program_init_required',
+            ownerProgramId: this.programId,
+            createInstruction: null,
         };
     }
     /**
@@ -105,20 +87,10 @@ export class FiveAccountManager {
         return {
             address: pda.address,
             bump: pda.bump,
-            createInstruction: {
-                programId: '11111111111111111111111111111112', // System Program
-                accounts: [
-                    { pubkey: pda.address, isSigner: false, isWritable: true },
-                    { pubkey: userPublicKey, isSigner: true, isWritable: true },
-                    { pubkey: this.programId, isSigner: false, isWritable: false }
-                ],
-                data: this.encodeCreateAccountInstruction({
-                    size: 512, // 512 bytes for user state
-                    owner: this.programId,
-                    rentExempt: true
-                })
-            },
-            rentLamports
+            rentLamports,
+            creationMode: 'program_init_required',
+            ownerProgramId: this.programId,
+            createInstruction: null,
         };
     }
     /**

package/dist/assets/vm/five_vm_wasm.d.ts

@@ -280,6 +280,10 @@ export class WasmCompilationOptions {
      * Enable or disable debug information
      */
     with_debug_info(enabled: boolean): WasmCompilationOptions;
+    /**
+     * Enable or disable REQUIRE_BATCH lowering.
+     */
+    with_disable_require_batch(enabled: boolean): WasmCompilationOptions;
     /**
      * Enable or disable enhanced error reporting
      */
@@ -348,6 +352,10 @@ export class WasmCompilationOptions {
      * Enable bytecode compression
      */
     compress_output: boolean;
+    /**
+     * Disable REQUIRE_BATCH lowering in compiler pipeline.
+     */
+    disable_require_batch: boolean;
     /**
      * Enable constraint caching optimization
      */

package/dist/assets/vm/five_vm_wasm.js

@@ -924,6 +924,14 @@ class WasmCompilationOptions {
         const ret = wasm.__wbg_get_wasmcompilationoptions_compress_output(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Disable REQUIRE_BATCH lowering in compiler pipeline.
+     * @returns {boolean}
+     */
+    get disable_require_batch() {
+        const ret = wasm.__wbg_get_wasmcompilationoptions_disable_require_batch(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Enable constraint caching optimization
      * @returns {boolean}
@@ -1025,6 +1033,13 @@ class WasmCompilationOptions {
     set compress_output(arg0) {
         wasm.__wbg_set_wasmcompilationoptions_compress_output(this.__wbg_ptr, arg0);
     }
+    /**
+     * Disable REQUIRE_BATCH lowering in compiler pipeline.
+     * @param {boolean} arg0
+     */
+    set disable_require_batch(arg0) {
+        wasm.__wbg_set_wasmcompilationoptions_disable_require_batch(this.__wbg_ptr, arg0);
+    }
     /**
      * Enable constraint caching optimization
      * @param {boolean} arg0
@@ -1323,6 +1338,16 @@ class WasmCompilationOptions {
         const ret = wasm.wasmcompilationoptions_with_debug_info(ptr, enabled);
         return WasmCompilationOptions.__wrap(ret);
     }
+    /**
+     * Enable or disable REQUIRE_BATCH lowering.
+     * @param {boolean} enabled
+     * @returns {WasmCompilationOptions}
+     */
+    with_disable_require_batch(enabled) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.wasmcompilationoptions_with_disable_require_batch(ptr, enabled);
+        return WasmCompilationOptions.__wrap(ret);
+    }
     /**
      * Enable or disable enhanced error reporting
      * @param {boolean} enabled

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

@@ -116,6 +116,8 @@ export const __wbg_get_wasmcompilationoptions_compress_output: (a: number) => nu
 export const __wbg_set_wasmcompilationoptions_compress_output: (a: number, b: number) => void;
 export const __wbg_get_wasmcompilationoptions_enable_module_namespaces: (a: number) => number;
 export const __wbg_set_wasmcompilationoptions_enable_module_namespaces: (a: number, b: number) => void;
+export const __wbg_get_wasmcompilationoptions_disable_require_batch: (a: number) => number;
+export const __wbg_set_wasmcompilationoptions_disable_require_batch: (a: number, b: number) => void;
 export const wasmcompilationoptions_new: () => number;
 export const wasmcompilationoptions_with_mode: (a: number, b: number, c: number) => number;
 export const wasmcompilationoptions_with_optimization_level: (a: number, b: number, c: number) => number;
@@ -137,6 +139,7 @@ export const wasmcompilationoptions_with_export_format: (a: number, b: number, c
 export const wasmcompilationoptions_with_debug_info: (a: number, b: number) => number;
 export const wasmcompilationoptions_with_compression: (a: number, b: number) => number;
 export const wasmcompilationoptions_with_module_namespaces: (a: number, b: number) => number;
+export const wasmcompilationoptions_with_disable_require_batch: (a: number, b: number) => number;
 export const wasmcompilationoptions_production_optimized: () => number;
 export const wasmcompilationoptions_development_debug: () => number;
 export const wasmcompilationoptions_fast_iteration: () => number;

package/dist/compiler/BytecodeCompiler.js

@@ -9,6 +9,7 @@
 import { readFile } from "fs/promises";
 import { CompilationSDKError, } from "../types.js";
 import { normalizeAbiFunctions } from "../utils/abi.js";
+import { normalizeWasmCompilerSource } from "./source-normalization.js";
 /**
  * Bytecode compiler for Five scripts
  */
@@ -25,6 +26,7 @@ export class BytecodeCompiler {
     async compile(source, options = {}) {
         const startTime = Date.now();
         const sourceContent = typeof source === 'string' ? source : source.content;
+        const normalizedSourceContent = normalizeWasmCompilerSource(sourceContent);
         const sourceFilename = typeof source === 'string' ? 'unknown.v' : source.filename || 'unknown.v';
         // Compile source (debug info available in this.debug mode)
         try {
@@ -38,7 +40,7 @@ export class BytecodeCompiler {
                 target: options.target || "vm",
                 debug: options.debug || false,
                 maxSize: options.maxSize || 1048576, // 1MB default
-                optimizationLevel: options.optimizationLevel || "production", // Default to Production
+                optimizationLevel: "production", // Public SDK surface is locked to production
                 sourceFile: sourceFilename,
                 // Pass through metrics options
                 metricsFormat: options.metricsFormat,
@@ -48,7 +50,7 @@ export class BytecodeCompiler {
                 comprehensiveMetrics: options.comprehensiveMetrics,
             };
             // Perform compilation
-            const result = await this.wasmCompiler.compile(sourceContent, compilerOptions);
+            const result = await this.wasmCompiler.compile(normalizedSourceContent, compilerOptions);
             const compilationTime = Date.now() - startTime;
             if (result.success && result.bytecode) {
                 let abiData = result.abi;
@@ -114,7 +116,7 @@ export class BytecodeCompiler {
                 : undefined;
             throw new CompilationSDKError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, {
                 ...(inheritedDetails || {}),
-                source: sourceContent.substring(0, 200),
+                source: normalizedSourceContent.substring(0, 200),
                 options,
             });
         }
@@ -216,6 +218,7 @@ export class BytecodeCompiler {
      */
     async validateSource(source) {
         const code = typeof source === 'string' ? source : source.content;
+        const normalizedCode = normalizeWasmCompilerSource(code);
         if (this.debug) {
             console.log(`[BytecodeCompiler] Validating source (${code.length} chars)...`);
         }
@@ -223,7 +226,7 @@ export class BytecodeCompiler {
             if (!this.wasmCompiler) {
                 await this.loadWasmCompiler();
             }
-            const result = await this.wasmCompiler.validateSource(code);
+            const result = await this.wasmCompiler.validateSource(normalizedCode);
             return {
                 valid: result.valid,
                 errors: result.errors ? this.transformErrors(result.errors) : undefined,
@@ -372,6 +375,7 @@ export class BytecodeCompiler {
      */
     async generateABI(source) {
         const code = typeof source === 'string' ? source : source.content;
+        const normalizedCode = normalizeWasmCompilerSource(code);
         if (this.debug) {
             console.log(`[BytecodeCompiler] Generating ABI for source (${code.length} chars)...`);
         }
@@ -379,7 +383,7 @@ export class BytecodeCompiler {
             if (!this.wasmCompiler) {
                 await this.loadWasmCompiler();
             }
-            const abi = await this.wasmCompiler.generateABI(code);
+            const abi = await this.wasmCompiler.generateABI(normalizedCode);
             const normalizedFunctions = normalizeAbiFunctions(abi?.functions ?? abi);
             return { ...abi, functions: normalizedFunctions };
         }
@@ -387,7 +391,7 @@ export class BytecodeCompiler {
             if (this.debug) {
                 console.log(`[BytecodeCompiler] ABI generation error: ${error}`);
             }
-            throw new CompilationSDKError(`ABI generation failed: ${error instanceof Error ? error.message : "Unknown error"}`, { source: code.substring(0, 100) });
+            throw new CompilationSDKError(`ABI generation failed: ${error instanceof Error ? error.message : "Unknown error"}`, { source: normalizedCode.substring(0, 100) });
         }
     }
     /**

package/dist/compiler/source-normalization.d.ts

@@ -0,0 +1 @@
+export declare function normalizeWasmCompilerSource(source: string): string;

package/dist/compiler/source-normalization.js

@@ -0,0 +1,67 @@
+const SPL_TOKEN_PROGRAM_ID = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+function normalizeAccountContextAccess(source) {
+    const placeholders = new Map();
+    let nextId = 0;
+    const protect = (match) => {
+        const token = `__FIVE_CTX_${nextId++}__`;
+        placeholders.set(token, match);
+        return token;
+    };
+    let normalized = source.replace(/(\b[A-Za-z_][A-Za-z0-9_]*)\.ctx\.(key|lamports|owner|data|bump)\b/g, protect);
+    normalized = normalized.replace(/(\b[A-Za-z_][A-Za-z0-9_]*)\.(key|lamports|owner|data|bump)\b/g, '$1.ctx.$2');
+    for (const [token, original] of placeholders.entries()) {
+        normalized = normalized.split(token).join(original);
+    }
+    return normalized;
+}
+function normalizeSplTokenModule(source) {
+    const importPattern = /^\s*use\s+std::interfaces::spl_token;\s*$/m;
+    if (!importPattern.test(source) && !/\bspl_token::[A-Za-z_][A-Za-z0-9_]*\s*\(/.test(source)) {
+        return source;
+    }
+    let normalized = source.replace(importPattern, '');
+    const methods = new Set();
+    for (const match of normalized.matchAll(/\bspl_token::([A-Za-z_][A-Za-z0-9_]*)\s*\(/g)) {
+        methods.add(match[1]);
+    }
+    if (methods.size === 0) {
+        return normalized;
+    }
+    const signatures = Array.from(methods)
+        .sort()
+        .map((method) => {
+        switch (method) {
+            case 'transfer':
+                return '  transfer(source: account @mut, destination: account @mut, authority: account @signer, amount: u64);';
+            case 'mint_to':
+                return '  mint_to(mint: account @mut, destination: account @mut, authority: account @signer, amount: u64);';
+            case 'burn':
+                return '  burn(source: account @mut, mint: account @mut, authority: account @signer, amount: u64);';
+            case 'approve':
+                return '  approve(source: account @mut, delegate: account, authority: account @signer, amount: u64);';
+            case 'revoke':
+                return '  revoke(source: account @mut, authority: account @signer);';
+            case 'freeze_account':
+                return '  freeze_account(account_to_freeze: account @mut, mint: account @mut, freeze_authority: account @signer);';
+            case 'thaw_account':
+                return '  thaw_account(account_to_thaw: account @mut, mint: account @mut, freeze_authority: account @signer);';
+            case 'transfer_checked':
+                return '  transfer_checked(source: account @mut, mint: account @mut, destination: account @mut, authority: account @signer, amount: u64, decimals: u8);';
+            default:
+                return `  ${method}(source: account @mut, destination: account @mut, authority: account @signer, amount: u64);`;
+        }
+    })
+        .join('\n');
+    normalized = normalized.replace(/\bspl_token::([A-Za-z_][A-Za-z0-9_]*)\s*\(/g, 'SPLToken.$1(');
+    if (/^\s*interface\s+SPLToken\b/m.test(normalized)) {
+        return normalized;
+    }
+    const interfaceDecl = `interface SPLToken @program("${SPL_TOKEN_PROGRAM_ID}") {\n${signatures}\n}\n\n`;
+    return `${interfaceDecl}${normalized.trimStart()}`;
+}
+export function normalizeWasmCompilerSource(source) {
+    let normalized = source;
+    normalized = normalizeAccountContextAccess(normalized);
+    normalized = normalizeSplTokenModule(normalized);
+    return normalized;
+}

package/dist/config/ProgramIdResolver.js

@@ -4,6 +4,7 @@
  */
 import { validator } from '../validation/index.js';
 import { VmClusterConfigResolver } from './VmClusterConfigResolver.js';
+import { FIVE_VM_PROGRAM_ID } from '../types.js';
 /**
  * Centralized resolver for program IDs across all SDK operations.
  * Ensures consistent validation and error messaging.
@@ -45,7 +46,7 @@ export class ProgramIdResolver {
      * ```
      */
     static resolve(explicit, options) {
-        // Precedence: explicit → default → cluster-config
+        // Precedence: explicit → default → env → cluster-config → baked
         let resolved;
         if (explicit) {
             resolved = explicit;
@@ -53,12 +54,15 @@ export class ProgramIdResolver {
         else if (this.defaultProgramId) {
             resolved = this.defaultProgramId;
         }
+        else if (process.env.FIVE_PROGRAM_ID) {
+            resolved = process.env.FIVE_PROGRAM_ID;
+        }
         else {
             try {
                 resolved = VmClusterConfigResolver.loadClusterConfig().programId;
             }
             catch {
-                resolved = undefined;
+                resolved = FIVE_VM_PROGRAM_ID;
             }
         }
         if (!resolved && !options?.allowUndefined) {

package/dist/constants/headers.d.ts

@@ -0,0 +1,2 @@
+export declare const SCRIPT_BYTECODE_HEADER_V1_LEN = 10;
+export declare const SCRIPT_ACCOUNT_HEADER_LEN = 64;

package/dist/constants/headers.js

@@ -0,0 +1,2 @@
+export const SCRIPT_BYTECODE_HEADER_V1_LEN = 10;
+export const SCRIPT_ACCOUNT_HEADER_LEN = 64;

package/dist/crypto/index.d.ts

@@ -9,9 +9,10 @@ export declare class PDAUtils {
     /**
      * Derive script account using seed-based derivation compatible with SystemProgram.createAccountWithSeed
      * @param bytecode - The bytecode to derive address for
+     * @param basePublicKey - The deployer/base public key used for createWithSeed
      * @param programId - The Five VM program ID (required - no default to enforce explicit configuration)
      */
-    static deriveScriptAccount(bytecode: Uint8Array, programId: string): Promise<{
+    static deriveScriptAccount(bytecode: Uint8Array, basePublicKey: string, programId: string): Promise<{
         address: string;
         bump: number;
         seed: string;
@@ -127,6 +128,12 @@ export declare class RentCalculator {
      * Calculate minimum rent-exempt balance for account size (legacy method)
      */
     static calculateRentExemption(accountSize: number): number;
+    /**
+     * Query rent from RPC when possible and fall back to local estimation otherwise.
+     */
+    static calculateRentExemptionWithConnection(accountSize: number, connection?: {
+        getMinimumBalanceForRentExemption?: (size: number) => Promise<number>;
+    }): Promise<number>;
     /**
      * Get estimated rent for script account based on bytecode size
      */