@5ive-tech/sdk 1.1.10 → 1.1.13

package/dist/modules/admin.js

@@ -1,5 +1,6 @@
 import { validator } from "../validation/index.js";
 import { ProgramIdResolver } from "../config/ProgramIdResolver.js";
+import { confirmTransactionRobust } from "../utils/transaction.js";
 import bs58 from "bs58";
 const VM_STATE_SEED = Buffer.from("vm_state", "utf8");
 const FEE_VAULT_NAMESPACE_SEED = Buffer.from([
@@ -205,9 +206,12 @@ export async function initializeVmStateOnSolana(connection, authorityKeypair, op
         preflightCommitment: "confirmed",
         maxRetries: options.maxRetries || 3,
     });
-    const confirmation = await connection.confirmTransaction(signature, "confirmed");
-    if (confirmation?.value?.err) {
-        return { success: false, transactionId: signature, vmStateAccount: generated.vmStateAccount, error: JSON.stringify(confirmation.value.err) };
+    const confirmation = await confirmTransactionRobust(connection, signature, {
+        commitment: "finalized",
+        timeoutMs: 120000,
+    });
+    if (!confirmation.success) {
+        return { success: false, transactionId: signature, vmStateAccount: generated.vmStateAccount, error: confirmation.error || "confirmation failed" };
     }
     return { success: true, transactionId: signature, vmStateAccount: generated.vmStateAccount };
 }
@@ -235,9 +239,12 @@ export async function setFeesOnSolana(connection, authorityKeypair, deployFeeLam
         preflightCommitment: "confirmed",
         maxRetries: options.maxRetries || 3,
     });
-    const confirmation = await connection.confirmTransaction(signature, "confirmed");
-    if (confirmation?.value?.err) {
-        return { success: false, transactionId: signature, vmStateAccount: generated.vmStateAccount, error: JSON.stringify(confirmation.value.err) };
+    const confirmation = await confirmTransactionRobust(connection, signature, {
+        commitment: "finalized",
+        timeoutMs: 120000,
+    });
+    if (!confirmation.success) {
+        return { success: false, transactionId: signature, vmStateAccount: generated.vmStateAccount, error: confirmation.error || "confirmation failed" };
     }
     return { success: true, transactionId: signature, vmStateAccount: generated.vmStateAccount };
 }
@@ -266,14 +273,17 @@ export async function initFeeVaultOnSolana(connection, payerKeypair, shardIndex,
         preflightCommitment: "confirmed",
         maxRetries: options.maxRetries || 3,
     });
