@5ive-tech/sdk 1.1.8 → 1.1.10

package/dist/modules/execute.d.ts

@@ -52,6 +52,8 @@ export declare function generateExecuteInstruction(scriptAccount: string, functi
         isWritable: boolean;
         isSystemAccount?: boolean;
     }>;
+    feeShardIndex?: number;
+    payerAccount?: string;
 }): Promise<SerializedExecution>;
 export declare function executeOnSolana(scriptAccount: string, connection: any, signerKeypair: any, functionName: string | number, parameters?: any[], accounts?: string[], options?: {
     debug?: boolean;
@@ -63,6 +65,8 @@ export declare function executeOnSolana(scriptAccount: string, connection: any,
     vmStateAccount?: string;
     fiveVMProgramId?: string;
     abi?: any;
+    feeShardIndex?: number;
+    payerAccount?: string;
 }): Promise<{
     success: boolean;
     result?: any;

package/dist/modules/execute.js

@@ -7,6 +7,45 @@ 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;
+const FEE_VAULT_NAMESPACE_SEED = Buffer.from([
+    0xff, 0x66, 0x69, 0x76, 0x65, 0x5f, 0x76, 0x6d, 0x5f, 0x66, 0x65, 0x65,
+    0x5f, 0x76, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x76, 0x31,
+]);
+const EXECUTE_FEE_HEADER_A = 0xff;
+const EXECUTE_FEE_HEADER_B = 0x53;
+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 };
+}
+async function readVMStateShardCount(connection, vmStateAddress) {
+    if (!connection)
+        return 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 DEFAULT_FEE_VAULT_SHARD_COUNT;
+        const data = new Uint8Array(info.data);
+        if (data.length <= 50)
+            return DEFAULT_FEE_VAULT_SHARD_COUNT;
+        const shardCount = data[50];
+        return shardCount > 0 ? shardCount : DEFAULT_FEE_VAULT_SHARD_COUNT;
+    }
+    catch {
+        return DEFAULT_FEE_VAULT_SHARD_COUNT;
+    }
+}
+function selectFeeShard(shardCount) {
+    const totalShards = Math.max(1, shardCount | 0);
+    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+        const bytes = new Uint32Array(1);
+        crypto.getRandomValues(bytes);
+        return bytes[0] % totalShards;
+    }
+    return Math.floor(Math.random() * totalShards);
+}
 // Helper function to initialize ParameterEncoder if needed (though BytecodeEncoder is preferred)
 // Assume BytecodeEncoder handles it or call it if needed.
 // BytecodeEncoder uses WASM module directly via loader.
@@ -188,9 +227,9 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         funcDef = Array.isArray(scriptMetadata.functions)
             ? scriptMetadata.functions.find((f) => f.index === functionIndex)
             : scriptMetadata.functions[functionIndex];
-        const paramDefs = (funcDef.parameters || []);
-        actualParamCount = paramDefs.length;
-        encodedParams = await encodeParametersWithABI(parameters, funcDef, functionIndex, accounts, options);
+        const encoded = await encodeParametersWithABI(parameters, funcDef, functionIndex, accounts, options);
+        actualParamCount = encoded.paramCount;
+        encodedParams = encoded.encoded;
     }
     catch (metadataError) {
         if (options.debug) {
@@ -212,34 +251,18 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
     // Resolve program ID with consistent precedence
     const programId = ProgramIdResolver.resolve(options.fiveVMProgramId);
     const vmStatePDA = await PDAUtils.deriveVMStatePDA(programId);
-    const vmState = options.vmStateAccount || vmStatePDA.address;
-    let adminAccount = options.adminAccount;
-    if (!adminAccount && connection) {
-        try {
-            let vmStateAddress = options.vmStateAccount;
-            if (!vmStateAddress) {
-                const pda = await PDAUtils.deriveVMStatePDA(programId);
-                vmStateAddress = pda.address;
-            }
-            const { PublicKey } = await import("@solana/web3.js");
-            const info = await connection.getAccountInfo(new PublicKey(vmStateAddress));
-            if (info) {
-                const data = new Uint8Array(info.data);
-                if (data.length >= 32) {
-                    const authorityPubkey = new PublicKey(data.slice(0, 32));
-                    adminAccount = authorityPubkey.toBase58();
-                }
-            }
-        }
-        catch (error) {
-            if (options.debug) {
-                console.warn(`[FiveSDK] Failed to resolve admin account from VM state:`, error);
-            }
-        }
+    if (options.vmStateAccount && options.vmStateAccount !== vmStatePDA.address) {
+        throw new Error(`vmStateAccount must be canonical PDA ${vmStatePDA.address}; got ${options.vmStateAccount}`);
     }
+    const vmState = vmStatePDA.address;
+    const shardCount = await readVMStateShardCount(connection, vmState);
+    const feeShardIndex = options.feeShardIndex !== undefined
+        ? ((options.feeShardIndex % shardCount) + shardCount) % shardCount
+        : selectFeeShard(shardCount);
+    const feeVault = await deriveProgramFeeVault(programId, feeShardIndex);
     const instructionAccounts = [
         { pubkey: scriptAccount, isSigner: false, isWritable: false },
-        { pubkey: vmState, isSigner: false, isWritable: true },
+        { pubkey: vmState, isSigner: false, isWritable: false },
     ];
     const abiAccountMetadata = new Map();
     if (funcDef && funcDef.parameters) {
@@ -285,12 +308,12 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
             }
         });
     }
