@5ive-tech/sdk 1.1.13 → 1.1.15

package/dist/modules/deploy.js

@@ -1,9 +1,10 @@
 import { PDAUtils, RentCalculator } from "../crypto/index.js";
 import { validator, Validators } from "../validation/index.js";
 import { calculateDeployFee } from "./fees.js";
-import { confirmTransactionRobust, getAccountInfoWithRetry, pollForConfirmation, SDK_COMMITMENTS, } from "../utils/transaction.js";
+import { getAccountInfoWithRetry, sendAndConfirmRawTransactionRobust, SDK_COMMITMENTS, } from "../utils/transaction.js";
 import { ProgramIdResolver } from "../config/ProgramIdResolver.js";
 import { VmClusterConfigResolver } from "../config/VmClusterConfigResolver.js";
+import { SCRIPT_ACCOUNT_HEADER_LEN } from "../constants/headers.js";
 const DEFAULT_FEE_VAULT_SHARD_COUNT = (() => {
     try {
         return VmClusterConfigResolver.loadClusterConfig().feeVaultShardCount;
@@ -12,13 +13,28 @@ const DEFAULT_FEE_VAULT_SHARD_COUNT = (() => {
         return 2;
     }
 })();
+const MAX_FEE_VAULT_SHARD_COUNT = 8;
 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));
