@5ive-tech/sdk 1.1.8 → 1.1.10

package/dist/modules/deploy.js

@@ -3,6 +3,75 @@ import { validator, Validators } from "../validation/index.js";
 import { calculateDeployFee } from "./fees.js";
 import { pollForConfirmation } from "../utils/transaction.js";
 import { ProgramIdResolver } from "../config/ProgramIdResolver.js";
+const DEFAULT_FEE_VAULT_SHARD_COUNT = 10;
+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,
+]);
+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");
+        if (!info) {
+            return { shardCount: DEFAULT_FEE_VAULT_SHARD_COUNT };
+        }
+        const data = new Uint8Array(info.data);
+        if (data.length < 56) {
+            return { shardCount: DEFAULT_FEE_VAULT_SHARD_COUNT };
+        }
+        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;
+        return { deployFeeLamports, shardCount };
+    }
+    catch {
+        return { shardCount: DEFAULT_FEE_VAULT_SHARD_COUNT };
+    }
+}
+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));
+    return { address: pda.toBase58(), bump };
+}
+function createInitFeeVaultInstructionData(shardIndex, bump) {
+    return Uint8Array.from([11, shardIndex & 0xff, bump & 0xff]);
+}
+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 vault = await deriveProgramFeeVault(programId, shardIndex);
+        const tx = new Transaction().add(new TransactionInstruction({
+            programId: new PublicKey(programId),
+            keys: [
+                { pubkey: new PublicKey(vmStateAccount), isSigner: false, isWritable: false },
+                { pubkey: payer.publicKey, isSigner: true, isWritable: true },
+                { pubkey: new PublicKey(vault.address), isSigner: false, isWritable: true },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            ],
+            data: Buffer.from(createInitFeeVaultInstructionData(shardIndex, vault.bump)),
+        }));
+        const { blockhash } = await connection.getLatestBlockhash("confirmed");
+        tx.recentBlockhash = blockhash;
+        tx.feePayer = payer.publicKey;
+        tx.partialSign(payer);
+        const sig = await connection.sendRawTransaction(tx.serialize(), {
+            skipPreflight: true,
+            preflightCommitment: "confirmed",
+            maxRetries: options.maxRetries || 3,
+        });
+        await connection.confirmTransaction(sig, "confirmed");
+        signatures.push(sig);
+        if (options.debug) {
+            console.log(`[FiveSDK] Initialized fee vault shard ${shardIndex}: ${vault.address}`);
+        }
+    }
+    return signatures;
+}
 export async function generateDeployInstruction(bytecode, deployer, options = {}, connection, fiveVMProgramId) {
     Validators.bytecode(bytecode);
     validator.validateBase58Address(deployer, "deployer");
@@ -29,24 +98,21 @@ export async function generateDeployInstruction(bytecode, deployer, options = {}
     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 { deployFeeLamports } = await readVMStateFeeConfig(connection, vmStatePDA);
+    const deployShardIndex = 0;
+    const deployVault = await deriveProgramFeeVault(programId, deployShardIndex);
     const deployAccounts = [
         { pubkey: scriptAccount, isSigner: false, isWritable: true },
         { pubkey: vmStatePDA, isSigner: false, isWritable: true },
         { pubkey: deployer, isSigner: true, isWritable: true },
-        {
-            pubkey: "11111111111111111111111111111112",
-            isSigner: false,
-            isWritable: false,
-        },
+        { pubkey: deployVault.address, isSigner: false, isWritable: true },
     ];
-    if (options.adminAccount) {
-        deployAccounts.push({
-            pubkey: options.adminAccount,
-            isSigner: false,
-            isWritable: true,
-        });
-    }
-    const instructionData = encodeDeployInstruction(bytecode, options.permissions || 0, exportMetadata);
+    deployAccounts.push({
+        pubkey: "11111111111111111111111111111111",
+        isSigner: false,
+        isWritable: false,
+    });
+    const instructionData = encodeDeployInstruction(bytecode, options.permissions || 0, exportMetadata, deployShardIndex, deployVault.bump);
     const result = {
         programId: programId,
         instruction: {
@@ -110,14 +176,12 @@ options = {}) {
     const exportMetadata = encodeExportMetadata(options.exportMetadata);
     const totalAccountSize = SCRIPT_HEADER_SIZE + exportMetadata.length + bytecode.length;
     const rentLamports = await connection.getMinimumBalanceForRentExemption(totalAccountSize);
-    // Generate VM state keypair
-    const vmStateKeypair = Keypair.generate();
-    const VM_STATE_SIZE = 56; // FIVEVMState::LEN
-    const vmStateRent = await connection.getMinimumBalanceForRentExemption(VM_STATE_SIZE);
+    const vmStatePDA = await PDAUtils.deriveVMStatePDA(programIdStr);
+    const vmStatePubkey = new PublicKey(vmStatePDA.address);
     if (options.debug) {
         console.log(`[FiveSDK] Preparing deployment transaction:`);
         console.log(`  - Script Account: ${scriptAccount}`);
-        console.log(`  - VM State Account: ${vmStateKeypair.publicKey.toString()}`);
+        console.log(`  - VM State Account: ${vmStatePubkey.toString()}`);
         console.log(`  - Deployer: ${deployerPublicKey.toString()}`);
     }
     const tx = new Transaction();
@@ -127,24 +191,21 @@ options = {}) {
             units: options.computeBudget,
         }));
     }