-    const userInstructionAccounts = accounts.map((acc, index) => {
+    const userInstructionAccounts = accounts.map((acc) => {
         // Check both derived ABI metadata and passed-in metadata (from FunctionBuilder)
         const abiMetadata = abiAccountMetadata.get(acc);
         const passedMetadata = options.accountMetadata?.get(acc);
         const metadata = abiMetadata || passedMetadata;
-        const isSigner = metadata ? metadata.isSigner : (index === 0 && adminAccount ? true : false);
+        const isSigner = metadata ? metadata.isSigner : false;
         const isWritable = metadata ? metadata.isWritable : true;
         return {
             pubkey: acc,
@@ -299,20 +322,24 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         };
     });
     instructionAccounts.push(...userInstructionAccounts);
-    if (adminAccount) {
-        const existingAdminIdx = instructionAccounts.findIndex(a => a.pubkey === adminAccount);
-        if (existingAdminIdx === -1) {
-            instructionAccounts.push({
-                pubkey: adminAccount,
-                isSigner: false,
-                isWritable: true,
-            });
-        }
-        else {
-            instructionAccounts[existingAdminIdx].isWritable = true;
-        }
+    const instructionData = encodeExecuteInstruction(functionIndex, encodedParams, actualParamCount, feeShardIndex, feeVault.bump);
+    // Runtime requires strict tail: [payer, fee_vault, system_program].
+    const signerCandidates = instructionAccounts
+        .filter((acc) => acc.isSigner)
+        .map((acc) => acc.pubkey);
+    const inferredPayer = options.payerAccount ||
+        (signerCandidates.length > 0
+            ? signerCandidates[signerCandidates.length - 1]
+            : accounts[0]);
+    if (!inferredPayer) {
+        throw new Error("Could not infer execute fee payer account. Provide a signer account or set options.payerAccount.");
     }
-    const instructionData = encodeExecuteInstruction(functionIndex, encodedParams, actualParamCount);
+    const feeTailAccounts = [
+        { pubkey: inferredPayer, isSigner: true, isWritable: true },
+        { pubkey: feeVault.address, isSigner: false, isWritable: true },
+        { pubkey: "11111111111111111111111111111111", isSigner: false, isWritable: false },
+    ];
+    instructionAccounts.push(...feeTailAccounts);
     const result = {
         instruction: {
             programId: programId,
@@ -328,7 +355,7 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         requiredSigners: [],
         estimatedComputeUnits: options.computeUnitLimit ||
             estimateComputeUnits(functionIndex, parameters.length),
-        adminAccount: adminAccount,
+        adminAccount: feeVault.address,
     };
     const shouldEstimateFees = options.estimateFees !== false && connection;
     if (shouldEstimateFees) {
@@ -356,6 +383,8 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
                 vmStateAccount: options.vmStateAccount,
                 fiveVMProgramId: options.fiveVMProgramId,
                 abi: options.abi,
+                feeShardIndex: options.feeShardIndex,
+                payerAccount: options.payerAccount || signerKeypair.publicKey.toString(),
             });
         }
         catch (metadataError) {
@@ -375,19 +404,12 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
             transaction.add(computePriceIx);
         }
         const accountKeys = [...executionData.instruction.accounts];
-        if (options.vmStateAccount && accountKeys.length >= 2) {
-            for (let i = 0; i < accountKeys.length; i++) {
-                if (i === 1) {
-                    accountKeys[i].pubkey = options.vmStateAccount;
-                    break;
-                }
-            }
-        }
         const signerPubkey = signerKeypair.publicKey.toString();
         let signerFound = false;
         for (const meta of accountKeys) {
             if (meta.pubkey === signerPubkey) {
                 meta.isSigner = true;
+                meta.isWritable = true;
                 signerFound = true;
             }
         }
@@ -537,9 +559,15 @@ export async function executeScriptAccount(scriptAccount, functionIndex = 0, par
     });
 }
 // Helpers
-function encodeExecuteInstruction(functionIndex, encodedParams, paramCount) {
+function encodeExecuteInstruction(functionIndex, encodedParams, paramCount, feeShardIndex, feeVaultBump) {
     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));
     // Param count as fixed u32
