@5ive-tech/sdk 1.1.2

package/dist/modules/accounts.js

@@ -0,0 +1,275 @@
+import { ScriptMetadataParser } from "../metadata/index.js";
+import { normalizeAbiFunctions } from "../utils/abi.js";
+import { loadWasmVM } from "../wasm/instance.js";
+import { SolanaPublicKeyUtils } from "../crypto/index.js";
+export async function fetchAccountAndDeserialize(accountAddress, connection, // Solana Connection object
+options = {}) {
+    try {
+        if (options.debug) {
+            console.log(`[FiveSDK] Fetching account and deserializing data: ${accountAddress}`);
+        }
+        if (!SolanaPublicKeyUtils.isValid(accountAddress)) {
+            return {
+                success: false,
+                error: `Invalid account address format: ${accountAddress}`,
+                logs: [],
+            };
+        }
+        const { PublicKey } = await import("@solana/web3.js");
+        let accountPubkey;
+        try {
+            accountPubkey = new PublicKey(accountAddress);
+        }
+        catch (addressError) {
+            return {
+                success: false,
+                error: `Invalid account address format: ${accountAddress}`,
+                logs: [],
+            };
+        }
+        const accountInfo = await connection.getAccountInfo(accountPubkey, "confirmed");
+        if (!accountInfo) {
+            return {
+                success: false,
+                error: `Account not found: ${accountAddress}`,
+                logs: [],
+            };
+        }
+        if (!accountInfo.data || accountInfo.data.length === 0) {
+            return {
+                success: false,
+                error: `Account has no data: ${accountAddress}`,
+                logs: [],
+            };
+        }
+        const logs = [];
+        if (options.debug) {
+            console.log(`[FiveSDK] Account fetched successfully:`);
+            console.log(`  - Address: ${accountAddress}`);
+            console.log(`  - Owner: ${accountInfo.owner.toString()}`);
+            console.log(`  - Lamports: ${accountInfo.lamports}`);
+            console.log(`  - Data length: ${accountInfo.data.length} bytes`);
+            logs.push(`Account fetched: ${accountInfo.data.length} bytes`);
+            logs.push(`Owner: ${accountInfo.owner.toString()}`);
+            logs.push(`Balance: ${accountInfo.lamports / 1e9} SOL`);
+        }
+        const result = {
+            success: true,
+            accountInfo: {
+                address: accountAddress,
+                owner: accountInfo.owner.toString(),
+                lamports: accountInfo.lamports,
+                dataLength: accountInfo.data.length,
+            },
+            logs,
+        };
+        if (options.parseMetadata) {
+            try {
+                const scriptMetadata = ScriptMetadataParser.parseMetadata(accountInfo.data, accountAddress);
+                result.scriptMetadata = scriptMetadata;
+                result.rawBytecode = scriptMetadata.bytecode;
+                result.decodedData = {
+                    header: {
+                        version: scriptMetadata.version,
+                        deployedAt: scriptMetadata.deployedAt,
+                        authority: scriptMetadata.authority,
+                    },
+                    bytecode: scriptMetadata.bytecode,
+                    abi: scriptMetadata.abi,
+                    functions: normalizeAbiFunctions(scriptMetadata.abi?.functions ?? scriptMetadata.abi).map((func) => ({
+                        name: func.name,
+                        index: func.index,
+                        parameters: func.parameters || [],
+                    })),
+                };
+                const parsedFunctions = result.decodedData.functions;
+                if (options.debug) {
+                    console.log(`[FiveSDK] Script metadata parsed successfully:`);
+                    console.log(`  - Script name: ${scriptMetadata.abi.name}`);
+                    console.log(`  - Functions: ${parsedFunctions.length}`);
+                    console.log(`  - Bytecode size: ${scriptMetadata.bytecode.length} bytes`);
+                    console.log(`  - Authority: ${scriptMetadata.authority}`);
+                    logs.push(`Script metadata parsed: ${parsedFunctions.length} functions`);
+                    logs.push(`Bytecode: ${scriptMetadata.bytecode.length} bytes`);
+                }
+            }
+            catch (metadataError) {
+                if (options.debug) {
+                    console.warn(`[FiveSDK] Failed to parse script metadata:`, metadataError);
+                }
+                result.rawBytecode = accountInfo.data;
+                logs.push("Warning: Failed to parse script metadata, treating as raw data");
+            }
+        }
+        else {
+            result.rawBytecode = accountInfo.data;
+            logs.push("Raw account data returned (metadata parsing disabled)");
+        }
+        if (options.validateEncoding && result.rawBytecode) {
+            try {
+                const validation = await validateBytecodeEncoding(result.rawBytecode, options.debug);
+                if (validation.valid) {
+                    logs.push("Encoding validation: PASSED");
+                    if (options.debug) {
+                        console.log(`[FiveSDK] Validation passed: ${validation.info}`);
+                    }
+                }
+                else {
+                    logs.push(`Encoding validation: FAILED - ${validation.error}`);
+                    if (options.debug) {
+                        console.warn(`[FiveSDK] Validation failed: ${validation.error}`);
+                    }
+                }
+            }
+            catch (validationError) {
+                logs.push(`Validation error: ${validationError instanceof Error ? validationError.message : "Unknown error"}`);
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown account fetch error";
+        if (options.debug) {
+            console.error(`[FiveSDK] Account fetch and deserialization failed: ${errorMessage}`);
+        }
+        return {
+            success: false,
+            error: errorMessage,
+            logs: [],
+        };
+    }
+}
+export async function fetchMultipleAccountsAndDeserialize(accountAddresses, connection, options = {}) {
+    const batchSize = options.batchSize || 100;
+    const results = new Map();
+    if (options.debug) {
+        console.log(`[FiveSDK] Batch fetching ${accountAddresses.length} accounts (batch size: ${batchSize})`);
+    }
+    for (let i = 0; i < accountAddresses.length; i += batchSize) {
+        const batch = accountAddresses.slice(i, i + batchSize);
+        if (options.debug) {
+            console.log(`[FiveSDK] Processing batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(accountAddresses.length / batchSize)}`);
+        }
+        const batchPromises = batch.map((address) => fetchAccountAndDeserialize(address, connection, {
+            debug: false,
+            parseMetadata: options.parseMetadata,
+            validateEncoding: options.validateEncoding,
+        }));
+        const batchResults = await Promise.allSettled(batchPromises);
+        batch.forEach((address, index) => {
+            const batchResult = batchResults[index];
+            if (batchResult.status === "fulfilled") {
+                results.set(address, batchResult.value);
+            }
+            else {
+                results.set(address, {
+                    success: false,
+                    error: `Batch processing failed: ${batchResult.reason}`,
+                    logs: [],
+                });
+            }
+        });
+    }
+    if (options.debug) {
+        const successful = Array.from(results.values()).filter((r) => r.success).length;
+        console.log(`[FiveSDK] Batch processing completed: ${successful}/${accountAddresses.length} successful`);
+    }
+    return results;
+}
+export async function deserializeParameters(instructionData, expectedTypes = [], options = {}) {
+    try {
+        if (options.debug) {
+            console.log(`[FiveSDK] Deserializing parameters from ${instructionData.length} bytes:`);
+            console.log(`[FiveSDK] Instruction data (hex):`, Buffer.from(instructionData).toString("hex"));
+            console.log(`[FiveSDK] Expected parameter types:`, expectedTypes);
+        }
+        const wasmVM = await loadWasmVM();
+        try {
+            const wasmModule = await import("../assets/vm/five_vm_wasm.js");
+            if (options.debug) {
+                console.log(`[FiveSDK] Using WASM ParameterEncoder for decoding`);
+            }
+            const decodedResult = wasmModule.ParameterEncoder.decode_instruction_data(instructionData);
+            if (options.debug) {
+                console.log(`[FiveSDK] Decoding result:`, decodedResult);
+            }
+            const parameters = [];
+            if (decodedResult && decodedResult.parameters) {
+                decodedResult.parameters.forEach((param, index) => {
+                    parameters.push({
+                        type: expectedTypes[index] || "unknown",
+                        value: param,
+                    });
+                });
+            }
+            return {
+                success: true,
+                parameters,
+                functionIndex: decodedResult.function_index,
+                discriminator: decodedResult.discriminator,
+            };
+        }
+        catch (wasmError) {
+            if (options.debug) {
+                console.warn(`[FiveSDK] WASM decoding failed:`, wasmError);
+            }
+            throw wasmError;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error
+            ? error.message
+            : "Unknown deserialization error";
+        if (options.debug) {
+            console.error(`[FiveSDK] Parameter deserialization failed: ${errorMessage}`);
+        }
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+export async function validateBytecodeEncoding(bytecode, debug = false) {
+    try {
+        if (bytecode.length < 10) {
+            return { valid: false, error: "Bytecode too short for Five VM format (min 10 bytes)" };
+        }
+        const magicBytes = bytecode.slice(0, 4);
+        const expectedMagic = new Uint8Array([0x35, 0x49, 0x56, 0x45]); // "5IVE"
+        let isValidHeader = true;
+        for (let i = 0; i < 4; i++) {
+            if (magicBytes[i] !== expectedMagic[i]) {
+                isValidHeader = false;
+                break;
+            }
+        }
+        if (!isValidHeader) {
+            return {
+                valid: false,
+                error: 'Invalid Five VM magic bytes (expected "5IVE")',
+            };
+        }
+        // Optimized Header V3:
+        // 0-3: Magic
+        // 4-7: Features (u32 LE)
+        // 8: Public Function Count (u8)
+        // 9: Total Function Count (u8)
+        // Read features as u32 LE
+        const features = bytecode[4] | (bytecode[5] << 8) | (bytecode[6] << 16) | (bytecode[7] << 24);
+        const publicFunctionCount = bytecode[8];
+        const totalFunctionCount = bytecode[9];
+        if (debug) {
+            console.log(`[FiveSDK] Validation - Magic: "5IVE", Features: ${features}, PublicFuncs: ${publicFunctionCount}, TotalFuncs: ${totalFunctionCount}`);
+        }
+        return {
+            valid: true,
+            info: `Valid Five VM bytecode with ${publicFunctionCount}/${totalFunctionCount} functions (features: ${features})`,
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: error instanceof Error ? error.message : "Validation error",
+        };
+    }
+}

package/dist/modules/deploy.d.ts

@@ -0,0 +1,90 @@
+import { FiveBytecode, DeploymentOptions, SerializedDeployment } from "../types.js";
+interface ExportMetadataInterfaceInput {
+    name: string;
+    methodMap?: Record<string, string>;
+}
+interface ExportMetadataInput {
+    methods?: string[];
+    interfaces?: ExportMetadataInterfaceInput[];
+}
+export declare function generateDeployInstruction(bytecode: FiveBytecode, deployer: string, options?: DeploymentOptions & {
+    debug?: boolean;
+}, connection?: any, fiveVMProgramId?: string): Promise<SerializedDeployment>;
+export declare function createDeploymentTransaction(bytecode: FiveBytecode, connection: any, deployerPublicKey: any, // PublicKey
+options?: {
+    debug?: boolean;
+    fiveVMProgramId?: string;
+    computeBudget?: number;
+    exportMetadata?: ExportMetadataInput;
+}): Promise<{
+    transaction: any;
+    scriptKeypair: any;
+    vmStateKeypair: any;
+    programId: string;
+    rentLamports: number;
+}>;
+export declare function deployToSolana(bytecode: FiveBytecode, connection: any, // Solana Connection object
+deployerKeypair: any, // Solana Keypair object
+options?: {
+    debug?: boolean;
+    network?: string;
+    computeBudget?: number;
+    maxRetries?: number;
+    fiveVMProgramId?: string;
+    vmStateAccount?: string;
+    exportMetadata?: ExportMetadataInput;
+}): Promise<{
+    success: boolean;
+    programId?: string;
+    transactionId?: string;
+    deploymentCost?: number;
+    error?: string;
+    logs?: string[];
+    vmStateAccount?: string;
+}>;
+export declare function deployLargeProgramToSolana(bytecode: FiveBytecode, connection: any, // Solana Connection object
+deployerKeypair: any, // Solana Keypair object
+options?: {
+    chunkSize?: number;
+    debug?: boolean;
+    network?: string;
+    maxRetries?: number;
+    fiveVMProgramId?: string;
+    progressCallback?: (chunk: number, total: number) => void;
+    vmStateAccount?: string;
+}): Promise<{
+    success: boolean;
+    scriptAccount?: string;
+    transactionIds?: string[];
+    totalTransactions?: number;
+    deploymentCost?: number;
+    chunksUsed?: number;
+    vmStateAccount?: string;
+    error?: string;
+    logs?: string[];
+}>;
+export declare function deployLargeProgramOptimizedToSolana(bytecode: FiveBytecode, connection: any, // Solana Connection object
+deployerKeypair: any, // Solana Keypair object
+options?: {
+    chunkSize?: number;
+    debug?: boolean;
+    network?: string;
+    maxRetries?: number;
+    fiveVMProgramId?: string;
+    progressCallback?: (transaction: number, total: number) => void;
+}): Promise<{
+    success: boolean;
+    scriptAccount?: string;
+    transactionIds?: string[];
+    totalTransactions?: number;
+    deploymentCost?: number;
+    chunksUsed?: number;
+    vmStateAccount?: string;
+    optimizationSavings?: {
+        transactionsSaved: number;
+        estimatedCostSaved: number;
+    };
+    error?: string;
+    logs?: string[];
+}>;
+export {};