-    // 1. Create VM State Account
-    tx.add(SystemProgram.createAccount({
-        fromPubkey: deployerPublicKey,
-        newAccountPubkey: vmStateKeypair.publicKey,
-        lamports: vmStateRent,
-        space: VM_STATE_SIZE,
-        programId: programId,
-    }));
-    // 2. Initialize VM State
-    tx.add(new TransactionInstruction({
-        keys: [
-            { pubkey: vmStateKeypair.publicKey, isSigner: false, isWritable: true },
-            { pubkey: deployerPublicKey, isSigner: true, isWritable: false },
-        ],
-        programId: programId,
-        data: Buffer.from([0]), // Initialize discriminator
-    }));
-    // 3. Create Script Account
+    // 1. Initialize canonical VM State if missing
+    const vmStateInfo = await connection.getAccountInfo(vmStatePubkey);
+    if (!vmStateInfo) {
+        tx.add(new TransactionInstruction({
+            keys: [
+                { pubkey: vmStatePubkey, isSigner: false, isWritable: true },
+                { pubkey: deployerPublicKey, isSigner: true, isWritable: false },
+                { pubkey: deployerPublicKey, isSigner: true, isWritable: true },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            ],
+            programId: programId,
+            data: buildInitializeVmStateInstructionData(vmStatePDA.bump),
+        }));
+    }
+    // 2. Create Script Account
     tx.add(SystemProgram.createAccount({
         fromPubkey: deployerPublicKey,
         newAccountPubkey: scriptKeypair.publicKey,
@@ -152,12 +213,12 @@ options = {}) {
         space: totalAccountSize,
         programId: programId,
     }));