@@ -582,7 +610,7 @@ function inferParameterType(value) {
         return "string";
     }
 }
-async function encodeParametersWithABI(parameters, functionDef, functionIndex, accounts = [], options = {}) {
+async function encodeParametersWithABI(parameters, functionDef, functionIndex, _accounts = [], options = {}) {
     const isAccountParam = (param) => {
         if (!param)
             return false;
@@ -598,51 +626,33 @@ async function encodeParametersWithABI(parameters, functionDef, functionIndex, a
         return type === 'pubkey';
     };
     const paramDefs = (functionDef.parameters || []);
-    if (parameters.length !== paramDefs.length) {
+    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 paramValues = {};
-    paramDefs.forEach((param, index) => {
-        if (index < parameters.length) {
-            let value = parameters[index];
-            if (isAccountParam(param)) {
-                let accountPubkey = null;
-                if (value && typeof value === 'object' && typeof value.toBase58 === 'function') {
-                    accountPubkey = value.toBase58();
-                }
-                else if (typeof value === 'string') {
-                    accountPubkey = value;
-                }
-                else if (typeof value === 'number') {
-                    if (value >= 0 && value < accounts.length) {
-                        accountPubkey = accounts[value];
-                    }
-                    else {
-                        throw new Error(`Account index ${value} out of bounds`);
-                    }
-                }
-                if (accountPubkey) {
-                    const accountIndex = accounts.indexOf(accountPubkey);
-                    if (accountIndex >= 0) {
-                        // MitoVM receives accounts excluding the script account.
-                        // Account index 0 is the VM state account.
-                        value = accountIndex + 1;
-                    }
-                    else {
-                        throw new Error(`Account ${accountPubkey} not found in accounts array`);
-                    }
-                }
-            }
-            else if (isPubkeyParam(param)) {
-                if (value && typeof value === 'object' && typeof value.toBase58 === 'function') {
-                    value = value.toBase58();
-                }
+    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) {
+            throw new Error(`Missing value for parameter: ${param.name}`);
+        }
+        let value = parameters[sourceIndex];
+        if (isPubkeyParam(param)) {
+            if (value && typeof value === 'object' && typeof value.toBase58 === 'function') {
+                value = value.toBase58();
             }
-            paramValues[param.name] = value;
         }
-    });
-    const encoded = await BytecodeEncoder.encodeExecute(functionIndex, paramDefs, paramValues, true, options);
-    return encoded;
+        paramValues[param.name] = value;
+        argCursor += 1;
+    }
+    const encoded = await BytecodeEncoder.encodeExecute(functionIndex, nonAccountParamDefs, paramValues, true, options);
+    return { encoded, paramCount: nonAccountParamDefs.length };
 }
 function estimateComputeUnits(functionIndex, parameterCount) {
     return Math.max(5000, 1000 + parameterCount * 500 + functionIndex * 100);

package/dist/modules/fees.d.ts

@@ -1,5 +1,7 @@
 import { FeeInformation } from "../types.js";
 export declare function getFees(connection: any, fiveVMProgramId?: string): Promise<{
+    deployFeeLamports: number;
+    executeFeeLamports: number;
     deployFeeBps: number;
     executeFeeBps: number;
     adminAccount: string | null;

package/dist/modules/fees.js

@@ -4,16 +4,20 @@ export async function getFees(connection, fiveVMProgramId) {
     try {
         const state = await getVMState(connection, fiveVMProgramId);
         return {
-            deployFeeBps: state.deployFeeBps,
-            executeFeeBps: state.executeFeeBps,
-            adminAccount: state.authority
+            deployFeeLamports: state.deployFeeLamports,
+            executeFeeLamports: state.executeFeeLamports,
+            deployFeeBps: state.deployFeeLamports,
+            executeFeeBps: state.executeFeeLamports,
+            adminAccount: state.authority,
         };
     }
     catch (error) {
         return {
+            deployFeeLamports: 0,
+            executeFeeLamports: 0,
             deployFeeBps: 0,
             executeFeeBps: 0,
-            adminAccount: null
+            adminAccount: null,
         };
     }
 }
@@ -22,17 +26,16 @@ export async function calculateDeployFee(bytecodeSize, connection, fiveVMProgram
         const accountSize = 64 + bytecodeSize;
         const rentLamports = await RentCalculator.calculateRentExemption(accountSize);
         const vmState = await getVMState(connection, fiveVMProgramId);
-        const deployFeeBps = vmState.deployFeeBps;
-        const feeLamports = Math.floor((rentLamports * deployFeeBps) / 10000);
+        const deployFeeLamports = vmState.deployFeeLamports;
         return {
-            feeBps: deployFeeBps,
+            feeBps: 0,
             basisLamports: rentLamports,
-            feeLamports,
-            totalEstimatedCost: rentLamports + feeLamports,
+            feeLamports: deployFeeLamports,
+            totalEstimatedCost: rentLamports + deployFeeLamports,
             costBreakdown: {
                 basis: RentCalculator.formatSOL(rentLamports),
-                fee: RentCalculator.formatSOL(feeLamports),
-                total: RentCalculator.formatSOL(rentLamports + feeLamports),
+                fee: RentCalculator.formatSOL(deployFeeLamports),
+                total: RentCalculator.formatSOL(rentLamports + deployFeeLamports),
             },
         };
     }
@@ -56,17 +59,16 @@ export async function calculateExecuteFee(connection, fiveVMProgramId) {
     const STANDARD_TX_FEE = 5000;
     try {
         const vmState = await getVMState(connection, fiveVMProgramId);
-        const executeFeeBps = vmState.executeFeeBps;
-        const feeLamports = Math.floor((STANDARD_TX_FEE * executeFeeBps) / 10000);
+        const executeFeeLamports = vmState.executeFeeLamports;
         return {
-            feeBps: executeFeeBps,
+            feeBps: 0,
             basisLamports: STANDARD_TX_FEE,
-            feeLamports,
-            totalEstimatedCost: STANDARD_TX_FEE + feeLamports,
+            feeLamports: executeFeeLamports,
+            totalEstimatedCost: STANDARD_TX_FEE + executeFeeLamports,
             costBreakdown: {
                 basis: RentCalculator.formatSOL(STANDARD_TX_FEE),
-                fee: RentCalculator.formatSOL(feeLamports),
-                total: RentCalculator.formatSOL(STANDARD_TX_FEE + feeLamports),
+                fee: RentCalculator.formatSOL(executeFeeLamports),
+                total: RentCalculator.formatSOL(STANDARD_TX_FEE + executeFeeLamports),
             },
         };
     }
@@ -91,7 +93,7 @@ export async function getFeeInformation(bytecodeSize, connection, fiveVMProgramI
             calculateExecuteFee(connection, fiveVMProgramId),
             getVMState(connection, fiveVMProgramId),
         ]);
-        const feesEnabled = vmState.deployFeeBps > 0 || vmState.executeFeeBps > 0;
+        const feesEnabled = vmState.deployFeeLamports > 0 || vmState.executeFeeLamports > 0;
         return {
             deploy: deployFee,
             execute: executeFee,

package/dist/modules/vm-state.d.ts

@@ -1,7 +1,11 @@
 export declare function getVMState(connection: any, fiveVMProgramId?: string): Promise<{
     authority: string;
     scriptCount: number;
+    deployFeeLamports: number;
+    executeFeeLamports: number;
     deployFeeBps: number;
     executeFeeBps: number;
+    feeVaultShardCount: number;
+    vmStateBump: number;
     isInitialized: boolean;
 }>;

package/dist/modules/vm-state.js

@@ -30,11 +30,18 @@ export async function getVMState(connection, fiveVMProgramId) {
             throw new Error(`VM State account data too small: expected 56, got ${accountData.length}`);
         const authority = Base58Utils.encode(accountData.slice(0, 32));
         const view = new DataView(accountData.buffer, accountData.byteOffset, accountData.byteLength);
+        const deployFeeLamports = view.getUint32(40, true);
+        const executeFeeLamports = view.getUint32(44, true);
         return {
             authority,
             scriptCount: Number(view.getBigUint64(32, true)),
-            deployFeeBps: view.getUint32(40, true),
-            executeFeeBps: view.getUint32(44, true),
+            deployFeeLamports,
+            executeFeeLamports,
+            // Backward-compatible aliases; deprecated.
+            deployFeeBps: deployFeeLamports,
+            executeFeeBps: executeFeeLamports,
+            feeVaultShardCount: accountData[50] || 10,
+            vmStateBump: accountData[51] || 0,
             isInitialized: accountData[48] === 1
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@5ive-tech/sdk",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "description": "Client-agnostic TypeScript SDK for Five VM scripts on Solana",
   "type": "module",
   "main": "dist/index.js",
@@ -36,6 +36,7 @@
     "copy-assets": "mkdir -p dist/assets/vm && COPYFILE_DISABLE=1 cp src/assets/vm/* dist/assets/vm/",
     "test": "node examples/basic-usage.js",
     "test:jest": "NODE_OPTIONS=--experimental-vm-modules jest --runInBand",
+    "test:localnet": "USE_SOLANA_MOCKS=0 RUN_LOCALNET_VALIDATOR_TESTS=1 NODE_OPTIONS=--experimental-vm-modules jest --runInBand src/__tests__/integration/localnet-fee-vault.test.ts",
     "gen-types": "node ./node_modules/typescript/bin/tsc && node dist/bin/gen-types.js",
     "prepublishOnly": "npm run build"
   },
@@ -56,4 +57,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}