@5ive-tech/sdk 1.1.2

package/dist/wasm/compiler/InfoLogic.js

@@ -0,0 +1,24 @@
+import { createCompilerError } from "./utils.js";
+export function getCompilerInfo(ctx) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    try {
+        const info = ctx.compiler.get_compiler_stats();
+        return JSON.parse(info);
+    }
+    catch (error) {
+        throw createCompilerError("Failed to get compiler info", error);
+    }
+}
+export async function discoverModules(ctx, entryPoint) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    try {
+        return ctx.compiler.discoverModules(entryPoint);
+    }
+    catch (error) {
+        throw createCompilerError(`Module discovery failed: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+}

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

@@ -0,0 +1,2 @@
+import { CompilationContext } from "./types.js";
+export declare function optimizeBytecode(ctx: CompilationContext, bytecode: Uint8Array): Promise<Uint8Array>;

package/dist/wasm/compiler/OptimizationLogic.js

@@ -0,0 +1,13 @@
+import { createCompilerError } from "./utils.js";
+export async function optimizeBytecode(ctx, bytecode) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    try {
+        const optimized = ctx.compiler.optimize_bytecode(bytecode);
+        return new Uint8Array(optimized);
+    }
+    catch (error) {
+        throw createCompilerError("Bytecode optimization failed", error);
+    }
+}

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

@@ -0,0 +1,7 @@
+import { CompilationContext } from "./types.js";
+export declare function validateSource(ctx: CompilationContext, sourceCode: string): Promise<{
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}>;
+export declare function validateAccountConstraints(ctx: CompilationContext, sourceCode: string, functionName: string, accounts: any[]): Promise<any>;

package/dist/wasm/compiler/ValidationLogic.js

@@ -0,0 +1,26 @@
+import { createCompilerError } from "./utils.js";
+export async function validateSource(ctx, sourceCode) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    try {
+        const result = ctx.compiler.validate_syntax(sourceCode);
+        return JSON.parse(result);
+    }
+    catch (error) {
+        throw createCompilerError("Syntax validation failed", error);
+    }
+}
+export async function validateAccountConstraints(ctx, sourceCode, functionName, accounts) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    try {
+        const accountsJson = JSON.stringify(accounts);
+        const validation = ctx.compiler.validate_account_constraints(sourceCode, functionName, accountsJson);
+        return JSON.parse(validation);
+    }
+    catch (error) {
+        throw createCompilerError("Account constraint validation failed", error);
+    }
+}

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

@@ -0,0 +1,2 @@
+export { FiveCompiler } from "./FiveCompiler.js";
+export * from "./types.js";

package/dist/wasm/compiler/index.js

@@ -0,0 +1,2 @@
+export { FiveCompiler } from "./FiveCompiler.js";
+export * from "./types.js";

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

@@ -0,0 +1,8 @@
+import { Logger } from "../../types.js";
+export interface CompilationContext {
+    compiler: any;
+    wasmModuleRef: any;
+    WasmCompilationOptions: any;
+    BytecodeAnalyzer: any;
+    logger: Logger;
+}

package/dist/wasm/compiler/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import { CLIError } from "../../types.js";
+export declare function createCompilerError(message: string, cause?: Error): CLIError;
+export declare function extractMetrics(result: any, defaultFormat: string): {
+    format: string;
+    exported: string;
+    detailed?: any;
+} | undefined;
+export declare function extractAbi(result: any, logger: any): any | undefined;

package/dist/wasm/compiler/utils.js

@@ -0,0 +1,75 @@
+export function createCompilerError(message, cause) {
+    const error = new Error(message);
+    error.name = "CompilerError";
+    error.code = "COMPILER_ERROR";
+    error.category = "wasm";
+    error.exitCode = 1;
+    if (cause) {
+        error.details = {
+            cause: cause.message,
+            stack: cause.stack,
+        };
+    }
+    return error;
+}
+export function extractMetrics(result, defaultFormat) {
+    if (!result || typeof result !== "object") {
+        return undefined;
+    }
+    const exported = result.metrics;
+    if (!exported) {
+        return undefined;
+    }
+    const format = result.metrics_format || defaultFormat;
+    let detailed;
+    try {
+        const getDetailed = result.get_metrics_detailed;
+        if (typeof getDetailed === "function") {
+            detailed = getDetailed.call(result);
+        }
+        else {
+            const getObject = result.get_metrics_object;
+            if (typeof getObject === "function") {
+                detailed = getObject.call(result);
+            }
+        }
+    }
+    catch {
+        // Ignore metrics errors
+    }
+    return {
+        format,
+        exported,
+        detailed,
+    };
+}
+export function extractAbi(result, logger) {
+    if (!result) {
+        return undefined;
+    }
+    if (typeof result.get_abi === "function") {
+        try {
+            const abiJson = result.get_abi();
+            if (abiJson) {
+                return JSON.parse(abiJson);
+            }
+        }
+        catch (error) {
+            logger.debug("Failed to parse ABI from get_abi():", error);
+        }
+    }
+    const directAbi = result.abi;
+    if (!directAbi) {
+        return undefined;
+    }
+    if (typeof directAbi === "string") {
+        try {
+            return JSON.parse(directAbi);
+        }
+        catch (error) {
+            logger.debug("Failed to parse ABI from result.abi string:", error);
+            return undefined;
+        }
+    }
+    return directAbi;
+}

package/dist/wasm/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Five SDK WASM Integration Index
+ *
+ * Provides access to WASM VM and Compiler classes for the SDK.
+ * Includes cross-platform path resolution and resource management.
+ */
+export { FiveVM } from './vm.js';
+export { FiveCompiler } from './compiler/index.js';
+export { BytecodeEncoder } from '../lib/bytecode-encoder.js';

package/dist/wasm/index.js

@@ -0,0 +1,12 @@
+/**
+ * Five SDK WASM Integration Index
+ *
+ * Provides access to WASM VM and Compiler classes for the SDK.
+ * Includes cross-platform path resolution and resource management.
+ */
+// Direct re-exports from CLI WASM modules
+export { FiveVM } from './vm.js';
+export { FiveCompiler } from './compiler/index.js';
+// Bytecode encoder from lib
+export { BytecodeEncoder } from '../lib/bytecode-encoder.js';
+// Simple WASM utilities (no over-engineering)

package/dist/wasm/instance.d.ts

@@ -0,0 +1 @@
+export declare function loadWasmVM(): Promise<any>;

package/dist/wasm/instance.js

@@ -0,0 +1,26 @@
+import { FiveSDKError } from "../types.js";
+let wasmVMInstance = null;
+export async function loadWasmVM() {
+    if (wasmVMInstance) {
+        return wasmVMInstance;
+    }
+    try {
+        // Import existing WASM VM from five-cli infrastructure
+        const { FiveVM } = await import('./vm.js');
+        // Create a simple logger for WASM VM
+        const logger = {
+            debug: (msg) => console.debug("[WASM VM]", msg),
+            info: (msg) => console.info("[WASM VM]", msg),
+            warn: (msg) => console.warn("[WASM VM]", msg),
+            error: (msg) => console.error("[WASM VM]", msg),
+        };
+        wasmVMInstance = new FiveVM(logger); // Initialize WASM VM
+        if (wasmVMInstance.initialize) {
+            await wasmVMInstance.initialize();
+        }
+        return wasmVMInstance;
+    }
+    catch (error) {
+        throw new FiveSDKError(`Failed to load WASM VM: ${error instanceof Error ? error.message : "Unknown error"}`, "WASM_LOAD_ERROR");
+    }
+}

package/dist/wasm/loader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * WASM Loader for Five VM
+ *
+ * Loader that uses the main wasm-pack generated entry point.
+ * Compatible with both Node.js and Browser environments.
+ */
+export declare function getWasmModule(): Promise<any>;

package/dist/wasm/loader.js

@@ -0,0 +1,112 @@
+/**
+ * WASM Loader for Five VM
+ *
+ * Loader that uses the main wasm-pack generated entry point.
+ * Compatible with both Node.js and Browser environments.
+ */
+// Store the initialized module instance globally within this module's scope.
+let wasmModule = null;
+import { ConfigManager } from '../config/ConfigManager.js';
+export async function getWasmModule() {
+    if (wasmModule) {
+        return wasmModule;
+    }
+    // Build candidate list from config and sensible defaults
+    const cfg = await ConfigManager.getInstance().get();
+    const prefer = cfg.wasm?.loader || 'auto';
+    const configured = Array.isArray(cfg.wasm?.modulePaths) ? cfg.wasm.modulePaths : [];
+    const nodeCandidates = [
+        '../../five_vm_wasm.cjs',
+        '../five_vm_wasm.cjs',
+        './five_vm_wasm.cjs',
+        '../../five_vm_wasm.js',
+        '../five_vm_wasm.js',
+        './five_vm_wasm.js', // Sibling check
+    ];
+    const bundlerCandidates = [
+        '../../assets/vm/five_vm_wasm.cjs',
+        '../assets/vm/five_vm_wasm.cjs',
+        '../../assets/vm/five_vm_wasm.js',
+        '../assets/vm/five_vm_wasm.js',
+        // Fallback for direct import (bundler alias)
+        'five-wasm',
+        'five-vm-wasm'
+    ];
+    let candidates = [];
+    candidates.push(...configured);
+    // Detect environment to prioritize candidates
+    const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+    if (prefer === 'node' || (prefer === 'auto' && isNode)) {
+        candidates.push(...nodeCandidates);
+        candidates.push(...bundlerCandidates);
+    }
+    else {
+        candidates.push(...bundlerCandidates); // Bundler/Browser preferred
+        candidates.push(...nodeCandidates);
+    }
+    const tried = [];
+    for (const candidate of candidates) {
+        try {
+            const mod = await import(candidate);
+            // Node.js specific initialization using fs/path (Dynamic Import to avoid Browser errors)
+            if (mod && typeof mod.initSync === 'function' && isNode) {
+                try {
+                    const fs = await import('fs');
+                    const path = await import('path');
+                    const url = await import('url');
+                    const dirname = path.dirname;
+                    const resolve = path.resolve;
+                    const fileURLToPath = url.fileURLToPath;
+                    const existsSync = fs.existsSync;
+                    const readFileSync = fs.readFileSync;
+                    // Resolve path safely
+                    let here;
+                    try {
+                        here = dirname(fileURLToPath(import.meta.url));
+                    }
+                    catch (e) {
+                        // Fallback if import.meta.url is not file://
+                        here = process.cwd();
+                    }
+                    const wasmFiles = [
+                        resolve(here, '../five_vm_wasm_bg.wasm'),
+                        resolve(here, '../../five_vm_wasm_bg.wasm'),
+                        resolve(here, '../assets/vm/five_vm_wasm_bg.wasm'),
+                        resolve(here, '../../assets/vm/five_vm_wasm_bg.wasm'),
+                    ];
+                    for (const wf of wasmFiles) {
+                        if (existsSync(wf)) {
+                            mod.initSync(readFileSync(wf));
+                            break;
+                        }
+                    }
+                }
+                catch (syncErr) {
+                    // Ignore sync init errors in node, might work with default init
+                    // tried.push({ path: candidate, error: syncErr });
+                }
+            }
+            // Universal initialization (Browser/Node) if default export is init function
+            if (mod && typeof mod.default === 'function') {
+                try {
+                    await mod.default();
+                }
+                catch (initErr) {
+                    tried.push({ path: candidate, error: initErr });
+                }
+            }
+            if (mod) {
+                wasmModule = mod;
+                return wasmModule;
+            }
+            tried.push({ path: candidate, error: 'Module import returned null/undefined' });
+        }
+        catch (e) {
+            tried.push({ path: candidate, error: e });
+        }
+    }
+    const attempted = tried
+        .map(t => `  - ${t.path}: ${t.error instanceof Error ? t.error.message : String(t.error)}`)
+        .join('\n');
+    throw new Error(`Five VM WASM module not found or failed to load. Please ensure five-wasm is built.\nAttempts:\n${attempted}`);
+}

package/dist/wasm/vm.d.ts

@@ -0,0 +1,33 @@
+import { VMExecutionOptions, VMExecutionResult, AccountInfo, Logger } from '../types.js';
+export declare class FiveVM {
+    private vm;
+    private logger;
+    private initialized;
+    constructor(logger: Logger);
+    initialize(): Promise<void>;
+    private isWasmOnlyExecution;
+    private hasFiveMagic;
+    private looksLikeScriptHeader;
+    private looksLikeOptimizedHeader;
+    execute(options: VMExecutionOptions): Promise<VMExecutionResult>;
+    private parseVMResult;
+    executeFunction(bytecode: Uint8Array, functionIndex: number, parameters: Array<{
+        type: string;
+        value: any;
+    }>, accounts?: AccountInfo[]): Promise<VMExecutionResult>;
+    getState(): Promise<any>;
+    validateBytecode(bytecode: Uint8Array): Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
+    getVMConstants(): any;
+    private convertAccountsToWasm;
+    private loggerwarn;
+    private createVMError;
+    getVMInfo(): {
+        version: string;
+        features: string[];
+    };
+    isReady(): boolean;
+    cleanup(): void;
+}

package/dist/wasm/vm.js

@@ -0,0 +1,250 @@
+// Five VM WASM integration.
+import { getWasmModule } from './loader.js';
+let FiveVMWasm;
+let WasmAccount;
+let ParameterEncoder;
+let wrap_with_script_header;
+const SCRIPT_HEADER_LEN = 64; // ScriptHeader::LEN
+const OPTIMIZED_HEADER_LEN = 7; // OptimizedHeader V2 size
+const FIVE_MAGIC = [0x35, 0x49, 0x56, 0x45];
+export class FiveVM {
+    constructor(logger) {
+        this.vm = null;
+        this.initialized = false;
+        this.logger = logger;
+    }
+    async initialize() {
+        try {
+            this.logger.debug('[DEBUG] Starting VM WASM initialization...');
+            const wasmModule = await getWasmModule();
+            FiveVMWasm = wasmModule.FiveVMWasm;
+            WasmAccount = wasmModule.WasmAccount;
+            ParameterEncoder = wasmModule.ParameterEncoder;
+            if (typeof wasmModule.wrap_with_script_header !== 'function') {
+                // Warning only? Or throw?
+                this.logger.warn('WASM VM missing wrap_with_script_header');
+            }
+            else {
+                wrap_with_script_header = wasmModule.wrap_with_script_header;
+            }
+            this.initialized = true;
+        }
+        catch (error) {
+            throw this.createVMError('Five VM WASM modules not found. Please run "npm run build:wasm".', error);
+        }
+    }
+    isWasmOnlyExecution() {
+        // Check basic env
+        if (typeof process !== 'undefined' && process.argv) {
+            if (process.argv.includes('local'))
+                return true;
+        }
+        return true;
+    }
+    hasFiveMagic(data) {
+        if (data.length < FIVE_MAGIC.length)
+            return false;
+        return FIVE_MAGIC.every((byte, index) => data[index] === byte);
+    }
+    looksLikeScriptHeader(data) {
+        if (data.length < SCRIPT_HEADER_LEN)
+            return false;
+        if (!this.hasFiveMagic(data))
+            return false;
+        const encodedLen = data[4] + (data[5] << 8) + (data[6] << 16);
+        const payloadLen = data.length - SCRIPT_HEADER_LEN;
+        return encodedLen === payloadLen;
+    }
+    looksLikeOptimizedHeader(data) {
+        if (data.length < OPTIMIZED_HEADER_LEN)
+            return false;
+        if (!this.hasFiveMagic(data))
+            return false;
+        return !this.looksLikeScriptHeader(data);
+    }
+    async execute(options) {
+        if (!this.initialized)
+            await this.initialize();
+        if (!this.initialized)
+            throw this.createVMError('VM not initialized');
+        const startTime = Date.now();
+        try {
+            let scriptData;
+            const hasScriptHeader = this.looksLikeScriptHeader(options.bytecode);
+            const hasOptimizedHeader = this.looksLikeOptimizedHeader(options.bytecode);
+            if (hasScriptHeader || hasOptimizedHeader) {
+                scriptData = options.bytecode;
+            }
+            else {
+                if (!wrap_with_script_header) {
+                    // Fallback if binding missing
+                    scriptData = options.bytecode;
+                }
+                else {
+                    const wrapped = wrap_with_script_header(options.bytecode);
+                    scriptData = new Uint8Array(wrapped);
+                }
+            }
+            // Create VM instance
+            this.vm = new FiveVMWasm(scriptData);
+            const wasmAccounts = this.convertAccountsToWasm(options.accounts || []);
+            const inputData = options.inputData || new Uint8Array(0);
+            // Execute
+            const result = this.vm.execute_partial(inputData, wasmAccounts);
+            const executionTime = Date.now() - startTime;
+            return this.parseVMResult(result, executionTime);
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            return {
+                success: false,
+                error: {
+                    type: 'ExecutionError',
+                    message: error instanceof Error ? error.message : 'Unknown VM error',
+                    instructionPointer: 0,
+                    stackTrace: [],
+                    errorCode: -1
+                },
+                executionTime,
+                logs: []
+            };
+        }
+    }
+    parseVMResult(result, executionTime) {
+        let resultValue = null;
+        let success = false;
+        let status = 'Failed';
+        let errorMessage = undefined;
+        // Handle simple string results.
+        if (typeof result === 'string') {
+            if (result.startsWith('Ok(')) {
+                success = true;
+                status = 'Completed';
+                // Regex parsing for basic types
+                const u64Match = result.match(/Ok\(Some\(U64\((\d+)\)\)\)/);
+                if (u64Match)
+                    resultValue = { type: 'U64', value: parseInt(u64Match[1]) };
+                // ... (Can expand primitive parsing if needed, but maintaining minimal logic here)
+            }
+            else if (result.startsWith('Err(')) {
+                success = false;
+                status = 'Failed';
+                errorMessage = result;
+            }
+        }
+        else {
+            // Handle Object result (WASM binding struct)
+            const resultStatus = typeof result.status === 'function' ? result.status() : result.status;
+            success = resultStatus === 'Completed';
+            status = resultStatus || 'Completed';
+            const resultErrorMessage = typeof result.error_message === 'function' ? result.error_message() : result.error_message;
+            errorMessage = resultErrorMessage;
+            if (result.has_result_value) {
+                const raw = result.get_result_value;
+                resultValue = typeof raw === 'bigint' ? Number(raw) : raw;
+            }
+            else if (result.result_value !== undefined) {
+                resultValue = result.result_value;
+            }
+        }
+        return {
+            success,
+            result: resultValue,
+            computeUnitsUsed: typeof result === 'object' ? result.compute_units_used : 0,
+            executionTime,
+            logs: [],
+            status,
+            stoppedAt: typeof result === 'object' ? result.stopped_at_opcode_name : undefined,
+            errorMessage
+        };
+    }
+    async executeFunction(bytecode, functionIndex, parameters, accounts) {
+        if (!this.initialized)
+            await this.initialize();
+        // Import BytecodeEncoder
+        const { BytecodeEncoder } = await import('../lib/bytecode-encoder.js');
+        // Pass typed parameters through to WASM encoder
+        const typedParams = parameters.map(param => ({
+            type: param.type,
+            value: param.value
+        }));
+        if (!ParameterEncoder || !ParameterEncoder.encode_execute) {
+            throw new Error('ParameterEncoder WASM binding not loaded or missing encode_execute');
+        }
+        // Use WASM binding to encode parameters (returns fixed-size encoded params)
+        const rawParams = ParameterEncoder.encode_execute(functionIndex, typedParams);
+        // EXECUTE_INSTRUCTION is 9 (matches on-chain protocol)
+        const discriminator = new Uint8Array([9]);
+        // Encode function index as u32 little endian
+        const functionIndexBytes = BytecodeEncoder.encodeU32(functionIndex);
+        // Assemble: [discriminator, function_index(u32), param_count(u32), rawParams...]
+        // Construct instruction:
+        const functionIndexArr = BytecodeEncoder.encodeU32(functionIndex); // 4 bytes
+        const paramCountArr = BytecodeEncoder.encodeU32(parameters.length);
+        const properInstructionData = new Uint8Array(discriminator.length + functionIndexArr.length + paramCountArr.length + rawParams.length);
+        properInstructionData.set(discriminator, 0);
+        properInstructionData.set(functionIndexArr, discriminator.length);
+        properInstructionData.set(paramCountArr, discriminator.length + functionIndexArr.length);
+        properInstructionData.set(rawParams, discriminator.length + functionIndexArr.length + paramCountArr.length);
+        return await this.execute({
+            bytecode,
+            inputData: properInstructionData,
+            accounts: accounts || []
+        });
+    }
+    async getState() {
+        if (!this.vm)
+            throw this.createVMError('No VM instance available');
+        return JSON.parse(this.vm.get_state());
+    }
+    async validateBytecode(bytecode) {
+        if (!this.initialized)
+            await this.initialize();
+        try {
+            const valid = FiveVMWasm.validate_bytecode(bytecode);
+            return { valid };
+        }
+        catch (error) {
+            return { valid: false, error: String(error) };
+        }
+    }
+    getVMConstants() {
+        if (!this.initialized)
+            throw this.createVMError('VM not initialized');
+        return JSON.parse(FiveVMWasm.get_constants());
+    }
+    convertAccountsToWasm(accounts) {
+        const wasmAccounts = [];
+        for (const account of accounts) {
+            try {
+                const wasmAccount = new WasmAccount(account.key, account.data || new Uint8Array(0), account.lamports || 0, account.isWritable || false, account.isSigner || false, account.owner || new Uint8Array(32));
+                wasmAccounts.push(wasmAccount);
+            }
+            catch (error) {
+                this.loggerwarn(`Failed to convert account ${account.key}: ${error}`);
+            }
+        }
+        return wasmAccounts;
+    }
+    loggerwarn(msg) {
+        if (this.logger && this.logger.warn)
+            this.logger.warn(msg);
+        else
+            console.warn(msg);
+    }
+    createVMError(message, cause) {
+        const error = new Error(message);
+        error.name = 'VMError';
+        error.code = 'VM_ERROR';
+        error.category = 'wasm';
+        if (cause) {
+            error.details = { cause: cause.message };
+        }
+        return error;
+    }
+    getVMInfo() {
+        return { version: '1.0.0', features: ['wasm', 'sdk'] };
+    }
+    isReady() { return this.initialized; }
+    cleanup() { this.vm = null; }
+}