-    // 4. Deploy Instruction
+    // 3. Deploy Instruction
     const deployData = encodeDeployInstruction(bytecode, 0, exportMetadata);
     tx.add(new TransactionInstruction({
         keys: [
             { pubkey: scriptKeypair.publicKey, isSigner: false, isWritable: true },
-            { pubkey: vmStateKeypair.publicKey, isSigner: false, isWritable: true },
+            { pubkey: vmStatePubkey, isSigner: false, isWritable: true },
             { pubkey: deployerPublicKey, isSigner: true, isWritable: true },
         ],
         programId: programId,
@@ -168,11 +229,10 @@ options = {}) {
     tx.feePayer = deployerPublicKey;
     // Partial sign with generated keys
     tx.partialSign(scriptKeypair);
-    tx.partialSign(vmStateKeypair);
     return {
         transaction: tx,
         scriptKeypair,
-        vmStateKeypair,
+        vmStateKeypair: null,
         programId: scriptAccount,
         rentLamports,
     };
@@ -200,22 +260,28 @@ options = {}) {
         const exportMetadata = encodeExportMetadata(options.exportMetadata);
         const totalAccountSize = SCRIPT_HEADER_SIZE + exportMetadata.length + bytecode.length;
         const rentLamports = await connection.getMinimumBalanceForRentExemption(totalAccountSize);
-        // Generate VM state keypair for this deployment OR reuse
-        let vmStatePubkey;
-        let vmStateKeypair;
-        let vmStateRent = 0;
-        const VM_STATE_SIZE = 56; // FIVEVMState::LEN
-        if (options.vmStateAccount) {
-            vmStatePubkey = new PublicKey(options.vmStateAccount);
-            if (options.debug) {
-                console.log(`[FiveSDK] Reuse VM State: ${vmStatePubkey.toString()}`);
-            }
-        }
-        else {
-            vmStateKeypair = Keypair.generate();
-            vmStatePubkey = vmStateKeypair.publicKey;
-            vmStateRent = await connection.getMinimumBalanceForRentExemption(VM_STATE_SIZE);
-        }
+        const vmStateResolution = await ensureCanonicalVmStateAccount(connection, deployerKeypair, new PublicKey(programId), {
+            vmStateAccount: options.vmStateAccount,
+            maxRetries: options.maxRetries,
+            debug: options.debug,
+        });
+        const vmStatePubkey = vmStateResolution.vmStatePubkey;
+        const vmStateRent = vmStateResolution.vmStateRent;
+        const vmStateFeeConfig = await readVMStateFeeConfig(connection, vmStatePubkey.toString());
+        const deployShardIndex = 0;
+        const deployVault = await deriveProgramFeeVault(programId, deployShardIndex);
+        const feeVaultKeys = [
+            {
+                pubkey: new PublicKey(deployVault.address),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: SystemProgram.programId,
+                isSigner: false,
+                isWritable: false,
+            },
+        ];
         if (options.debug) {
             console.log(`[FiveSDK] Script Account: ${scriptAccount}`);
             console.log(`[FiveSDK] VM State Account: ${vmStatePubkey.toString()}`);
@@ -223,7 +289,8 @@ options = {}) {
             console.log(`[FiveSDK] Export metadata size: ${exportMetadata.length} bytes`);
             console.log(`[FiveSDK] Rent cost: ${((rentLamports + vmStateRent) / 1e9)} SOL`);
         }
-        // SINGLE TRANSACTION: create VM state + initialize + create script account + deploy bytecode
+        const feeVaultInitSigs = await initProgramFeeVaultShards(connection, programId, vmStatePubkey.toString(), vmStateFeeConfig.shardCount, deployerKeypair, { debug: options.debug, maxRetries: options.maxRetries });
+        // SINGLE TRANSACTION: create script account + deploy bytecode
         const tx = new Transaction();
         // Optional compute budget
         if (options.computeBudget && options.computeBudget > 0) {
@@ -235,36 +302,7 @@ options = {}) {
             }
             catch { }
         }
-        if (!options.vmStateAccount) {
-            // 1) Create VM state account owned by the program
-            const createVmStateIx = SystemProgram.createAccount({
-                fromPubkey: deployerKeypair.publicKey,
-                newAccountPubkey: vmStatePubkey,
-                lamports: vmStateRent,
-                space: VM_STATE_SIZE,
-                programId: new PublicKey(programId),
-            });
-            tx.add(createVmStateIx);
-            // 2) Initialize VM state: [discriminator(0)] with accounts [vm_state, authority]
-            const initVmStateIx = new TransactionInstruction({
-                keys: [
-                    {
-                        pubkey: vmStatePubkey,
-                        isSigner: false,
-                        isWritable: true,
-                    },
-                    {
-                        pubkey: deployerKeypair.publicKey,
-                        isSigner: true,
-                        isWritable: false,
-                    },
-                ],
-                programId: new PublicKey(programId),
-                data: Buffer.from([0]), // Initialize discriminator
-            });
-            tx.add(initVmStateIx);
-        }
-        // 3) Create script account
+        // 1) Create script account
         const createAccountIx = SystemProgram.createAccount({
             fromPubkey: deployerKeypair.publicKey,
             newAccountPubkey: scriptKeypair.publicKey,
@@ -273,7 +311,7 @@ options = {}) {
             programId: new PublicKey(programId),
         });
         tx.add(createAccountIx);
-        const deployData = encodeDeployInstruction(bytecode, 0, exportMetadata);
+        const deployData = encodeDeployInstruction(bytecode, 0, exportMetadata, deployShardIndex, deployVault.bump);
         const instructionDataBuffer = Buffer.from(deployData);
         const deployIx = new TransactionInstruction({
             keys: [
@@ -292,6 +330,16 @@ options = {}) {
                     isSigner: true,
                     isWritable: true,
                 },
+                {
+                    pubkey: new PublicKey(deployVault.address),
+                    isSigner: false,
+                    isWritable: true,
+                },
+                {
+                    pubkey: SystemProgram.programId,
+                    isSigner: false,
+                    isWritable: false,
+                },
             ],
             programId: new PublicKey(programId),
             data: instructionDataBuffer,
@@ -301,9 +349,6 @@ options = {}) {
         tx.recentBlockhash = blockhash;
         tx.feePayer = deployerKeypair.publicKey;
         tx.partialSign(deployerKeypair);
-        if (!options.vmStateAccount) {
-            tx.partialSign(vmStateKeypair);
-        }
         tx.partialSign(scriptKeypair);
         const txSerialized = tx.serialize();
         if (options.debug) {
@@ -347,13 +392,14 @@ options = {}) {
             success: true,
             programId: scriptAccount,
             transactionId: signature,
-            deploymentCost: rentLamports,
+            deploymentCost: rentLamports + vmStateRent,
             logs: [
                 `Script Account: ${scriptAccount}`,
                 `Deployment TX: ${signature}`,
                 `Deployment cost (rent): ${rentLamports / 1e9} SOL`,
                 `Bytecode size: ${bytecode.length} bytes`,
                 `VM State Account: ${vmStatePubkey.toString()}`,
+                `Fee vault shards initialized: ${feeVaultInitSigs.length}`,
             ],
             vmStateAccount: vmStatePubkey.toString(),
         };
@@ -380,7 +426,7 @@ options = {}) {
     console.log(`[FiveSDK] options:`, options);
     try {
         // If bytecode is small enough, use regular deployment
-        if (bytecode.length <= 800) {
+        if (bytecode.length <= 800 && !options.forceChunkedSmallProgram) {
             if (options.debug) {
                 console.log(`[FiveSDK] Bytecode is small (${bytecode.length} bytes), using regular deployment`);
             }
@@ -390,6 +436,7 @@ options = {}) {
                 maxRetries: options.maxRetries,
                 fiveVMProgramId: options.fiveVMProgramId,
                 vmStateAccount: options.vmStateAccount,
+                adminAccount: options.adminAccount,
             });
         }
         const { Keypair, PublicKey, Transaction, TransactionInstruction, SystemProgram, } = await import("@solana/web3.js");
@@ -402,76 +449,37 @@ options = {}) {
         const rentLamports = await connection.getMinimumBalanceForRentExemption(totalAccountSize);
         const programIdStr = ProgramIdResolver.resolve(options.fiveVMProgramId);
         const programId = new PublicKey(programIdStr);
-        // Handle VM state account (reuse or create)
-        let vmStatePubkey;
-        let vmStateKeypair;
-        let vmStateRent = 0;
-        const VM_STATE_SIZE = 56; // FIVEVMState::LEN
-        if (options.vmStateAccount) {
-            vmStatePubkey = new PublicKey(options.vmStateAccount);
-            if (options.debug) {
-                console.log(`[FiveSDK] Reuse existing VM State: ${vmStatePubkey.toString()}`);
-            }
-        }
-        else {
-            // Generate NEW VM state account
-            vmStateKeypair = Keypair.generate();
-            vmStatePubkey = vmStateKeypair.publicKey;
-            vmStateRent = await connection.getMinimumBalanceForRentExemption(VM_STATE_SIZE);
-        }
+        const vmStateResolution = await ensureCanonicalVmStateAccount(connection, deployerKeypair, programId, {
+            vmStateAccount: options.vmStateAccount,
+            maxRetries: options.maxRetries,
+            debug: options.debug,
+        });
+        const vmStatePubkey = vmStateResolution.vmStatePubkey;
+        const vmStateRent = vmStateResolution.vmStateRent;
+        const vmStateFeeConfig = await readVMStateFeeConfig(connection, vmStatePubkey.toString());
+        const deployShardIndex = 0;
+        const deployVault = await deriveProgramFeeVault(programIdStr, deployShardIndex);
+        const feeVaultKeys = [
+            {
+                pubkey: new PublicKey(deployVault.address),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: SystemProgram.programId,
+                isSigner: false,
+                isWritable: false,
+            },
+        ];
         if (options.debug) {
             console.log(`[FiveSDK] Script Account: ${scriptAccount}`);
             console.log(`[FiveSDK] VM State Account: ${vmStatePubkey.toString()}`);
             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 transactionIds = [];
         let totalCost = rentLamports + vmStateRent;
-        // TRANSACTION 0: Create VM State Account + Initialize (ONLY IF CREATING NEW)
-        if (!options.vmStateAccount) {
-            if (options.debug) {
-                console.log(`[FiveSDK] Step 0: Create VM state account and initialize`);
-            }
-            const vmStateTransaction = new Transaction();
-            vmStateTransaction.add(SystemProgram.createAccount({
-                fromPubkey: deployerKeypair.publicKey,
-                newAccountPubkey: vmStateKeypair.publicKey,
-                lamports: vmStateRent,
-                space: VM_STATE_SIZE,
-                programId: programId,
-            }));
-            vmStateTransaction.add(new TransactionInstruction({
-                keys: [
-                    {
-                        pubkey: vmStateKeypair.publicKey,
-                        isSigner: false,
-                        isWritable: true,
-                    },
-                    {
-                        pubkey: deployerKeypair.publicKey,
-                        isSigner: true,
-                        isWritable: false,
-                    },
-                ],
-                programId: programId,
-                data: Buffer.from([0]), // Initialize discriminator
-            }));
-            vmStateTransaction.feePayer = deployerKeypair.publicKey;
-            const vmStateBlockhash = await connection.getLatestBlockhash("confirmed");
-            vmStateTransaction.recentBlockhash = vmStateBlockhash.blockhash;
-            vmStateTransaction.partialSign(deployerKeypair);
-            vmStateTransaction.partialSign(vmStateKeypair);
-            const vmStateSignature = await connection.sendRawTransaction(vmStateTransaction.serialize(), {
-                skipPreflight: true,
-                preflightCommitment: "confirmed",
-                maxRetries: options.maxRetries || 3,
-            });
-            await connection.confirmTransaction(vmStateSignature, "confirmed");
-            transactionIds.push(vmStateSignature);
-            if (options.debug) {
-                console.log(`[FiveSDK] ✅ VM state initialized: ${vmStateSignature}`);
-            }
-        }
         // TRANSACTION 1: Create Account + InitLargeProgram
         if (options.debug) {
             console.log(`[FiveSDK] Step 1: Create account and initialize large program`);
@@ -487,10 +495,7 @@ options = {}) {
         });
         initTransaction.add(createAccountInstruction);
         // Add InitLargeProgram instruction (discriminator 4 + expected_size as u32)
-        const initInstructionData = Buffer.concat([
-            Buffer.from([4]), // InitLargeProgram discriminator
-            Buffer.from(new Uint32Array([bytecode.length]).buffer), // expected_size as little-endian u32
-        ]);
+        const initInstructionData = createInitLargeProgramInstructionData(bytecode.length);
         const initLargeProgramInstruction = new TransactionInstruction({
             keys: [
                 {
@@ -506,8 +511,9 @@ options = {}) {
                 {
                     pubkey: vmStatePubkey,
                     isSigner: false,
-                    isWritable: true,
+                    isWritable: false,
                 },
+                ...feeVaultKeys,
             ],
             programId: programId,
             data: initInstructionData,
@@ -587,10 +593,7 @@ options = {}) {
                 totalCost += additionalRent;
             }
             // Add AppendBytecode instruction (discriminator 5 + chunk data)
-            const appendInstructionData = Buffer.concat([
-                Buffer.from([5]), // AppendBytecode discriminator
-                chunk,
-            ]);
+            const appendInstructionData = createAppendBytecodeInstructionData(chunk);
             const appendBytecodeInstruction = new TransactionInstruction({
                 keys: [
                     {
@@ -606,8 +609,9 @@ options = {}) {
                     {
                         pubkey: vmStatePubkey,
                         isSigner: false,
-                        isWritable: true,
+                        isWritable: false,
                     },
+                    ...feeVaultKeys,
                 ],
                 programId: programId,
                 data: appendInstructionData,
@@ -648,6 +652,7 @@ options = {}) {
             vmStateAccount: vmStatePubkey.toString(),
             logs: [
                 `Deployed ${bytecode.length} bytes in ${chunks.length} chunks using ${transactionIds.length} transactions`,
+                `Fee vault shards initialized: ${feeVaultInitSigs.length}`,
             ],
         };
     }
@@ -675,7 +680,7 @@ options = {}) {
     console.log(`[FiveSDK] Expected optimization: 50-70% fewer transactions`);
     try {
         // If bytecode is small enough, use regular deployment
-        if (bytecode.length <= 800) {
+        if (bytecode.length <= 800 && !options.forceChunkedSmallProgram) {
             if (options.debug) {
                 console.log(`[FiveSDK] Bytecode is small (${bytecode.length} bytes), using regular deployment`);
             }
@@ -683,6 +688,10 @@ options = {}) {
                 debug: options.debug,
                 network: options.network,
                 maxRetries: options.maxRetries,
+                fiveVMProgramId: options.fiveVMProgramId,
+                vmStateAccount: options.vmStateAccount,
+                adminAccount: options.adminAccount,
+                exportMetadata: options.exportMetadata,
             });
         }
         const { Keypair, PublicKey, Transaction, TransactionInstruction, SystemProgram, } = await import("@solana/web3.js");
@@ -690,72 +699,42 @@ options = {}) {
         const scriptKeypair = Keypair.generate();
         const scriptAccount = scriptKeypair.publicKey.toString();
         // Calculate full account size upfront
-        const SCRIPT_HEADER_SIZE = 128; // FIVEScriptHeaderV2::LEN
+        const SCRIPT_HEADER_SIZE = 64; // ScriptAccountHeader::LEN
         const totalAccountSize = SCRIPT_HEADER_SIZE + bytecode.length;
         const rentLamports = await connection.getMinimumBalanceForRentExemption(totalAccountSize);
         const programIdStr = ProgramIdResolver.resolve(options.fiveVMProgramId);
         const programId = new PublicKey(programIdStr);
-        // Generate VM state account for this deployment
-        const vmStateKeypair = Keypair.generate();
-        const VM_STATE_SIZE = 56; // FIVEVMState::LEN (32 + 8 + 4 + 4 + 1 + 7)
-        const vmStateRent = await connection.getMinimumBalanceForRentExemption(VM_STATE_SIZE);
+        const vmStateResolution = await ensureCanonicalVmStateAccount(connection, deployerKeypair, programId, {
+            vmStateAccount: options.vmStateAccount,
+            maxRetries: options.maxRetries,
+            debug: options.debug,
+        });
+        const vmStatePubkey = vmStateResolution.vmStatePubkey;
+        const vmStateRent = vmStateResolution.vmStateRent;
+        const vmStateFeeConfig = await readVMStateFeeConfig(connection, vmStatePubkey.toString());
+        const deployShardIndex = 0;
+        const deployVault = await deriveProgramFeeVault(programIdStr, deployShardIndex);
+        const feeVaultKeys = [
+            {
+                pubkey: new PublicKey(deployVault.address),
+                isSigner: false,
+                isWritable: true,
+            },
+            {
+                pubkey: SystemProgram.programId,
+                isSigner: false,
+                isWritable: false,
+            },
+        ];
         if (options.debug) {
             console.log(`[FiveSDK] Script Account: ${scriptAccount}`);
-            console.log(`[FiveSDK] VM State Account: ${vmStateKeypair.publicKey.toString()}`);
+            console.log(`[FiveSDK] VM State Account: ${vmStatePubkey.toString()}`);
             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 transactionIds = [];
         let totalCost = rentLamports + vmStateRent;
-        if (options.debug) {
-            console.log(`[FiveSDK] Create VM state account and initialize`);
-        }
-        const vmStateTransaction = new Transaction();
-        vmStateTransaction.add(SystemProgram.createAccount({
-            fromPubkey: deployerKeypair.publicKey,
-            newAccountPubkey: vmStateKeypair.publicKey,
-            lamports: vmStateRent,
-            space: VM_STATE_SIZE,
-            programId: programId,
-        }));
-        vmStateTransaction.add(new TransactionInstruction({
-            keys: [
-                {
-                    pubkey: vmStateKeypair.publicKey,
-                    isSigner: false,
-                    isWritable: true,
-                },
-                {
-                    pubkey: deployerKeypair.publicKey,
-                    isSigner: true,
-                    isWritable: false,
-                },
-            ],
-            programId: programId,
-            data: Buffer.from([0]), // Initialize discriminator
-        }));
-        vmStateTransaction.feePayer = deployerKeypair.publicKey;
-        const vmStateBlockhash = await connection.getLatestBlockhash("confirmed");
-        vmStateTransaction.recentBlockhash = vmStateBlockhash.blockhash;
-        vmStateTransaction.partialSign(deployerKeypair);
-        vmStateTransaction.partialSign(vmStateKeypair);
-        const vmStateSignature = await connection.sendRawTransaction(vmStateTransaction.serialize(), {
-            skipPreflight: true,
-            preflightCommitment: "confirmed",
-            maxRetries: options.maxRetries || 3,
-        });
-        const vmStateConfirmation = await pollForConfirmation(connection, vmStateSignature, "confirmed", 120000, options.debug);
-        if (!vmStateConfirmation.success) {
-            return {
-                success: false,
-                error: `VM state initialization confirmation failed: ${vmStateConfirmation.error}`,
-                transactionIds: [vmStateSignature]
-            };
-        }
-        transactionIds.push(vmStateSignature);
-        if (options.debug) {
-            console.log(`[FiveSDK] ✅ VM state initialized: ${vmStateSignature}`);
-        }
         const chunks = chunkBytecode(bytecode, chunkSize);
         const firstChunk = chunks[0];
         const remainingChunks = chunks.slice(1);
@@ -774,13 +753,7 @@ options = {}) {
             programId: programId,
         });
         initTransaction.add(createAccountInstruction);
-        const sizeBuffer = Buffer.allocUnsafe(4);
-        sizeBuffer.writeUInt32LE(bytecode.length, 0);
-        const initInstructionData = Buffer.concat([
-            Buffer.from([4]), // InitLargeProgramWithChunk discriminator (same as InitLargeProgram)
-            sizeBuffer,
-            firstChunk,
-        ]);
+        const initInstructionData = createInitLargeProgramInstructionData(bytecode.length, firstChunk);
         const initLargeProgramWithChunkInstruction = new TransactionInstruction({
             keys: [
                 {
@@ -794,10 +767,11 @@ options = {}) {
                     isWritable: true,
                 },
                 {
-                    pubkey: vmStateKeypair.publicKey,
+                    pubkey: vmStatePubkey,
                     isSigner: false,
-                    isWritable: true,
+                    isWritable: false,
                 },
+                ...feeVaultKeys,
             ],
             programId: programId,
             data: initInstructionData,
@@ -847,10 +821,7 @@ options = {}) {
                     if (options.debug) {
                         console.log(`[FiveSDK] Using single-chunk AppendBytecode for remaining chunk (${chunkGroup[0].length} bytes)`);
                     }
-                    const singleChunkData = Buffer.concat([
-                        Buffer.from([5]), // AppendBytecode discriminator
-                        Buffer.from(chunkGroup[0]),
-                    ]);
+                    const singleChunkData = createAppendBytecodeInstructionData(chunkGroup[0]);
                     appendInstruction = new TransactionInstruction({
                         keys: [
                             {
@@ -864,10 +835,11 @@ options = {}) {
                                 isWritable: true,
                             },
                             {
-                                pubkey: vmStateKeypair.publicKey,
+                                pubkey: vmStatePubkey,
                                 isSigner: false,
                                 isWritable: true,
                             },
+                            ...feeVaultKeys,
                         ],
                         programId: programId,
                         data: singleChunkData,
@@ -889,10 +861,11 @@ options = {}) {
                                 isWritable: true,
                             },
                             {
-                                pubkey: vmStateKeypair.publicKey,
+                                pubkey: vmStatePubkey,
                                 isSigner: false,
                                 isWritable: true,
                             },
+                            ...feeVaultKeys,
                         ],
                         programId: programId,
                         data: multiChunkData,
@@ -941,9 +914,10 @@ options = {}) {
                     isSigner: true,
                     isWritable: true,
                 },
+                ...feeVaultKeys,
             ],
             programId: programId,
-            data: Buffer.from([7]), // FinalizeScript discriminator
+            data: createFinalizeScriptInstructionData(),
         }));
         finalizeTransaction.feePayer = deployerKeypair.publicKey;
         const finalizeBlockhash = await connection.getLatestBlockhash("confirmed");
@@ -983,7 +957,7 @@ options = {}) {
             totalTransactions: optimizedTransactionCount,
             deploymentCost: totalCost,
             chunksUsed: chunks.length,
-            vmStateAccount: vmStateKeypair.publicKey.toString(),
+            vmStateAccount: vmStatePubkey.toString(),
             optimizationSavings: {
                 transactionsSaved,
                 estimatedCostSaved,
@@ -994,6 +968,7 @@ options = {}) {
                 `💰 Cost: ${totalCost / 1e9} SOL`,
                 `🧩 Chunks: ${chunks.length}`,
                 `⚡ Optimization: ${Math.round((transactionsSaved / traditionalTransactionCount) * 100)}% fewer transactions`,
+                `🏦 Fee vault shards initialized: ${feeVaultInitSigs.length}`,
             ],
         };
     }
