@5ive-tech/sdk 1.1.10 → 1.1.12

package/dist/modules/deploy.js

@@ -1,9 +1,17 @@
 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,
@@ -14,7 +22,11 @@ async function readVMStateFeeConfig(connection, vmStateAddress) {
     }
     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 };
         }
@@ -64,7 +76,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 +211,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 +549,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 +575,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 +646,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 +916,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 +963,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 +1090,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,7 +7,16 @@ 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,
@@ -24,7 +33,11 @@ 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);
@@ -322,7 +335,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 +457,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 +492,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 +508,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 +572,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 +592,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 +646,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 +676,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/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
             });

package/dist/types.d.ts

@@ -18,7 +18,6 @@ export interface ProjectConfig {
     keypairPath?: string;
     optimizations?: ProjectOptimizations;
     dependencies?: ProjectDependency[];
-    multiFileMode?: boolean;
     wasm?: {
         loader?: 'auto' | 'node' | 'bundler';
         modulePaths?: string[];
@@ -80,12 +79,15 @@ export interface CompilationResult {
     metadata?: CompilationMetadata;
     errors?: CompilationError[];
     warnings?: CompilationWarning[];
+    diagnostics?: CompilationError[];
     disassembly?: string[];
     metrics?: CompilationMetrics;
     metricsReport?: CompilationMetricsReport;
     fiveFile?: FiveCompiledFile;
     publicFunctionNames?: string[];
     functionNames?: string[] | FunctionNameEntry[];
+    formattedErrorsTerminal?: string;
+    formattedErrorsJson?: string;
 }
 export interface CompilationMetadata {
     sourceFile: string;
@@ -113,7 +115,16 @@ export interface CompilationError {
     category?: string;
     description?: string;
     location?: any;
-    suggestions?: string[];
+    suggestions?: Array<string | {
+        message: string;
+        explanation?: string;
+        confidence?: number;
+        codeSuggestion?: string;
+    }>;
+    sourceLine?: string;
+    sourceSnippet?: string;
+    rendered?: string;
+    raw?: any;
 }
 export interface CompilationWarning {
     type: string;
@@ -332,12 +343,18 @@ export interface FiveCompiledFile {
 }
 export interface FiveFunction {
     name: string;
+    index?: number;
     parameters: FiveParameter[];
     returnType?: FiveType;
 }
 export interface FiveParameter {
     name: string;
     type: FiveType;
+    param_type?: FiveType;
+    optional?: boolean;
+    is_account?: boolean;
+    isAccount?: boolean;
+    attributes?: string[];
 }
 export type FiveType = string;
 export interface FunctionNameEntry {

package/dist/utils/abi.d.ts

@@ -4,7 +4,11 @@ export interface NormalizedABIFunction {
     parameters: Array<{
         name: string;
         type: string;
+        param_type?: string;
         optional?: boolean;
+        is_account?: boolean;
+        isAccount?: boolean;
+        attributes?: string[];
     }>;
     returnType?: string;
     accounts?: any[];

package/dist/utils/abi.js

@@ -20,8 +20,11 @@ export function normalizeAbiFunctions(abiFunctions) {
             parameters: parameters.map((param, paramIdx) => ({
                 name: param.name ?? `param${paramIdx}`,
                 type: param.type ?? param.param_type ?? param.paramType ?? '',
+                param_type: param.param_type ?? param.paramType,
                 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 ?? func.return_type,
             accounts: func.accounts ?? [],

package/dist/utils/transaction.d.ts

@@ -1,5 +1,27 @@
+export declare const SDK_COMMITMENTS: {
+    readonly WRITE: "confirmed";
+    readonly READ: "finalized";
+    readonly CONFIRM: "finalized";
+};
 export declare function pollForConfirmation(connection: any, signature: string, commitment?: string, timeoutMs?: number, debug?: boolean): Promise<{
     success: boolean;
     err?: any;
     error?: string;
 }>;
+export declare function confirmTransactionRobust(connection: any, signature: string, options?: {
+    commitment?: string;
+    timeoutMs?: number;
+    debug?: boolean;
+    blockhash?: string;
+    lastValidBlockHeight?: number;
+}): Promise<{
+    success: boolean;
+    err?: any;
+    error?: string;
+}>;
+export declare function getAccountInfoWithRetry(connection: any, pubkey: any, options?: {
+    commitment?: string;
+    retries?: number;
+    delayMs?: number;
+    debug?: boolean;
+}): Promise<any | null>;

package/dist/utils/transaction.js

@@ -1,6 +1,40 @@
+export const SDK_COMMITMENTS = {
+    WRITE: "confirmed",
+    READ: "finalized",
+    CONFIRM: "finalized",
+};
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_RETRY_DELAY_MS = 700;
+async function sleep(ms) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+}
+function backoffDelayMs(baseMs, attempt) {
+    const exp = Math.min(attempt, 6);
+    const raw = baseMs * (2 ** exp);
+    const jitter = Math.floor(raw * (0.15 * Math.random()));
+    return raw + jitter;
+}
+function normalizeCommitment(commitment) {
+    if (commitment === "finalized")
+        return "finalized";
+    if (commitment === "processed")
+        return "processed";
+    return "confirmed";
+}
+function statusMeetsCommitment(status, confirmations, target) {
+    if (target === "processed") {
+        return !!status || (confirmations ?? 0) >= 0;
+    }
+    if (target === "confirmed") {
+        return status === "confirmed" || status === "finalized" || (confirmations ?? 0) >= 1;
+    }
+    // finalized must be explicitly finalized; confirmations count is insufficient.
+    return status === "finalized";
+}
 export async function pollForConfirmation(connection, signature, commitment = "confirmed", timeoutMs = 120000, debug = false) {
     const startTime = Date.now();
-    const pollIntervalMs = 1000;
+    const pollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+    const targetCommitment = normalizeCommitment(commitment);
     if (debug) {
         console.log(`[FiveSDK] Starting confirmation poll with ${timeoutMs}ms timeout`);
     }
@@ -11,30 +45,36 @@ export async function pollForConfirmation(connection, signature, commitment = "c
                 console.log(`[FiveSDK] Confirmation status: ${JSON.stringify(confirmationStatus.value)}`);
             }
             if (confirmationStatus.value) {
-                if (confirmationStatus.value.confirmationStatus === commitment ||
-                    confirmationStatus.value.confirmations >= 1) {
-                    const transactionError = confirmationStatus.value.err;
-                    const succeeded = !transactionError;
+                const transactionError = confirmationStatus.value.err;
+                if (transactionError) {
+                    if (debug) {
+                        console.log(`[FiveSDK] Transaction error: ${JSON.stringify(transactionError)}`);
+                    }
+                    return {
+                        success: false,
+                        err: transactionError,
+                        error: JSON.stringify(transactionError),
+                    };
+                }
+                if (statusMeetsCommitment(confirmationStatus.value.confirmationStatus, confirmationStatus.value.confirmations, targetCommitment)) {
+                    const succeeded = true;
                     if (debug) {
                         console.log(`[FiveSDK] Transaction confirmed after ${Date.now() - startTime}ms${succeeded ? '' : ' (with error)'}`);
-                        if (transactionError) {
-                            console.log(`[FiveSDK] Transaction error: ${JSON.stringify(transactionError)}`);
-                        }
                     }
                     return {
                         success: succeeded,
-                        err: transactionError,
-                        error: transactionError ? JSON.stringify(transactionError) : undefined,
+                        err: undefined,
+                        error: undefined,
                     };
                 }
             }
-            await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+            await sleep(pollIntervalMs);
         }
         catch (error) {
             if (debug) {
                 console.log(`[FiveSDK] Polling error: ${error instanceof Error ? error.message : String(error)}`);
             }
-            await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+            await sleep(pollIntervalMs);
         }
     }
     const elapsed = Date.now() - startTime;
@@ -46,3 +86,45 @@ export async function pollForConfirmation(connection, signature, commitment = "c
         error: `Transaction confirmation timeout after ${elapsed}ms. Signature: ${signature}`,
     };
 }
+export async function confirmTransactionRobust(connection, signature, options = {}) {
+    const commitment = options.commitment || SDK_COMMITMENTS.CONFIRM;
+    const timeoutMs = options.timeoutMs || 120000;
+    const debug = options.debug || false;
+    try {
+        const confirmArg = options.blockhash && typeof options.lastValidBlockHeight === "number"
+            ? {
+                signature,
+                blockhash: options.blockhash,
+                lastValidBlockHeight: options.lastValidBlockHeight,
+            }
+            : signature;
+        const confirmation = await connection.confirmTransaction(confirmArg, commitment);
+        const err = confirmation?.value?.err;
+        if (!err) {
+            return { success: true };
+        }
+        return { success: false, err, error: JSON.stringify(err) };
+    }
+    catch (error) {
+        if (debug) {
+            console.log(`[FiveSDK] confirmTransaction threw, falling back to polling: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return pollForConfirmation(connection, signature, commitment, timeoutMs, debug);
+}
+export async function getAccountInfoWithRetry(connection, pubkey, options = {}) {
+    const commitment = options.commitment || SDK_COMMITMENTS.READ;
+    const retries = options.retries ?? 2;
+    const delayMs = options.delayMs ?? DEFAULT_RETRY_DELAY_MS;
+    const debug = options.debug || false;
+    let info = await connection.getAccountInfo(pubkey, commitment);
+    for (let attempt = 0; !info && attempt < retries; attempt++) {
+        const waitMs = backoffDelayMs(delayMs, attempt);
+        if (debug) {
+            console.log(`[FiveSDK] getAccountInfo retry ${attempt + 1}/${retries}, waiting ${waitMs}ms`);
+        }
+        await sleep(waitMs);
+        info = await connection.getAccountInfo(pubkey, commitment);
+    }
+    return info;
+}

package/dist/wasm/compiler/CompilationLogic.d.ts

@@ -1,10 +1,5 @@
 import { CompilationOptions, CompilationResult } from "../../types.js";
 import { CompilationContext } from "./types.js";
 export declare function compile(ctx: CompilationContext, source: string, options?: any): Promise<any>;
-export declare function compileModules(ctx: CompilationContext, mainSource: string, modules: Array<{
-    name: string;
-    source: string;
-}>, options?: any): Promise<any>;
 export declare function compileFile(ctx: CompilationContext, options: CompilationOptions): Promise<CompilationResult>;
 export declare function compileWithDiscovery(ctx: CompilationContext, entryPoint: string, options?: any): Promise<any>;
-export declare function compileModulesExplicit(ctx: CompilationContext, moduleFiles: string[], entryPoint: string, options?: any): Promise<any>;