+    return Math.max(1, Math.min(MAX_FEE_VAULT_SHARD_COUNT, normalized));
+}
+function normalizeRpcEndpoint(connection) {
+    return String(connection?.rpcEndpoint || connection?._rpcEndpoint || "").toLowerCase();
+}
+function isLocalnetBootstrapConnection(connection, network) {
+    const normalizedNetwork = String(network || "").toLowerCase();
+    if (normalizedNetwork === "localnet") {
+        return true;
+    }
+    const endpoint = normalizeRpcEndpoint(connection);
+    return endpoint.includes("127.0.0.1") || endpoint.includes("localhost");
+}
+function selectBootstrapCommitment(connection, network) {
+    return isLocalnetBootstrapConnection(connection, network) ? "confirmed" : "finalized";
 }
 async function readVMStateFeeConfig(connection, vmStateAddress) {
     if (!connection) {
@@ -53,6 +69,25 @@ async function deriveProgramFeeVault(programId, shardIndex) {
     const [pda, bump] = PublicKey.findProgramAddressSync([FEE_VAULT_NAMESPACE_SEED, Buffer.from([shardIndex])], new PublicKey(programId));
     return { address: pda.toBase58(), bump };
 }
+async function resolveScriptAccountDerivation(bytecode, deployer, programId, options) {
+    const { PublicKey } = await import("@solana/web3.js");
+    if (options.scriptAccount) {
+        validator.validateBase58Address(options.scriptAccount, "options.scriptAccount");
+        if (!options.scriptSeed) {
+            throw new Error("options.scriptSeed is required when options.scriptAccount is provided");
+        }
+        const expectedAccount = await PublicKey.createWithSeed(new PublicKey(deployer), options.scriptSeed, new PublicKey(programId));
+        if (expectedAccount.toBase58() !== options.scriptAccount) {
+            throw new Error("options.scriptAccount does not match the derived address for the provided deployer, scriptSeed, and programId");
+        }
+        return {
+            address: options.scriptAccount,
+            bump: 0,
+            seed: options.scriptSeed,
+        };
+    }
+    return PDAUtils.deriveScriptAccount(bytecode, deployer, programId);
+}
 function createInitFeeVaultInstructionData(shardIndex, bump) {
     return Uint8Array.from([11, shardIndex & 0xff, bump & 0xff]);
 }
@@ -60,10 +95,24 @@ async function initProgramFeeVaultShards(connection, programId, vmStateAccount,
     const { PublicKey, Transaction, TransactionInstruction, SystemProgram } = await import("@solana/web3.js");
     const signatures = [];
     const effectiveShardCount = clampShardCount(shardCount);
+    const programPubkey = new PublicKey(programId);
+    const bootstrapCommitment = selectBootstrapCommitment(connection);
     for (let shardIndex = 0; shardIndex < effectiveShardCount; shardIndex++) {
         const vault = await deriveProgramFeeVault(programId, shardIndex);
+        const existingVault = await getAccountInfoWithRetry(connection, new PublicKey(vault.address), {
+            commitment: bootstrapCommitment,
+            retries: 1,
+            delayMs: 500,
+            debug: options.debug,
+        });
+        if (existingVault?.owner && new PublicKey(existingVault.owner).equals(programPubkey)) {
+            if (options.debug) {
+                console.log(`[FiveSDK] Fee vault shard ${shardIndex} already initialized: ${vault.address}`);
+            }
+            continue;
+        }
         const tx = new Transaction().add(new TransactionInstruction({
-            programId: new PublicKey(programId),
+            programId: programPubkey,
             keys: [
                 { pubkey: new PublicKey(vmStateAccount), isSigner: false, isWritable: false },
                 { pubkey: payer.publicKey, isSigner: true, isWritable: true },
@@ -72,24 +121,24 @@ async function initProgramFeeVaultShards(connection, programId, vmStateAccount,
             ],
             data: Buffer.from(createInitFeeVaultInstructionData(shardIndex, vault.bump)),
         }));
-        const { blockhash } = await connection.getLatestBlockhash("confirmed");
-        tx.recentBlockhash = blockhash;
+        const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+        tx.recentBlockhash = latestBlockhash.blockhash;
         tx.feePayer = payer.publicKey;
         tx.partialSign(payer);
-        const sig = await connection.sendRawTransaction(tx.serialize(), {
-            skipPreflight: true,
-            preflightCommitment: "confirmed",
-            maxRetries: options.maxRetries || 3,
-        });
-        const shardConfirm = await confirmTransactionRobust(connection, sig, {
-            commitment: "finalized",
+        const shardSend = await sendAndConfirmRawTransactionRobust(connection, tx.serialize(), {
+            commitment: bootstrapCommitment,
             timeoutMs: 120000,
             debug: options.debug,
+            maxRetries: options.maxRetries || 3,
+            skipPreflight: false,
+            preflightCommitment: "confirmed",
+            blockhash: latestBlockhash.blockhash,
+            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
         });
-        if (!shardConfirm.success) {
-            throw new Error(`Fee vault shard init failed: ${shardConfirm.error || "unconfirmed"}`);
+        if (!shardSend.success || !shardSend.signature) {
+            throw new Error(`Fee vault shard init failed: ${shardSend.error || "unconfirmed"}`);
         }
-        signatures.push(sig);
+        signatures.push(shardSend.signature);
         if (options.debug) {
             console.log(`[FiveSDK] Initialized fee vault shard ${shardIndex}: ${vault.address}`);
         }
@@ -100,9 +149,6 @@ export async function generateDeployInstruction(bytecode, deployer, options = {}
     Validators.bytecode(bytecode);
     validator.validateBase58Address(deployer, "deployer");
     Validators.options(options);
-    if (options.scriptAccount) {
-        validator.validateBase58Address(options.scriptAccount, "options.scriptAccount");
-    }
     // Resolve program ID with consistent precedence
     const programId = ProgramIdResolver.resolve(fiveVMProgramId || options.fiveVMProgramId);
     const exportMetadata = encodeExportMetadata(options.exportMetadata);
@@ -110,7 +156,7 @@ export async function generateDeployInstruction(bytecode, deployer, options = {}
         console.log(`[FiveSDK] Generating deployment transaction (${bytecode.length} bytes)...`);
         console.log(`[FiveSDK] Using program ID: ${programId}`);
     }
-    const scriptResult = await PDAUtils.deriveScriptAccount(bytecode, programId);
+    const scriptResult = await resolveScriptAccountDerivation(bytecode, deployer, programId, options);
     const scriptAccount = scriptResult.address;
     const scriptSeed = scriptResult.seed;
     const vmStatePDAResult = await PDAUtils.deriveVMStatePDA(programId);
@@ -119,9 +165,8 @@ export async function generateDeployInstruction(bytecode, deployer, options = {}
         console.log(`[FiveSDK] Script Account: ${scriptAccount} (seed: ${scriptSeed})`);
         console.log(`[FiveSDK] VM State PDA: ${vmStatePDA}`);
     }
-    const SCRIPT_HEADER_SIZE = 64; // ScriptAccountHeader size from Rust program
-    const totalAccountSize = SCRIPT_HEADER_SIZE + exportMetadata.length + bytecode.length;
-    const rentLamports = await RentCalculator.calculateRentExemption(totalAccountSize);
+    const totalAccountSize = SCRIPT_ACCOUNT_HEADER_LEN + exportMetadata.length + bytecode.length;
+    const rentLamports = await RentCalculator.calculateRentExemptionWithConnection(totalAccountSize, connection);
     const { deployFeeLamports } = await readVMStateFeeConfig(connection, vmStatePDA);
     const deployShardIndex = 0;
     const deployVault = await deriveProgramFeeVault(programId, deployShardIndex);
@@ -196,9 +241,8 @@ options = {}) {
     const scriptKeypair = Keypair.generate();
     const scriptAccount = scriptKeypair.publicKey.toString();
     // Calculate account size and rent
-    const SCRIPT_HEADER_SIZE = 64; // ScriptHeader::LEN
     const exportMetadata = encodeExportMetadata(options.exportMetadata);
-    const totalAccountSize = SCRIPT_HEADER_SIZE + exportMetadata.length + bytecode.length;
+    const totalAccountSize = SCRIPT_ACCOUNT_HEADER_LEN + exportMetadata.length + bytecode.length;
     const rentLamports = await connection.getMinimumBalanceForRentExemption(totalAccountSize);
     const vmStatePDA = await PDAUtils.deriveVMStatePDA(programIdStr);
     const vmStatePubkey = new PublicKey(vmStatePDA.address);
@@ -216,7 +260,8 @@ options = {}) {
         }));
     }
     // 1. Initialize canonical VM State if missing
-    const vmStateInfo = await connection.getAccountInfo(vmStatePubkey, "finalized");
+    const bootstrapCommitment = selectBootstrapCommitment(connection);
+    const vmStateInfo = await connection.getAccountInfo(vmStatePubkey, bootstrapCommitment);
     if (!vmStateInfo) {
         tx.add(new TransactionInstruction({
             keys: [
@@ -280,17 +325,18 @@ options = {}) {
             console.log(`[FiveSDK] Generated script keypair: ${scriptAccount}`);
         }
         // Calculate account size and rent
-        const SCRIPT_HEADER_SIZE = 64; // ScriptHeader::LEN (five-protocol)
         const exportMetadata = encodeExportMetadata(options.exportMetadata);
-        const totalAccountSize = SCRIPT_HEADER_SIZE + exportMetadata.length + bytecode.length;
+        const totalAccountSize = SCRIPT_ACCOUNT_HEADER_LEN + exportMetadata.length + bytecode.length;
         const rentLamports = await connection.getMinimumBalanceForRentExemption(totalAccountSize);
         const vmStateResolution = await ensureCanonicalVmStateAccount(connection, deployerKeypair, new PublicKey(programId), {
             vmStateAccount: options.vmStateAccount,
             maxRetries: options.maxRetries,
             debug: options.debug,
+            network: options.network,
         });
         const vmStatePubkey = vmStateResolution.vmStatePubkey;
         const vmStateRent = vmStateResolution.vmStateRent;
+        const bootstrapCommitment = selectBootstrapCommitment(connection, options.network);
         const vmStateFeeConfig = await readVMStateFeeConfig(connection, vmStatePubkey.toString());
         const deployShardIndex = 0;
         const deployVault = await deriveProgramFeeVault(programId, deployShardIndex);
@@ -313,7 +359,7 @@ options = {}) {
             console.log(`[FiveSDK] Export metadata size: ${exportMetadata.length} bytes`);
             console.log(`[FiveSDK] Rent cost: ${((rentLamports + vmStateRent) / 1e9)} SOL`);
         }
-        const feeVaultInitSigs = await initProgramFeeVaultShards(connection, programId, vmStatePubkey.toString(), vmStateFeeConfig.shardCount, deployerKeypair, { debug: options.debug, maxRetries: options.maxRetries });
+        const feeVaultInitSigs = await initProgramFeeVaultShards(connection, programId, vmStatePubkey.toString(), vmStateFeeConfig.shardCount, deployerKeypair, { debug: options.debug, maxRetries: options.maxRetries, network: options.network });
         // SINGLE TRANSACTION: create script account + deploy bytecode
         const tx = new Transaction();
         // Optional compute budget
@@ -378,19 +424,20 @@ options = {}) {
         if (options.debug) {
             console.log(`[FiveSDK] Transaction serialized: ${txSerialized.length} bytes`);
         }
-        const signature = await connection.sendRawTransaction(txSerialized, {
-            skipPreflight: true,
-            preflightCommitment: "confirmed",
+        const sendResult = await sendAndConfirmRawTransactionRobust(connection, txSerialized, {
+            commitment: "confirmed",
+            timeoutMs: 120000,
+            debug: options.debug,
             maxRetries: options.maxRetries || 3,
+            skipPreflight: false,
+            preflightCommitment: "confirmed",
         });
+        const signature = sendResult.signature;
         if (options.debug) {
             console.log(`[FiveSDK] sendRawTransaction completed, returned signature: ${signature}`);
         }
-        // Custom confirmation polling with extended timeout (120 seconds)
-        const confirmationResult = await pollForConfirmation(connection, signature, "confirmed", 120000, // 120 second timeout
-        options.debug);
-        if (!confirmationResult.success) {
-            const errorMessage = `Deployment confirmation failed: ${confirmationResult.error || "Unknown error"}`;
+        if (!sendResult.success || !signature) {
+            const errorMessage = `Deployment confirmation failed: ${sendResult.error || "Unknown error"}`;
             if (options.debug)
                 console.log(`[FiveSDK] ${errorMessage}`);
             return {
@@ -399,8 +446,8 @@ options = {}) {
                 transactionId: signature,
             };
         }
-        if (confirmationResult.err) {
-            const errorMessage = `Combined deployment failed: ${JSON.stringify(confirmationResult.err)}`;
+        if (sendResult.err) {
+            const errorMessage = `Combined deployment failed: ${JSON.stringify(sendResult.err)}`;
             if (options.debug)
                 console.log(`[FiveSDK] ${errorMessage}`);
             return {
@@ -468,8 +515,7 @@ options = {}) {
         const scriptKeypair = Keypair.generate();
         const scriptAccount = scriptKeypair.publicKey.toString();
         // Calculate account size and rent
-        const SCRIPT_HEADER_SIZE = 64; // ScriptHeader::LEN (five-protocol)
-        const totalAccountSize = SCRIPT_HEADER_SIZE + bytecode.length;
+        const totalAccountSize = SCRIPT_ACCOUNT_HEADER_LEN + bytecode.length;
         const rentLamports = await connection.getMinimumBalanceForRentExemption(totalAccountSize);
         const programIdStr = ProgramIdResolver.resolve(options.fiveVMProgramId);
         const programId = new PublicKey(programIdStr);
@@ -477,9 +523,11 @@ options = {}) {
             vmStateAccount: options.vmStateAccount,
             maxRetries: options.maxRetries,
             debug: options.debug,
+            network: options.network,
         });
         const vmStatePubkey = vmStateResolution.vmStatePubkey;
         const vmStateRent = vmStateResolution.vmStateRent;
+        const bootstrapCommitment = selectBootstrapCommitment(connection, options.network);
         const vmStateFeeConfig = await readVMStateFeeConfig(connection, vmStatePubkey.toString());
         const deployShardIndex = 0;
         const deployVault = await deriveProgramFeeVault(programIdStr, deployShardIndex);
@@ -501,7 +549,7 @@ options = {}) {
             console.log(`[FiveSDK] Total account size: ${totalAccountSize} bytes`);
             console.log(`[FiveSDK] Initial rent cost: ${(rentLamports + vmStateRent) / 1e9} SOL`);
         }
-        const feeVaultInitSigs = await initProgramFeeVaultShards(connection, programIdStr, vmStatePubkey.toString(), vmStateFeeConfig.shardCount, deployerKeypair, { debug: options.debug, maxRetries: options.maxRetries });
+        const feeVaultInitSigs = await initProgramFeeVaultShards(connection, programIdStr, vmStatePubkey.toString(), vmStateFeeConfig.shardCount, deployerKeypair, { debug: options.debug, maxRetries: options.maxRetries, network: options.network });
         const transactionIds = [];
         let totalCost = rentLamports + vmStateRent;
         // TRANSACTION 1: Create Account + InitLargeProgram
@@ -514,7 +562,7 @@ options = {}) {
             fromPubkey: deployerKeypair.publicKey,
             newAccountPubkey: scriptKeypair.publicKey,
             lamports: rentLamports,
-            space: SCRIPT_HEADER_SIZE, // Start with just header space
+            space: SCRIPT_ACCOUNT_HEADER_LEN, // Start with just the ScriptAccountHeader
             programId: programId,
         });
         initTransaction.add(createAccountInstruction);
@@ -535,7 +583,7 @@ options = {}) {
                 {
                     pubkey: vmStatePubkey,
                     isSigner: false,
-                    isWritable: false,
+                    isWritable: true,
                 },
                 ...feeVaultKeys,
             ],
@@ -545,23 +593,24 @@ options = {}) {
         initTransaction.add(initLargeProgramInstruction);
         // Sign and send initialization transaction
         initTransaction.feePayer = deployerKeypair.publicKey;
-        const { blockhash } = await connection.getLatestBlockhash("confirmed");
-        initTransaction.recentBlockhash = blockhash;
+        const initBlockhash = await connection.getLatestBlockhash("confirmed");
+        initTransaction.recentBlockhash = initBlockhash.blockhash;
         initTransaction.partialSign(deployerKeypair);
         initTransaction.partialSign(scriptKeypair);
-        const initSignature = await connection.sendRawTransaction(initTransaction.serialize(), {
-            skipPreflight: true,
-            preflightCommitment: "confirmed",
-            maxRetries: options.maxRetries || 3,
-        });
-        const initConfirm = await confirmTransactionRobust(connection, initSignature, {
-            commitment: "finalized",
+        const initSend = await sendAndConfirmRawTransactionRobust(connection, initTransaction.serialize(), {
+            commitment: bootstrapCommitment,
             timeoutMs: 120000,
             debug: options.debug,
+            maxRetries: options.maxRetries || 3,
+            skipPreflight: false,
+            preflightCommitment: "confirmed",
+            blockhash: initBlockhash.blockhash,
+            lastValidBlockHeight: initBlockhash.lastValidBlockHeight,
         });
-        if (!initConfirm.success) {
-            throw new Error(`Initialization confirmation failed: ${initConfirm.error || "unconfirmed"}`);
+        if (!initSend.success || !initSend.signature) {
+            throw new Error(`Initialization confirmation failed: ${initSend.error || "unconfirmed"}`);
         }
+        const initSignature = initSend.signature;
         transactionIds.push(initSignature);
         if (options.debug) {
             console.log(`[FiveSDK] ✅ Initialization completed: ${initSignature}`);
@@ -580,7 +629,7 @@ options = {}) {
                 console.log(`[FiveSDK] Step ${i + 2}: Appending chunk ${i + 1}/${chunks.length} (${chunk.length} bytes)`);
             }
             // Calculate additional rent needed for this chunk
-            const currentInfo = await getAccountInfoWithRetry(connection, scriptKeypair.publicKey, { commitment: "finalized", retries: 2, delayMs: 1000, debug: options.debug });
+            const currentInfo = await getAccountInfoWithRetry(connection, scriptKeypair.publicKey, { commitment: bootstrapCommitment, 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;
@@ -633,7 +682,7 @@ options = {}) {
                     {
                         pubkey: vmStatePubkey,
                         isSigner: false,
-                        isWritable: false,
+                        isWritable: true,
                     },
                     ...feeVaultKeys,
                 ],
@@ -646,19 +695,20 @@ options = {}) {
             appendTransaction.feePayer = deployerKeypair.publicKey;
             appendTransaction.recentBlockhash = appendBlockhash.blockhash;
             appendTransaction.partialSign(deployerKeypair);
-            const appendSignature = await connection.sendRawTransaction(appendTransaction.serialize(), {
-                skipPreflight: true,
-                preflightCommitment: "confirmed",
-                maxRetries: options.maxRetries || 3,
-            });
-            const appendConfirm = await confirmTransactionRobust(connection, appendSignature, {
-                commitment: "finalized",
+            const appendSend = await sendAndConfirmRawTransactionRobust(connection, appendTransaction.serialize(), {
+                commitment: bootstrapCommitment,
                 timeoutMs: 120000,
                 debug: options.debug,
+                maxRetries: options.maxRetries || 3,
+                skipPreflight: false,
+                preflightCommitment: "confirmed",
+                blockhash: appendBlockhash.blockhash,
+                lastValidBlockHeight: appendBlockhash.lastValidBlockHeight,
             });
-            if (!appendConfirm.success) {
-                throw new Error(`Append confirmation failed: ${appendConfirm.error || "unconfirmed"}`);
+            if (!appendSend.success || !appendSend.signature) {
+                throw new Error(`Append confirmation failed: ${appendSend.error || "unconfirmed"}`);
             }
+            const appendSignature = appendSend.signature;
             transactionIds.push(appendSignature);
             if (options.debug) {
                 console.log(`[FiveSDK] ✅ Chunk ${i + 1} appended: ${appendSignature}`);
@@ -666,7 +716,7 @@ options = {}) {
         }
         // Final verification
         let finalInfo = await getAccountInfoWithRetry(connection, scriptKeypair.publicKey, {
-            commitment: "finalized",
+            commitment: bootstrapCommitment,
             retries: 2,
             delayMs: 1000,
             debug: options.debug,
@@ -674,7 +724,7 @@ options = {}) {
         if (!finalInfo) {
             throw new Error("Script account not found during final verification");
         }
-        const expectedSize = SCRIPT_HEADER_SIZE + bytecode.length;
+        const expectedSize = SCRIPT_ACCOUNT_HEADER_LEN + bytecode.length;
         if (options.debug) {
             console.log(`[FiveSDK] 🔍 Final verification:`);
             console.log(`[FiveSDK] Expected size: ${expectedSize} bytes`);
@@ -738,8 +788,7 @@ options = {}) {
         const scriptKeypair = Keypair.generate();
         const scriptAccount = scriptKeypair.publicKey.toString();
         // Calculate full account size upfront
-        const SCRIPT_HEADER_SIZE = 64; // ScriptAccountHeader::LEN
-        const totalAccountSize = SCRIPT_HEADER_SIZE + bytecode.length;
+        const totalAccountSize = SCRIPT_ACCOUNT_HEADER_LEN + bytecode.length;
         const rentLamports = await connection.getMinimumBalanceForRentExemption(totalAccountSize);
         const programIdStr = ProgramIdResolver.resolve(options.fiveVMProgramId);
         const programId = new PublicKey(programIdStr);
@@ -747,9 +796,11 @@ options = {}) {
             vmStateAccount: options.vmStateAccount,
             maxRetries: options.maxRetries,
             debug: options.debug,
+            network: options.network,
         });
         const vmStatePubkey = vmStateResolution.vmStatePubkey;
         const vmStateRent = vmStateResolution.vmStateRent;
+        const bootstrapCommitment = selectBootstrapCommitment(connection, options.network);
         const vmStateFeeConfig = await readVMStateFeeConfig(connection, vmStatePubkey.toString());
         const deployShardIndex = 0;
         const deployVault = await deriveProgramFeeVault(programIdStr, deployShardIndex);
@@ -771,7 +822,7 @@ options = {}) {
             console.log(`[FiveSDK] PRE-ALLOCATED full account size: ${totalAccountSize} bytes`);
             console.log(`[FiveSDK] Full rent cost paid upfront: ${(rentLamports + vmStateRent) / 1e9} SOL`);
         }
-        const feeVaultInitSigs = await initProgramFeeVaultShards(connection, programIdStr, vmStatePubkey.toString(), vmStateFeeConfig.shardCount, deployerKeypair, { debug: options.debug, maxRetries: options.maxRetries });
+        const feeVaultInitSigs = await initProgramFeeVaultShards(connection, programIdStr, vmStatePubkey.toString(), vmStateFeeConfig.shardCount, deployerKeypair, { debug: options.debug, maxRetries: options.maxRetries, network: options.network });
         const transactionIds = [];
         let totalCost = rentLamports + vmStateRent;
         const chunks = chunkBytecode(bytecode, chunkSize);
@@ -808,7 +859,7 @@ options = {}) {
                 {
                     pubkey: vmStatePubkey,
                     isSigner: false,
-                    isWritable: false,
+                    isWritable: true,
                 },
                 ...feeVaultKeys,
             ],
@@ -821,19 +872,24 @@ options = {}) {
         initTransaction.recentBlockhash = blockhash;
         initTransaction.partialSign(deployerKeypair);
         initTransaction.partialSign(scriptKeypair);
-        const initSignature = await connection.sendRawTransaction(initTransaction.serialize(), {
-            skipPreflight: true,
-            preflightCommitment: "confirmed",
+        const initSend = await sendAndConfirmRawTransactionRobust(connection, initTransaction.serialize(), {
+            commitment: "confirmed",
+            timeoutMs: 120000,
+            debug: options.debug,
             maxRetries: options.maxRetries || 3,
+            skipPreflight: false,
+            preflightCommitment: "confirmed",
+            blockhash: blockhash,
+            lastValidBlockHeight: undefined,
         });
-        const initConfirmation = await pollForConfirmation(connection, initSignature, "confirmed", 120000, options.debug);
-        if (!initConfirmation.success) {
+        if (!initSend.success || !initSend.signature) {
             return {
                 success: false,
-                error: `Initialization confirmation failed: ${initConfirmation.error}`,
+                error: `Initialization confirmation failed: ${initSend.error}`,
                 transactionIds
             };
         }
+        const initSignature = initSend.signature;
         transactionIds.push(initSignature);
         if (options.debug) {
             console.log(`[FiveSDK] ✅ Optimized initialization completed: ${initSignature}`);
@@ -916,19 +972,24 @@ options = {}) {
                 appendTransaction.feePayer = deployerKeypair.publicKey;
                 appendTransaction.recentBlockhash = appendBlockhash.blockhash;
                 appendTransaction.partialSign(deployerKeypair);
-                const appendSignature = await connection.sendRawTransaction(appendTransaction.serialize(), {
-                    skipPreflight: true,
-                    preflightCommitment: "confirmed",
+                const appendSend = await sendAndConfirmRawTransactionRobust(connection, appendTransaction.serialize(), {
+                    commitment: bootstrapCommitment,
+                    timeoutMs: 120000,
+                    debug: options.debug,
                     maxRetries: options.maxRetries || 3,
+                    skipPreflight: false,
+                    preflightCommitment: "confirmed",
+                    blockhash: appendBlockhash.blockhash,
+                    lastValidBlockHeight: appendBlockhash.lastValidBlockHeight,
                 });
-                const appendConfirmation = await pollForConfirmation(connection, appendSignature, "finalized", 120000, options.debug);
-                if (!appendConfirmation.success) {
+                if (!appendSend.success || !appendSend.signature) {
                     return {
                         success: false,
-                        error: `Append confirmation failed: ${appendConfirmation.error}`,
+                        error: `Append confirmation failed: ${appendSend.error}`,
                         transactionIds
                     };
                 }
+                const appendSignature = appendSend.signature;
                 transactionIds.push(appendSignature);
                 if (options.debug) {
                     console.log(`[FiveSDK] ✅ Multi-chunk append completed: ${appendSignature}`);
@@ -962,17 +1023,20 @@ options = {}) {
         const finalizeBlockhash = await connection.getLatestBlockhash("confirmed");
         finalizeTransaction.recentBlockhash = finalizeBlockhash.blockhash;
         finalizeTransaction.partialSign(deployerKeypair);
-        const finalizeSignature = await connection.sendRawTransaction(finalizeTransaction.serialize(), {
-            skipPreflight: true,
-            preflightCommitment: "confirmed",
+        const finalizeSend = await sendAndConfirmRawTransactionRobust(connection, finalizeTransaction.serialize(), {
+            commitment: bootstrapCommitment,
+            timeoutMs: 120000,
+            debug: options.debug,
             maxRetries: options.maxRetries || 3,
+            skipPreflight: false,
+            preflightCommitment: "confirmed",
+            blockhash: finalizeBlockhash.blockhash,
+            lastValidBlockHeight: finalizeBlockhash.lastValidBlockHeight,
         });
-        // Use custom polling for finalize to handle validator latency
-        const finalizeConfirmation = await pollForConfirmation(connection, finalizeSignature, "finalized", 120000, // 120 second timeout
-        options.debug);
-        if (!finalizeConfirmation.success) {
-            console.error(`[FiveSDK] FinalizeScript confirmation failed: ${finalizeConfirmation.error}`);
+        if (!finalizeSend.success || !finalizeSend.signature) {
+            console.error(`[FiveSDK] FinalizeScript confirmation failed: ${finalizeSend.error}`);
         }
+        const finalizeSignature = finalizeSend.signature;
         transactionIds.push(finalizeSignature);
         if (options.debug) {
             console.log(`[FiveSDK] ✅ FinalizeScript completed: ${finalizeSignature}`);
@@ -1095,7 +1159,8 @@ 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, "finalized");
+    const bootstrapCommitment = selectBootstrapCommitment(connection, options.network);
+    const existing = await connection.getAccountInfo(vmStatePubkey, bootstrapCommitment);
     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()}`);
@@ -1125,14 +1190,18 @@ async function ensureCanonicalVmStateAccount(connection, deployerKeypair, progra
     const initBlockhash = await connection.getLatestBlockhash("confirmed");
     initTransaction.recentBlockhash = initBlockhash.blockhash;
     initTransaction.partialSign(deployerKeypair);
-    const initSignature = await connection.sendRawTransaction(initTransaction.serialize(), {
-        skipPreflight: true,
-        preflightCommitment: "confirmed",
+    const initSend = await sendAndConfirmRawTransactionRobust(connection, initTransaction.serialize(), {
+        commitment: "confirmed",
+        timeoutMs: 120000,
+        debug: options.debug,
         maxRetries: options.maxRetries || 3,
+        skipPreflight: false,
+        preflightCommitment: "confirmed",
+        blockhash: initBlockhash.blockhash,
+        lastValidBlockHeight: initBlockhash.lastValidBlockHeight,
     });
-    const initConfirmation = await pollForConfirmation(connection, initSignature, "confirmed", 120000, options.debug);
-    if (!initConfirmation.success || initConfirmation.err) {
-        throw new Error(`canonical VM state initialization failed: ${initConfirmation.error || JSON.stringify(initConfirmation.err)}`);
+    if (!initSend.success || initSend.err) {
+        throw new Error(`canonical VM state initialization failed: ${initSend.error || JSON.stringify(initSend.err)}`);
     }
     return { vmStatePubkey, vmStateRent, created: true, bump: canonical.bump };
 }

package/dist/modules/execute.d.ts

@@ -65,6 +65,11 @@ export declare function executeOnSolana(scriptAccount: string, connection: any,
     vmStateAccount?: string;
     fiveVMProgramId?: string;
     abi?: any;
+    accountMetadata?: Map<string, {
+        isSigner: boolean;
+        isWritable: boolean;
+        isSystemAccount?: boolean;
+    }>;
     feeShardIndex?: number;
     payerAccount?: string;
 }): Promise<{