@5ive-tech/sdk 1.1.7 → 1.1.9

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/dist/testing/AccountTestFixture.js

@@ -219,7 +219,7 @@ export class AccountTestFixture {
                 else if (spec.type === 'state' || spec.type === 'mutable') {
                     // Create state/mutable account with initial data
                     const space = 1024; // Default space
-                    const owner = options.fiveVMProgramId || new PublicKey('9MHGM73eszNUtmJS6ypDCESguxWhCBnkUPpTMyLGqURH');
+                    const owner = options.fiveVMProgramId || new PublicKey('4Qxf3pbCse2veUgZVMiAm3nWqJrYo2pT4suxHKMJdK1d');
                     // Serialize state data if provided
                     let initialData;
                     if (spec.state && spec.type === 'state') {
@@ -242,7 +242,7 @@ export class AccountTestFixture {
                 else if (spec.type === 'init') {
                     // Create init account (will be initialized by script)
                     const space = 1024;
-                    const owner = options.fiveVMProgramId || new PublicKey('9MHGM73eszNUtmJS6ypDCESguxWhCBnkUPpTMyLGqURH');
+                    const owner = options.fiveVMProgramId || new PublicKey('4Qxf3pbCse2veUgZVMiAm3nWqJrYo2pT4suxHKMJdK1d');
                     publicKey = await manager.createAccount(space, owner);
                     if (options.debug) {
                         console.log(`  ${spec.name} (init): ${publicKey.toString()}`);
@@ -256,7 +256,7 @@ export class AccountTestFixture {
                 else {
                     // Create readonly account
                     const space = 0;
-                    const owner = options.fiveVMProgramId || new PublicKey('9MHGM73eszNUtmJS6ypDCESguxWhCBnkUPpTMyLGqURH');
+                    const owner = options.fiveVMProgramId || new PublicKey('4Qxf3pbCse2veUgZVMiAm3nWqJrYo2pT4suxHKMJdK1d');
                     publicKey = await manager.createAccount(space, owner);
                     if (options.debug) {
                         console.log(`  ${spec.name} (readonly): ${publicKey.toString()}`);

package/dist/testing/TestDiscovery.d.ts

@@ -13,6 +13,8 @@ export interface VSourceTest {
     file: string;
     functionName: string;
     parameters?: any[];
+    expectedResult?: any;
+    expectsResult?: boolean;
     description?: string;
 }
 /**
@@ -36,6 +38,8 @@ export interface DiscoveredTest {
     source?: VSourceTest;
     description?: string;
     parameters?: any[];
+    expectedResult?: any;
+    expectsResult?: boolean;
 }
 /**
  * Discover tests from directory
@@ -64,6 +68,8 @@ export declare class TestDiscovery {
      * Parse .v source file for test functions and parameters
      */
     private static parseVFile;
+    private static splitParamsAndExpectation;
+    private static parseTokenValue;
     /**
      * Compile a .v test source file
      */

package/dist/testing/TestDiscovery.js

@@ -6,7 +6,7 @@
  * extracts parameters from @test-params comments, and compiles source files.
  */
 import { readFile, readdir, stat } from 'fs/promises';
-import { join, basename } from 'path';
+import { basename, join } from 'path';
 import { FiveSDK } from '../FiveSDK.js';
 /**
  * Discover tests from directory
@@ -121,80 +121,62 @@ export class TestDiscovery {
         const tests = [];
         try {
             const content = await readFile(file, 'utf8');
-            // Find all function definitions with potential test annotations
-            // Pattern 1: pub function with #[test] annotation
-            // Pattern 2: function with specific naming convention (test_*, *_test)
             const lines = content.split('\n');
-            let currentFunction = null;
-            let currentParams = null;
-            let currentDescription = null;
+            let pendingParams;
             for (let i = 0; i < lines.length; i++) {
                 const line = lines[i].trim();
                 // Check for @test-params comment
-                const paramsMatch = line.match(/@test-params\s+(.*)/);
+                const paramsMatch = line.match(/@test-params(?:\s+(.*))?$/);
                 if (paramsMatch) {
                     try {
-                        const paramsStr = paramsMatch[1].trim();
-                        // Try to parse as JSON array first
-                        if (paramsStr.startsWith('[')) {
-                            currentParams = JSON.parse(paramsStr);
+                        const paramsStr = (paramsMatch[1] || '').trim();
+                        if (paramsStr.length === 0) {
+                            pendingParams = [];
+                        }
+                        else if (paramsStr.startsWith('[')) {
+                            const parsed = JSON.parse(paramsStr);
+                            pendingParams = Array.isArray(parsed) ? parsed : [];
                         }
                         else {
-                            // Parse space-separated values
-                            currentParams = paramsStr.split(/\s+/).map(p => {
-                                // Try to parse as number
-                                if (!isNaN(Number(p))) {
-                                    return Number(p);
-                                }
-                                return p;
-                            });
+                            pendingParams = paramsStr
+                                .split(/\s+/)
+                                .filter(Boolean)
+                                .map((token) => this.parseTokenValue(token));
                         }
                     }
                     catch (error) {
                         console.warn(`Failed to parse @test-params in ${file}:${i + 1}: ${line}`);
+                        pendingParams = undefined;
                     }
                     continue;
                 }
-                // Check for test annotation
-                if (line.startsWith('#[test]') || line.includes('#[test]')) {
-                    // Next non-empty line should be the function definition
-                    for (let j = i + 1; j < lines.length; j++) {
-                        const nextLine = lines[j].trim();
-                        if (nextLine && !nextLine.startsWith('//')) {
-                            const funcMatch = nextLine.match(/(?:pub\s+)?(?:fn|instruction|script)\s+(\w+)\s*\(/);
-                            if (funcMatch) {
-                                currentFunction = funcMatch[1];
-                                break;
-                            }
-                        }
-                    }
-                    continue;
-                }
-                // Check for pub function that matches test naming convention
-                const funcMatch = line.match(/pub\s+(?:fn|instruction|script)\s+(test_\w+|_?\w+_test)\s*\(/);
+                // Match canonical DSL test function forms:
+                //   pub test_name(...)
+                //   pub fn test_name(...)
+                const funcMatch = line.match(/^pub\s+(?:fn\s+)?(test_[A-Za-z0-9_]*|[A-Za-z0-9_]*_test)\s*\([^)]*\)\s*(?:->\s*([A-Za-z0-9_<>\[\]]+))?/);
                 if (funcMatch) {
                     const functionName = funcMatch[1];
-                    // Check if we have parameters from @test-params comment
-                    if (currentParams || currentFunction) {
-                        const name = basename(file, '.v') + '::' + functionName;
-                        tests.push({
-                            name,
-                            path: file,
+                    const returnType = funcMatch[2];
+                    const hasReturnValue = !!returnType;
+                    const [parameters, expectedResult, expectsResult] = this.splitParamsAndExpectation(pendingParams, hasReturnValue);
+                    const name = `${basename(file, '.v')}::${functionName}`;
+                    tests.push({
+                        name,
+                        path: file,
+                        type: 'v-source',
+                        source: {
                             type: 'v-source',
-                            source: {
-                                type: 'v-source',
-                                file,
-                                functionName,
-                                parameters: currentParams || undefined,
-                                description: currentDescription || undefined
-                            },
-                            parameters: currentParams || undefined,
-                            description: currentDescription || undefined
-                        });
-                        currentParams = null;
-                        currentDescription = null;
-                        currentFunction = null;
-                    }
+                            file,
+                            functionName,
+                            parameters: parameters.length > 0 ? parameters : undefined,
+                            expectedResult,
+                            expectsResult
+                        },
+                        parameters: parameters.length > 0 ? parameters : undefined,
+                        expectedResult,
+                        expectsResult
+                    });
+                    pendingParams = undefined;
                 }
             }
         }
@@ -203,6 +185,29 @@ export class TestDiscovery {
         }
         return tests;
     }
+    static splitParamsAndExpectation(values, hasReturnValue) {
+        const parsed = Array.isArray(values) ? values : [];
+        if (!hasReturnValue || parsed.length === 0) {
+            return [parsed, undefined, false];
+        }
+        const params = parsed.slice(0, parsed.length - 1);
+        return [params, parsed[parsed.length - 1], true];
+    }
+    static parseTokenValue(token) {
+        if ((token.startsWith('"') && token.endsWith('"')) ||
+            (token.startsWith("'") && token.endsWith("'"))) {
+            return token.slice(1, -1);
+        }
+        if (token === 'true')
+            return true;
+        if (token === 'false')
+            return false;
+        const asNumber = Number(token);
+        if (!Number.isNaN(asNumber)) {
+            return asNumber;
+        }
+        return token;
+    }
     /**
      * Compile a .v test source file
      */