-    const confirmation = await connection.confirmTransaction(signature, "confirmed");
-    if (confirmation?.value?.err) {
+    const confirmation = await confirmTransactionRobust(connection, signature, {
+        commitment: "finalized",
+        timeoutMs: 120000,
+    });
+    if (!confirmation.success) {
         return {
             success: false,
             transactionId: signature,
             vmStateAccount: generated.vmStateAccount,
             feeVaultAccount: generated.feeVaultAccount,
-            error: JSON.stringify(confirmation.value.err),
+            error: confirmation.error || "confirmation failed",
         };
     }
     return {
@@ -308,14 +318,17 @@ export async function withdrawScriptFeesOnSolana(connection, authorityKeypair, r
         preflightCommitment: "confirmed",
         maxRetries: options.maxRetries || 3,
     });
-    const confirmation = await connection.confirmTransaction(signature, "confirmed");
-    if (confirmation?.value?.err) {
+    const confirmation = await confirmTransactionRobust(connection, signature, {
+        commitment: "finalized",
+        timeoutMs: 120000,
+    });
+    if (!confirmation.success) {
         return {
             success: false,
             transactionId: signature,
             vmStateAccount: generated.vmStateAccount,
             feeVaultAccount: generated.feeVaultAccount,
-            error: JSON.stringify(confirmation.value.err),
+            error: confirmation.error || "confirmation failed",
         };
     }
     return {

package/dist/modules/deploy.js

@@ -1,20 +1,36 @@
 import { PDAUtils, RentCalculator } from "../crypto/index.js";
 import { validator, Validators } from "../validation/index.js";
 import { calculateDeployFee } from "./fees.js";
-import { pollForConfirmation } from "../utils/transaction.js";
+import { confirmTransactionRobust, getAccountInfoWithRetry, pollForConfirmation, SDK_COMMITMENTS, } from "../utils/transaction.js";
 import { ProgramIdResolver } from "../config/ProgramIdResolver.js";
-const DEFAULT_FEE_VAULT_SHARD_COUNT = 10;
+import { VmClusterConfigResolver } from "../config/VmClusterConfigResolver.js";
+const DEFAULT_FEE_VAULT_SHARD_COUNT = (() => {
+    try {
+        return VmClusterConfigResolver.loadClusterConfig().feeVaultShardCount;
+    }
+    catch {
+        return 2;
+    }
+})();
 const FEE_VAULT_NAMESPACE_SEED = Buffer.from([
     0xff, 0x66, 0x69, 0x76, 0x65, 0x5f, 0x76, 0x6d, 0x5f, 0x66, 0x65, 0x65,
     0x5f, 0x76, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x76, 0x31,
 ]);
+function clampShardCount(rawCount) {
+    const normalized = rawCount > 0 ? rawCount : DEFAULT_FEE_VAULT_SHARD_COUNT;
+    return Math.max(1, Math.min(DEFAULT_FEE_VAULT_SHARD_COUNT, normalized));
+}
 async function readVMStateFeeConfig(connection, vmStateAddress) {
     if (!connection) {
         return { shardCount: DEFAULT_FEE_VAULT_SHARD_COUNT };
     }
     try {
         const { PublicKey } = await import("@solana/web3.js");
-        const info = await connection.getAccountInfo(new PublicKey(vmStateAddress), "confirmed");
+        const info = await getAccountInfoWithRetry(connection, new PublicKey(vmStateAddress), {
+            commitment: SDK_COMMITMENTS.READ,
+            retries: 2,
+            delayMs: 700,
+        });
         if (!info) {
             return { shardCount: DEFAULT_FEE_VAULT_SHARD_COUNT };
         }
@@ -25,7 +41,7 @@ async function readVMStateFeeConfig(connection, vmStateAddress) {
         const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const deployFeeLamports = view.getUint32(40, true);
         const shardCountRaw = data.length > 50 ? data[50] : 0;
-        const shardCount = shardCountRaw > 0 ? shardCountRaw : DEFAULT_FEE_VAULT_SHARD_COUNT;
+        const shardCount = clampShardCount(shardCountRaw);
         return { deployFeeLamports, shardCount };
     }
     catch {
@@ -43,7 +59,8 @@ function createInitFeeVaultInstructionData(shardIndex, bump) {
 async function initProgramFeeVaultShards(connection, programId, vmStateAccount, shardCount, payer, options = {}) {
     const { PublicKey, Transaction, TransactionInstruction, SystemProgram } = await import("@solana/web3.js");
     const signatures = [];
-    for (let shardIndex = 0; shardIndex < shardCount; shardIndex++) {
+    const effectiveShardCount = clampShardCount(shardCount);
+    for (let shardIndex = 0; shardIndex < effectiveShardCount; shardIndex++) {
         const vault = await deriveProgramFeeVault(programId, shardIndex);
         const tx = new Transaction().add(new TransactionInstruction({
             programId: new PublicKey(programId),
@@ -64,7 +81,14 @@ async function initProgramFeeVaultShards(connection, programId, vmStateAccount,
             preflightCommitment: "confirmed",
             maxRetries: options.maxRetries || 3,
         });
-        await connection.confirmTransaction(sig, "confirmed");
+        const shardConfirm = await confirmTransactionRobust(connection, sig, {
+            commitment: "finalized",
+            timeoutMs: 120000,
+            debug: options.debug,
+        });
+        if (!shardConfirm.success) {
+            throw new Error(`Fee vault shard init failed: ${shardConfirm.error || "unconfirmed"}`);
+        }
         signatures.push(sig);
         if (options.debug) {
             console.log(`[FiveSDK] Initialized fee vault shard ${shardIndex}: ${vault.address}`);
@@ -192,7 +216,7 @@ options = {}) {
         }));
     }
     // 1. Initialize canonical VM State if missing
-    const vmStateInfo = await connection.getAccountInfo(vmStatePubkey);
+    const vmStateInfo = await connection.getAccountInfo(vmStatePubkey, "finalized");
     if (!vmStateInfo) {
         tx.add(new TransactionInstruction({
             keys: [
@@ -530,7 +554,14 @@ options = {}) {
             preflightCommitment: "confirmed",
             maxRetries: options.maxRetries || 3,
         });
-        await connection.confirmTransaction(initSignature, "confirmed");
+        const initConfirm = await confirmTransactionRobust(connection, initSignature, {
+            commitment: "finalized",
+            timeoutMs: 120000,
+            debug: options.debug,
+        });
+        if (!initConfirm.success) {
+            throw new Error(`Initialization confirmation failed: ${initConfirm.error || "unconfirmed"}`);
+        }
         transactionIds.push(initSignature);
         if (options.debug) {
             console.log(`[FiveSDK] ✅ Initialization completed: ${initSignature}`);
@@ -549,16 +580,9 @@ options = {}) {
                 console.log(`[FiveSDK] Step ${i + 2}: Appending chunk ${i + 1}/${chunks.length} (${chunk.length} bytes)`);
             }
             // Calculate additional rent needed for this chunk
-            let currentInfo = await connection.getAccountInfo(scriptKeypair.publicKey);
-            // Retry logic for account info if null (eventual consistency)
-            if (!currentInfo) {
-                if (options.debug)
-                    console.log(`[FiveSDK] Account info null, retrying...`);
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                currentInfo = await connection.getAccountInfo(scriptKeypair.publicKey);
-                if (!currentInfo)
-                    throw new Error("Script account not found after initialization");
-            }
+            const currentInfo = await getAccountInfoWithRetry(connection, scriptKeypair.publicKey, { commitment: "finalized", retries: 2, delayMs: 1000, debug: options.debug });
+            if (!currentInfo)
+                throw new Error("Script account not found after initialization");
             const newSize = currentInfo.data.length + chunk.length;
             const newRentRequired = await connection.getMinimumBalanceForRentExemption(newSize);
             const additionalRent = Math.max(0, newRentRequired - currentInfo.lamports);
@@ -627,14 +651,29 @@ options = {}) {
                 preflightCommitment: "confirmed",
                 maxRetries: options.maxRetries || 3,
             });
-            await connection.confirmTransaction(appendSignature, "confirmed");
+            const appendConfirm = await confirmTransactionRobust(connection, appendSignature, {
+                commitment: "finalized",
+                timeoutMs: 120000,
+                debug: options.debug,
+            });
+            if (!appendConfirm.success) {
+                throw new Error(`Append confirmation failed: ${appendConfirm.error || "unconfirmed"}`);
+            }
             transactionIds.push(appendSignature);
             if (options.debug) {
                 console.log(`[FiveSDK] ✅ Chunk ${i + 1} appended: ${appendSignature}`);
             }
         }
         // Final verification
-        const finalInfo = await connection.getAccountInfo(scriptKeypair.publicKey);
+        let finalInfo = await getAccountInfoWithRetry(connection, scriptKeypair.publicKey, {
+            commitment: "finalized",
+            retries: 2,
+            delayMs: 1000,
+            debug: options.debug,
+        });
+        if (!finalInfo) {
+            throw new Error("Script account not found during final verification");
+        }
         const expectedSize = SCRIPT_HEADER_SIZE + bytecode.length;
         if (options.debug) {
             console.log(`[FiveSDK] 🔍 Final verification:`);
@@ -882,7 +921,7 @@ options = {}) {
                     preflightCommitment: "confirmed",
                     maxRetries: options.maxRetries || 3,
                 });
-                const appendConfirmation = await pollForConfirmation(connection, appendSignature, "confirmed", 120000, options.debug);
+                const appendConfirmation = await pollForConfirmation(connection, appendSignature, "finalized", 120000, options.debug);
                 if (!appendConfirmation.success) {
                     return {
                         success: false,
@@ -929,7 +968,7 @@ options = {}) {
             maxRetries: options.maxRetries || 3,
         });
         // Use custom polling for finalize to handle validator latency
-        const finalizeConfirmation = await pollForConfirmation(connection, finalizeSignature, "confirmed", 120000, // 120 second timeout
+        const finalizeConfirmation = await pollForConfirmation(connection, finalizeSignature, "finalized", 120000, // 120 second timeout
         options.debug);
         if (!finalizeConfirmation.success) {
             console.error(`[FiveSDK] FinalizeScript confirmation failed: ${finalizeConfirmation.error}`);
@@ -1056,7 +1095,7 @@ async function ensureCanonicalVmStateAccount(connection, deployerKeypair, progra
         throw new Error(`vmStateAccount must be canonical PDA ${canonical.address}; got ${options.vmStateAccount}`);
     }
     const vmStatePubkey = new PublicKey(canonical.address);
-    const existing = await connection.getAccountInfo(vmStatePubkey);
+    const existing = await connection.getAccountInfo(vmStatePubkey, "finalized");
     if (existing) {
         if (existing.owner.toBase58() !== programId.toBase58()) {
             throw new Error(`canonical VM state ${canonical.address} exists but is owned by ${existing.owner.toBase58()}, expected ${programId.toBase58()}`);

package/dist/modules/execute.js

@@ -7,13 +7,26 @@ import { validator, Validators } from "../validation/index.js";
 import { calculateExecuteFee } from "./fees.js";
 import { loadWasmVM } from "../wasm/instance.js";
 import { ProgramIdResolver } from "../config/ProgramIdResolver.js";
-const DEFAULT_FEE_VAULT_SHARD_COUNT = 10;
+import { VmClusterConfigResolver } from "../config/VmClusterConfigResolver.js";
+import { confirmTransactionRobust, getAccountInfoWithRetry, } from "../utils/transaction.js";
+const DEFAULT_FEE_VAULT_SHARD_COUNT = (() => {
+    try {
+        return VmClusterConfigResolver.loadClusterConfig().feeVaultShardCount;
+    }
+    catch {
+        return 2;
+    }
+})();
 const FEE_VAULT_NAMESPACE_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 EXECUTE_FEE_HEADER_A = 0xff;
 const EXECUTE_FEE_HEADER_B = 0x53;
+function clampShardCount(rawCount) {
+    const normalized = rawCount > 0 ? rawCount : DEFAULT_FEE_VAULT_SHARD_COUNT;
+    return Math.max(1, Math.min(DEFAULT_FEE_VAULT_SHARD_COUNT, normalized));
+}
 async function deriveProgramFeeVault(programId, shardIndex) {
     const { PublicKey } = await import("@solana/web3.js");
     const [pda, bump] = PublicKey.findProgramAddressSync([FEE_VAULT_NAMESPACE_SEED, Buffer.from([shardIndex])], new PublicKey(programId));
@@ -24,14 +37,17 @@ async function readVMStateShardCount(connection, vmStateAddress) {
         return DEFAULT_FEE_VAULT_SHARD_COUNT;
     try {
         const { PublicKey } = await import("@solana/web3.js");
-        const info = await connection.getAccountInfo(new PublicKey(vmStateAddress), "confirmed");
+        const info = await getAccountInfoWithRetry(connection, new PublicKey(vmStateAddress), {
+            commitment: "finalized",
+            retries: 2,
+            delayMs: 1000,
+        });
         if (!info)
             return DEFAULT_FEE_VAULT_SHARD_COUNT;
         const data = new Uint8Array(info.data);
         if (data.length <= 50)
             return DEFAULT_FEE_VAULT_SHARD_COUNT;
-        const shardCount = data[50];
-        return shardCount > 0 ? shardCount : DEFAULT_FEE_VAULT_SHARD_COUNT;
+        return clampShardCount(data[50]);
     }
     catch {
         return DEFAULT_FEE_VAULT_SHARD_COUNT;
@@ -265,7 +281,10 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         { pubkey: vmState, isSigner: false, isWritable: false },
     ];
     const abiAccountMetadata = new Map();
-    if (funcDef && funcDef.parameters) {
+    const hasFullParameterList = !!funcDef &&
+        Array.isArray(funcDef.parameters) &&
+        parameters.length === funcDef.parameters.length;
+    if (funcDef && funcDef.parameters && hasFullParameterList) {
         // First pass: detect if there's an @init constraint and find the payer
         let hasInit = false;
         let payerPubkey;
@@ -312,9 +331,11 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         // Check both derived ABI metadata and passed-in metadata (from FunctionBuilder)
         const abiMetadata = abiAccountMetadata.get(acc);
         const passedMetadata = options.accountMetadata?.get(acc);
-        const metadata = abiMetadata || passedMetadata;
+        const metadata = passedMetadata || abiMetadata;
         const isSigner = metadata ? metadata.isSigner : false;
-        const isWritable = metadata ? metadata.isWritable : true;
+        const isWritable = metadata
+            ? (metadata.isSystemAccount ? false : metadata.isWritable)
+            : true;
         return {
             pubkey: acc,
             isSigner,
@@ -322,7 +343,7 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         };
     });
     instructionAccounts.push(...userInstructionAccounts);
-    const instructionData = encodeExecuteInstruction(functionIndex, encodedParams, actualParamCount, feeShardIndex, feeVault.bump);
+    const instructionData = encodeExecuteInstruction(functionIndex, encodedParams, actualParamCount, feeShardIndex, options.debug === true);
     // Runtime requires strict tail: [payer, fee_vault, system_program].
     const signerCandidates = instructionAccounts
         .filter((acc) => acc.isSigner)
@@ -444,15 +465,15 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
             maxRetries: options.maxRetries || 3,
         });
         lastSignature = signature;
-        let confirmation;
-        try {
-            confirmation = await connection.confirmTransaction({
-                signature,
-                blockhash,
-                lastValidBlockHeight: (await connection.getLatestBlockhash("confirmed")).lastValidBlockHeight,
-            }, "confirmed");
-        }
-        catch (confirmError) {
+        const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+        const confirmation = await confirmTransactionRobust(connection, signature, {
+            commitment: "confirmed",
+            timeoutMs: 120000,
+            debug: options.debug,
+            blockhash,
+            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+        });
+        if (!confirmation.success) {
             try {
                 const txDetails = await connection.getTransaction(signature, {
                     commitment: "confirmed",
@@ -479,9 +500,9 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
                 }
             }
             catch (getTransactionError) { }
-            throw confirmError;
+            throw new Error(confirmation.error || "Execution confirmation failed");
         }
-        if (confirmation.value.err) {
+        if (confirmation.err) {
             let logs = [];
             let computeUnitsUsed;
             try {
@@ -495,7 +516,7 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
                 }
             }
             catch { }
-            const errorMessage = `Execution transaction failed: ${JSON.stringify(confirmation.value.err)}`;
+            const errorMessage = `Execution transaction failed: ${JSON.stringify(confirmation.err)}`;
             return {
                 success: false,
                 error: errorMessage,
@@ -559,14 +580,13 @@ export async function executeScriptAccount(scriptAccount, functionIndex = 0, par
     });
 }
 // Helpers
-function encodeExecuteInstruction(functionIndex, encodedParams, paramCount, feeShardIndex, feeVaultBump) {
+function encodeExecuteInstruction(functionIndex, encodedParams, paramCount, feeShardIndex, debug = false) {
     const parts = [];
     parts.push(new Uint8Array([9]));
     parts.push(new Uint8Array([
         EXECUTE_FEE_HEADER_A,
         EXECUTE_FEE_HEADER_B,
         feeShardIndex & 0xff,
-        feeVaultBump & 0xff,
     ]));
     // Function index as fixed u32
     parts.push(encodeU32(functionIndex));
@@ -580,6 +600,15 @@ function encodeExecuteInstruction(functionIndex, encodedParams, paramCount, feeS
         result.set(part, resultOffset);
         resultOffset += part.length;
     }
+    if (debug) {
+        const payloadLen = encodedParams.length;
+        const previewLen = Math.min(24, result.length);
+        const previewHex = Buffer.from(result.subarray(0, previewLen)).toString("hex");
+        const legacyVarintLikely = result.length >= 9 &&
+            // Legacy varint flow had no fee header and placed varint fields immediately after discriminator.
+            !(result[1] === EXECUTE_FEE_HEADER_A && result[2] === EXECUTE_FEE_HEADER_B);
+        console.log(`[FiveSDK] Execute wire envelope: discr=${result[0]} fee_header=[${result[1]},${result[2]},${result[3]}] function_index_u32=${functionIndex} param_count_u32=${paramCount} payload_len=${payloadLen} total_len=${result.length} preview_hex=${previewHex}${legacyVarintLikely ? " legacy_varint_suspected=true" : ""}`);
+    }
     return result;
 }
 function encodeU32(value) {
@@ -625,21 +654,27 @@ async function encodeParametersWithABI(parameters, functionDef, functionIndex, _
         const type = (param.type || param.param_type || '').toString().trim().toLowerCase();
         return type === 'pubkey';
     };
-    const paramDefs = (functionDef.parameters || []);
+    const paramDefs = functionDef.parameters || [];
     const nonAccountParamDefs = paramDefs.filter((param) => !isAccountParam(param));
-    const fullParameterListProvided = parameters.length >= paramDefs.length;
-    if (fullParameterListProvided && parameters.length !== paramDefs.length) {
-        console.warn(`[FiveSDK] Parameter validation warning: Function '${functionDef.name}' expects ${paramDefs.length} parameters, but received ${parameters.length}.`);
+    const isFullParamList = parameters.length === paramDefs.length;
+    const isArgOnlyList = parameters.length === nonAccountParamDefs.length;
+    if (!isFullParamList && !isArgOnlyList) {
+        console.warn(`[FiveSDK] Parameter validation warning: Function '${functionDef.name}' expects ${paramDefs.length} total params (${nonAccountParamDefs.length} non-account), but received ${parameters.length}.`);
+    }
+    // Current VM/compiler contract encodes non-account parameters only.
+    // If callers pass full ABI params (accounts + args), normalize to args-only order.
+    if (isFullParamList) {
+        console.warn(`[FiveSDK] Deprecation: full ABI parameter lists (including account params) are normalized to non-account execute args for '${functionDef.name}'. Pass args-only params to avoid this warning.`);
     }
+    const defsForEncoding = nonAccountParamDefs;
     const paramValues = {};
-    let argCursor = 0;
-    for (let index = 0; index < paramDefs.length; index++) {
-        const param = paramDefs[index];
-        if (isAccountParam(param)) {
-            continue;
-        }
-        const sourceIndex = fullParameterListProvided ? index : argCursor;
-        if (sourceIndex >= parameters.length) {
+    const paramSourceIndexByName = new Map(paramDefs.map((param, index) => [param.name, index]));
+    for (let index = 0; index < defsForEncoding.length; index++) {
+        const param = defsForEncoding[index];
+        const sourceIndex = isFullParamList
+            ? (paramSourceIndexByName.get(param.name) ?? -1)
+            : index;
+        if (sourceIndex < 0 || sourceIndex >= parameters.length) {
             throw new Error(`Missing value for parameter: ${param.name}`);
         }
         let value = parameters[sourceIndex];
@@ -649,10 +684,9 @@ async function encodeParametersWithABI(parameters, functionDef, functionIndex, _
             }
         }
         paramValues[param.name] = value;
-        argCursor += 1;
     }
-    const encoded = await BytecodeEncoder.encodeExecute(functionIndex, nonAccountParamDefs, paramValues, true, options);
-    return { encoded, paramCount: nonAccountParamDefs.length };
+    const encoded = await BytecodeEncoder.encodeExecute(functionIndex, defsForEncoding, paramValues, true, options);
+    return { encoded, paramCount: defsForEncoding.length };
 }
 function estimateComputeUnits(functionIndex, parameterCount) {
     return Math.max(5000, 1000 + parameterCount * 500 + functionIndex * 100);

package/dist/modules/vm-state.js

@@ -1,5 +1,6 @@
 import { PDAUtils, Base58Utils } from "../crypto/index.js";
 import { ProgramIdResolver } from "../config/ProgramIdResolver.js";
+import { getAccountInfoWithRetry } from "../utils/transaction.js";
 export async function getVMState(connection, fiveVMProgramId) {
     const programId = ProgramIdResolver.resolve(fiveVMProgramId);
     const vmStatePDA = await PDAUtils.deriveVMStatePDA(programId);
@@ -12,7 +13,11 @@ export async function getVMState(connection, fiveVMProgramId) {
                 pubkey = new PublicKey(vmStatePDA.address);
             }
             catch { }
-            const info = await connection.getAccountInfo(pubkey);
+            const info = await getAccountInfoWithRetry(connection, pubkey, {
+                commitment: "finalized",
+                retries: 2,
+                delayMs: 1000,
+            });
             if (!info)
                 throw new Error("VM State account not found");
             accountData = new Uint8Array(info.data);

package/dist/program/FunctionBuilder.d.ts

@@ -29,6 +29,7 @@ export declare class FunctionBuilder {
     private accountsMap;
     private argsMap;
     private resolvedAccounts;
+    private vmPayerAccount?;
     constructor(functionDef: FunctionDefinition, scriptAccount: string, abi: ScriptABI, options: FiveProgramOptions);
     /**
      * Specify accounts for this function call
@@ -47,6 +48,13 @@ export declare class FunctionBuilder {
      * @returns this for method chaining
      */
     args(args: Record<string, any>): this;
+    /**
+     * Override the VM execute-fee payer account for this instruction.
+     * This is distinct from the outer transaction fee payer.
+     */
+    payer(payer: string | {
+        toBase58(): string;
+    }): this;
     /**
      * Build and return serialized instruction data
      * This is the main method that orchestrates parameter resolution and instruction generation

package/dist/program/FunctionBuilder.js

@@ -62,6 +62,15 @@ export class FunctionBuilder {
         }
         return this;
     }
+    /**
+     * Override the VM execute-fee payer account for this instruction.
+     * This is distinct from the outer transaction fee payer.
+     */
+    payer(payer) {
+        this.vmPayerAccount =
+            typeof payer === 'string' ? payer : payer.toBase58();
+        return this;
+    }
     /**
      * Build and return serialized instruction data
      * This is the main method that orchestrates parameter resolution and instruction generation
@@ -93,7 +102,7 @@ export class FunctionBuilder {
         // Now validate that all required parameters are provided (including auto-injected ones)
         this.validateParameters();
         // Merge parameters in ABI order (accounts first, then data)
-        const { mergedParams, accountPubkeys } = this.mergeParameters();
+        const { mergedParams, argParams, accountPubkeys } = this.mergeParameters();
         // Append system accounts to the account list (they go at the end)
         const allAccountPubkeys = [...accountPubkeys, ...systemAccountsList];
         // Build account metadata from ABI attributes
@@ -105,7 +114,7 @@ export class FunctionBuilder {
         }
         // Call existing SDK method to generate instruction
         // This reuses the proven parameter encoding logic
-        const instruction = await this.generateInstructionData(mergedParams, allAccountPubkeys, accountMetadata);
+        const instruction = await this.generateInstructionData(mergedParams, argParams, allAccountPubkeys, accountMetadata);
         if (this.options.debug) {
             console.log(`[FunctionBuilder] Generated instruction:`, instruction);
         }
@@ -178,6 +187,7 @@ export class FunctionBuilder {
      */
     mergeParameters() {
         const mergedParams = [];
+        const argParams = [];
         const accountPubkeys = [];
         for (const param of this.functionDef.parameters) {
             if (param.is_account) {
@@ -196,9 +206,10 @@ export class FunctionBuilder {
                     throw new Error(`Missing argument '${param.name}'`);
                 }
                 mergedParams.push(value);
+                argParams.push(value);
             }
         }
-        return { mergedParams, accountPubkeys };
+        return { mergedParams, argParams, accountPubkeys };
     }
     /**
      * Build account metadata (isSigner, isWritable) from ABI attributes
@@ -279,14 +290,14 @@ export class FunctionBuilder {
      * @param accountMetadata - Account metadata (isSigner, isWritable)
      * @returns SerializedInstruction
      */
-    async generateInstructionData(mergedParams, accountList, accountMetadata) {
+    async generateInstructionData(mergedParams, argParams, accountList, accountMetadata) {
         // Account list is already passed in
         // Dynamically import FiveSDK to avoid circular dependencies
         const { FiveSDK } = await import('../FiveSDK.js');
         // Call the SDK's generateExecuteInstruction method.
         // This handles fixed-size typed execute encoding and parameter validation.
         const executionResult = await FiveSDK.generateExecuteInstruction(this.scriptAccount, this.functionDef.index, // Use function index directly
-        mergedParams, // All parameters in merged order
+        argParams, // Current VM contract encodes non-account args only
         accountList, // Account pubkey list
         undefined, // No connection needed - we have ABI
         {
@@ -295,6 +306,8 @@ export class FunctionBuilder {
             fiveVMProgramId: this.options.fiveVMProgramId,
             vmStateAccount: this.options.vmStateAccount,
             adminAccount: this.options.feeReceiverAccount,
+            payerAccount: this.vmPayerAccount ||
+                this.options.provider?.publicKey?.toBase58?.(),
             accountMetadata: accountMetadata, // Pass account metadata for correct isWritable flags
         });
         // Map SDK's instruction format (with 'accounts') to SerializedInstruction format (with 'keys')

package/dist/project/config.js

@@ -22,7 +22,6 @@ export function parseProjectConfig(parsedToml) {
         rpcUrl: deploy.rpc_url,
         programId: deploy.program_id,
         keypairPath: deploy.keypair_path,
-        multiFileMode: build.multi_file_mode ?? false,
         optimizations: {
             enableCompression: optimizations.enable_compression ?? true,
             enableConstraintOptimization: optimizations.enable_constraint_optimization ?? true,

package/dist/testing/TestRunner.js

@@ -238,9 +238,14 @@ export class FiveTestRunner {
                 byFile.set(test.path, cases);
             }
         }
+        const moduleNameForFile = (file) => file
+            .replace(/\.v$/i, '')
+            .split(/[\\/]/)
+            .filter(Boolean)
+            .join('::');
         for (const [file, testCases] of byFile.entries()) {
             suites.push({
-                name: basename(file, '.v'),
+                name: moduleNameForFile(file),
                 description: `Tests from ${file}`,
                 testCases
             });