@@ -1007,18 +982,24 @@ options = {}) {
         };
     }
 }
-function encodeDeployInstruction(bytecode, permissions = 0, metadata = new Uint8Array()) {
+function encodeDeployInstruction(bytecode, permissions = 0, metadata = new Uint8Array(), feeShardIndex = 0, feeVaultBump) {
     const lengthBuffer = Buffer.allocUnsafe(4);
     lengthBuffer.writeUInt32LE(bytecode.length, 0);
     const metadataLenBuffer = Buffer.allocUnsafe(4);
     metadataLenBuffer.writeUInt32LE(metadata.length, 0);
-    const result = new Uint8Array(1 + 4 + 1 + 4 + metadata.length + bytecode.length);
+    const hasFeeTrailer = typeof feeVaultBump === "number";
+    const result = new Uint8Array(1 + 4 + 1 + 4 + metadata.length + bytecode.length + (hasFeeTrailer ? 2 : 0));
     result[0] = 8; // Deploy discriminator (matches on-chain FIVE program)
     result.set(new Uint8Array(lengthBuffer), 1); // u32 LE length at bytes 1-4
     result[5] = permissions; // permissions byte at byte 5
     result.set(new Uint8Array(metadataLenBuffer), 6); // metadata length at bytes 6-9
     result.set(metadata, 10);
     result.set(bytecode, 10 + metadata.length);
+    if (hasFeeTrailer) {
+        const trailerOffset = 10 + metadata.length + bytecode.length;
+        result[trailerOffset] = feeShardIndex & 0xff;
+        result[trailerOffset + 1] = feeVaultBump & 0xff;
+    }
     console.log(`[FiveSDK] Deploy instruction encoded:`, {
         discriminator: result[0],
         lengthBytes: Array.from(new Uint8Array(lengthBuffer)),
@@ -1026,7 +1007,7 @@ function encodeDeployInstruction(bytecode, permissions = 0, metadata = new Uint8
         metadataLength: metadata.length,
         bytecodeLength: bytecode.length,
         totalInstructionLength: result.length,
-        expectedFormat: `[8, ${bytecode.length}_as_u32le, 0x${permissions.toString(16).padStart(2, '0')}, ${metadata.length}_as_u32le, metadata_bytes, bytecode_bytes]`,
+        expectedFormat: `[8, ${bytecode.length}_as_u32le, 0x${permissions.toString(16).padStart(2, '0')}, ${metadata.length}_as_u32le, metadata_bytes, bytecode_bytes, optional(shard,bump)]`,
         instructionHex: Buffer.from(result).toString("hex").substring(0, 20) + "...",
     });
     return result;
@@ -1068,6 +1049,54 @@ function encodeExportMetadata(input) {
     }
     return Uint8Array.from(out);
 }
+async function ensureCanonicalVmStateAccount(connection, deployerKeypair, programId, options = {}) {
+    const { PublicKey, Transaction, TransactionInstruction, SystemProgram } = await import("@solana/web3.js");
+    const canonical = await PDAUtils.deriveVMStatePDA(programId.toString());
+    if (options.vmStateAccount && options.vmStateAccount !== canonical.address) {
+        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);
+    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()}`);
+        }
+        if (options.debug) {
+            console.log(`[FiveSDK] Reusing canonical VM State PDA: ${canonical.address}`);
+        }
+        return { vmStatePubkey, vmStateRent: 0, created: false, bump: canonical.bump };
+    }
+    const VM_STATE_SIZE = 56;
+    const vmStateRent = await connection.getMinimumBalanceForRentExemption(VM_STATE_SIZE);
+    if (options.debug) {
+        console.log(`[FiveSDK] Initializing canonical VM State PDA: ${canonical.address}`);
+    }
+    const initTransaction = new Transaction();
+    initTransaction.add(new TransactionInstruction({
+        keys: [
+            { pubkey: vmStatePubkey, isSigner: false, isWritable: true },
+            { pubkey: deployerKeypair.publicKey, isSigner: true, isWritable: false },
+            { pubkey: deployerKeypair.publicKey, isSigner: true, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: buildInitializeVmStateInstructionData(canonical.bump),
+    }));
+    initTransaction.feePayer = deployerKeypair.publicKey;
+    const initBlockhash = await connection.getLatestBlockhash("confirmed");
+    initTransaction.recentBlockhash = initBlockhash.blockhash;
+    initTransaction.partialSign(deployerKeypair);
+    const initSignature = await connection.sendRawTransaction(initTransaction.serialize(), {
+        skipPreflight: true,
+        preflightCommitment: "confirmed",
+        maxRetries: options.maxRetries || 3,
+    });
+    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)}`);
+    }
+    return { vmStatePubkey, vmStateRent, created: true, bump: canonical.bump };
+}
 function chunkBytecode(bytecode, chunkSize) {
     const chunks = [];
     for (let i = 0; i < bytecode.length; i += chunkSize) {
@@ -1116,3 +1145,27 @@ function createMultiChunkInstructionData(chunks) {
     }
     return Buffer.concat(buffers);
 }
+function buildInitializeVmStateInstructionData(bump = 0) {
+    return Buffer.from([0, bump & 0xff]);
+}
+function createInitLargeProgramInstructionData(expectedSize, firstChunk) {
+    const sizeBuffer = Buffer.allocUnsafe(4);
+    sizeBuffer.writeUInt32LE(expectedSize, 0);
+    const parts = [Buffer.from([4]), sizeBuffer];
+    if (firstChunk && firstChunk.length > 0) {
+        parts.push(Buffer.from(firstChunk));
+    }
+    return Buffer.concat(parts);
+}
+function createAppendBytecodeInstructionData(chunk) {
+    return Buffer.concat([Buffer.from([5]), Buffer.from(chunk)]);
+}
+function createFinalizeScriptInstructionData() {
+    return Buffer.from([7]);
+}
+export const __deployTestUtils = {
+    buildInitializeVmStateInstructionData,
+    createInitLargeProgramInstructionData,
+    createAppendBytecodeInstructionData,
+    createFinalizeScriptInstructionData,
+};