@5ive-tech/sdk 1.1.2

package/dist/FiveSDK.js

@@ -0,0 +1,395 @@
+/**
+ * Five SDK client for Five VM scripts.
+ */
+import { FiveSDKError, } from "./types.js";
+import { BytecodeCompiler } from "./compiler/BytecodeCompiler.js";
+import { ParameterEncoder } from "./encoding/ParameterEncoder.js";
+import { ScriptMetadataParser, MetadataCache, } from "./metadata/index.js";
+import { normalizeAbiFunctions, resolveFunctionIndex } from "./utils/abi.js";
+import { validator, Validators } from "./validation/index.js";
+import { ProgramIdResolver } from "./config/ProgramIdResolver.js";
+import * as Deploy from "./modules/deploy.js";
+import * as Execute from "./modules/execute.js";
+import * as Fees from "./modules/fees.js";
+import * as VMState from "./modules/vm-state.js";
+import * as Accounts from "./modules/accounts.js";
+import * as StateDiff from "./modules/state-diff.js";
+import * as Namespaces from "./modules/namespaces.js";
+/**
+ * Main Five SDK class - entry point for all Five VM interactions
+ */
+export class FiveSDK {
+    constructor(config = {}) {
+        // Store the config but resolve at call time
+        this.fiveVMProgramId = config.fiveVMProgramId;
+        this.debug = config.debug || false;
+        this.network = config.network;
+        if (this.debug) {
+            const resolved = ProgramIdResolver.resolveOptional(this.fiveVMProgramId);
+            if (resolved) {
+                console.log(`[FiveSDK] Initialized with Five VM Program: ${resolved}`);
+            }
+            else {
+                console.log(`[FiveSDK] Initialized (program ID will be resolved at call time)`);
+            }
+        }
+    }
+    getConfig() {
+        return {
+            fiveVMProgramId: this.fiveVMProgramId,
+            debug: this.debug,
+            network: this.network,
+        };
+    }
+    static async initializeComponents(debug = false) {
+        if (!this.compiler) {
+            this.compiler = new BytecodeCompiler({ debug });
+        }
+        if (!this.parameterEncoder) {
+            this.parameterEncoder = new ParameterEncoder(debug);
+        }
+    }
+    // ==================== Static Factory Methods ====================
+    static create(options = {}) {
+        return new FiveSDK(options);
+    }
+    static devnet(options = {}) {
+        return new FiveSDK({ ...options, network: "devnet" });
+    }
+    static mainnet(options = {}) {
+        return new FiveSDK({ ...options, network: "mainnet" });
+    }
+    static localnet(options = {}) {
+        return new FiveSDK({ ...options, network: "localnet" });
+    }
+    // ==================== Program ID Defaults ====================
+    /**
+     * Set the default program ID for all SDK instances and operations
+     * Useful when deploying to a known program ID across your application
+     * @param programId - Solana public key (base58 encoded)
+     */
+    static setDefaultProgramId(programId) {
+        ProgramIdResolver.setDefault(programId);
+    }
+    /**
+     * Get the currently set default program ID
+     * @returns The default program ID, or undefined if not set
+     */
+    static getDefaultProgramId() {
+        return ProgramIdResolver.getDefault();
+    }
+    // ==================== Namespaces ====================
+    static canonicalizeNamespace(value) {
+        return Namespaces.canonicalizeScopedNamespace(value);
+    }
+    static namespaceSeedBytes(value) {
+        return Namespaces.namespaceSeedBytes(value);
+    }
+    static resolveNamespaceFromLockfile(value, lockfile) {
+        return Namespaces.resolveNamespaceFromLockfile(value, lockfile);
+    }
+    static async deriveNamespaceAccounts(value, fiveVMProgramId) {
+        return Namespaces.deriveNamespaceAccounts(value, fiveVMProgramId);
+    }
+    static async registerNamespaceTldOnChain(namespaceValue, options) {
+        return Namespaces.registerNamespaceTldOnChain(namespaceValue, options);
+    }
+    static async bindNamespaceOnChain(namespaceValue, scriptAccount, options) {
+        return Namespaces.bindNamespaceOnChain(namespaceValue, scriptAccount, options);
+    }
+    static async resolveNamespaceOnChain(namespaceValue, options) {
+        return Namespaces.resolveNamespaceOnChain(namespaceValue, options);
+    }
+    // ==================== Script Compilation ====================
+    static async compile(source, options = {}) {
+        const sourceContent = typeof source === 'string' ? source : source.content;
+        const sourceFilename = typeof source === 'string' ? 'unknown.v' : source.filename || 'unknown.v';
+        Validators.sourceCode(sourceContent);
+        Validators.options(options);
+        await this.initializeComponents(options.debug);
+        try {
+            const result = await this.compiler.compile(source, options);
+            if (result.success && result.bytecode) {
+                let abiData = result.abi ?? { functions: [], fields: [] };
+                if (options.debug) {
+                    try {
+                        const generatedABI = await this.compiler.generateABI(source);
+                        if (generatedABI && generatedABI.functions) {
+                            abiData = generatedABI;
+                        }
+                    }
+                    catch (abiError) {
+                        console.warn("[FiveSDK] ABI generation failed:", abiError);
+                    }
+                }
+                const functions = normalizeAbiFunctions(abiData.functions ?? abiData)
+                    .map((func) => ({
+                    name: func.name,
+                    index: func.index,
+                    parameters: func.parameters?.map((param) => ({
+                        name: param.name,
+                        type: param.type,
+                        optional: param.optional ?? false,
+                    })) || [],
+                    returnType: func.returnType,
+                }));
+                result.fiveFile = {
+                    filename: sourceFilename,
+                    bytecode: Buffer.from(result.bytecode).toString("base64"),
+                    abi: {
+                        functions,
+                        fields: abiData.fields || [],
+                        version: "1.0",
+                    },
+                    disassembly: result.disassembly || [],
+                    metrics: options.includeMetrics ? result.metrics : undefined,
+                    version: "1.0",
+                };
+                if (result.bytecode) {
+                    const functionNames = await this.getFunctionNames(result.bytecode);
+                    result.functionNames = functionNames;
+                    result.publicFunctionNames = functionNames.map((f) => f.name);
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            throw new FiveSDKError(`Compilation failed: ${error instanceof Error ? error.message : "Unknown error"}`, "COMPILATION_ERROR");
+        }
+    }
+    static async compileModules(mainSource, modules, options = {}) {
+        const mainSourceObj = typeof mainSource === 'string' ? { content: mainSource, filename: 'main.v' } : mainSource;
+        Validators.options(options);
+        await this.initializeComponents(options.debug);
+        if (!this.compiler)
+            throw new FiveSDKError("Compiler not initialized", "COMPILER_ERROR");
+        return this.compiler.compileModules(mainSourceObj, modules, options);
+    }
+    static async compileWithDiscovery(entryPoint, options = {}) {
+        Validators.options(options);
+        await this.initializeComponents(options.debug);
+        if (typeof this.compiler.compileWithDiscovery === 'function') {
+            return this.compiler.compileWithDiscovery(entryPoint, options);
+        }
+        return this.compileFile(entryPoint, options);
+    }
+    static async discoverModules(entryPoint, options = {}) {
+        await this.initializeComponents(options.debug);
+        if (typeof this.compiler.discoverModules === 'function') {
+            return this.compiler.discoverModules(entryPoint);
+        }
+        throw new Error("discoverModules not available in current compiler version");
+    }
+    static async compileFile(filePath, options = {}) {
+        Validators.filePath(filePath);
+        Validators.options(options);
+        await this.initializeComponents(options.debug);
+        return this.compiler.compileFile(filePath, options);
+    }
+    // ==================== Five File Format Utilities ====================
+    static async loadFiveFile(fileContent) {
+        try {
+            const fiveFile = JSON.parse(fileContent);
+            if (!fiveFile.bytecode || !fiveFile.abi) {
+                throw new Error("Invalid .five file format: missing bytecode or ABI");
+            }
+            const bytecode = new Uint8Array(Buffer.from(fiveFile.bytecode, "base64"));
+            return { bytecode, abi: fiveFile.abi, debug: fiveFile.debug };
+        }
+        catch (error) {
+            throw new FiveSDKError(`Failed to load .five file: ${error instanceof Error ? error.message : "Unknown error"}`, "FILE_LOAD_ERROR");
+        }
+    }
+    static extractBytecode(fiveFile) {
+        return new Uint8Array(Buffer.from(fiveFile.bytecode, "base64"));
+    }
+    static resolveFunctionIndex(abi, functionName) {
+        return resolveFunctionIndex(abi, functionName);
+    }
+    // ==================== WASM VM Direct Execution ====================
+    static async executeLocally(bytecode, functionName, parameters = [], options = {}) {
+        return Execute.executeLocally(bytecode, functionName, parameters, options);
+    }
+    static async execute(source, functionName, parameters = [], options = {}) {
+        await this.initializeComponents(options.debug);
+        return Execute.execute(this.compiler, source, functionName, parameters, options);
+    }
+    static async validateBytecode(bytecode, options = {}) {
+        Validators.bytecode(bytecode);
+        Validators.options(options);
+        await this.initializeComponents(options.debug);
+        // Using compile's validateSource? No, validateBytecode logic is in FiveSDK using loadWasmVM.
+        // I moved loadWasmVM to instance.ts but validateBytecode logic was in FiveSDK.
+        // I should have moved validateBytecode logic to execute.ts or validation/index.ts or a new module.
+        // I forgot to move `validateBytecode`. It was in `FiveSDK.ts`.
+        // I can invoke `loadWasmVM` here and call it.
+        try {
+            const { loadWasmVM } = await import("./wasm/instance.js");
+            const wasmVM = await loadWasmVM();
+            return await wasmVM.validateBytecode(bytecode);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                errors: [error instanceof Error ? error.message : "Unknown validation error"],
+            };
+        }
+    }
+    // ==================== Deployment ====================
+    static async generateDeployInstruction(bytecode, deployer, options = {}, connection) {
+        return Deploy.generateDeployInstruction(bytecode, deployer, options, connection);
+    }
+    // ==================== Execution ====================
+    static async generateExecuteInstruction(scriptAccount, functionName, parameters = [], accounts = [], connection, options = {}) {
+        return Execute.generateExecuteInstruction(scriptAccount, functionName, parameters, accounts, connection, options);
+    }
+    // ==================== VM State & Fees ====================
+    static async getVMState(connection, fiveVMProgramId) {
+        return VMState.getVMState(connection, fiveVMProgramId);
+    }
+    static async getFees(connection, fiveVMProgramId) {
+        return Fees.getFees(connection, fiveVMProgramId);
+    }
+    static async calculateDeployFee(bytecodeSize, connection, fiveVMProgramId) {
+        return Fees.calculateDeployFee(bytecodeSize, connection, fiveVMProgramId);
+    }
+    static async calculateExecuteFee(connection, fiveVMProgramId) {
+        return Fees.calculateExecuteFee(connection, fiveVMProgramId);
+    }
+    static async getFeeInformation(bytecodeSize, connection, fiveVMProgramId) {
+        return Fees.getFeeInformation(bytecodeSize, connection, fiveVMProgramId);
+    }
+    // ==================== Script Analysis ====================
+    static async getScriptMetadata(scriptAccount, connection) {
+        validator.validateBase58Address(scriptAccount, "scriptAccount");
+        if (!connection)
+            throw new Error("No connection provided");
+        const metadata = await ScriptMetadataParser.getScriptMetadata(connection, scriptAccount);
+        const normalizedFunctions = normalizeAbiFunctions(metadata.abi?.functions ?? metadata.abi);
+        return {
+            functions: normalizedFunctions.map((func) => ({
+                name: func.name,
+                index: func.index,
+                parameters: func.parameters,
+                returnType: func.returnType,
+                visibility: func.visibility,
+            })),
+        };
+    }
+    static async getScriptMetadataWithConnection(scriptAccount, connection) {
+        validator.validateBase58Address(scriptAccount, "scriptAccount");
+        return ScriptMetadataParser.getScriptMetadata(connection, scriptAccount);
+    }
+    static parseScriptMetadata(accountData, address) {
+        Validators.bytecode(accountData);
+        validator.validateBase58Address(address, "address");
+        return ScriptMetadataParser.parseMetadata(accountData, address);
+    }
+    static async getCachedScriptMetadata(scriptAccount, connection, cacheTTL = 5 * 60 * 1000) {
+        validator.validateBase58Address(scriptAccount, "scriptAccount");
+        validator.validateNumber(cacheTTL, "cacheTTL");
+        return this.metadataCache.getMetadata(scriptAccount, (address) => ScriptMetadataParser.getScriptMetadata(connection, address), cacheTTL);
+    }
+    static invalidateMetadataCache(scriptAccount) {
+        validator.validateBase58Address(scriptAccount, "scriptAccount");
+        this.metadataCache.invalidate(scriptAccount);
+    }
+    static getMetadataCacheStats() {
+        return this.metadataCache.getStats();
+    }
+    // ==================== Utilities ====================
+    static async executeOnSolana(scriptAccount, connection, signerKeypair, functionName, parameters = [], accounts = [], options = {}) {
+        return Execute.executeOnSolana(scriptAccount, connection, signerKeypair, functionName, parameters, accounts, options);
+    }
+    static async executeScriptAccount(scriptAccount, functionIndex = 0, parameters = [], connection, signerKeypair, options = {}) {
+        return Execute.executeScriptAccount(scriptAccount, functionIndex, parameters, connection, signerKeypair, options);
+    }
+    static async getFunctionNames(bytecode) {
+        await this.initializeComponents(false);
+        try {
+            const namesJson = await this.compiler.getFunctionNames(bytecode);
+            if (Array.isArray(namesJson))
+                return namesJson;
+            return JSON.parse(namesJson);
+        }
+        catch (error) {
+            console.warn("[FiveSDK] Failed to extract function names:", error);
+            return [];
+        }
+    }
+    static async callFunctionByName(scriptAccount, functionName, parameters = [], accounts = [], connection, options = {}) {
+        const available = await this.getFunctionNamesFromScriptAccount(scriptAccount, connection);
+        if (!available) {
+            throw new Error(`Cannot resolve function name "${functionName}"`);
+        }
+        const funcInfo = available.find((f) => f.name === functionName);
+        if (!funcInfo) {
+            throw new Error(`Function "${functionName}" not found`);
+        }
+        return this.executeByIndex(scriptAccount, funcInfo.function_index, parameters, accounts, connection, options);
+    }
+    static async executeByIndex(scriptAccount, functionIndex, parameters = [], accounts = [], connection, options = {}) {
+        return this.generateExecuteInstruction(scriptAccount, functionIndex, parameters, accounts, connection, options);
+    }
+    static async getFunctionNamesFromScriptAccount(scriptAccount, connection) {
+        if (!connection)
+            return null;
+        try {
+            const { PublicKey } = await import("@solana/web3.js");
+            const accountInfo = await connection.getAccountInfo(new PublicKey(scriptAccount), "confirmed");
+            if (!accountInfo)
+                return null;
+            const data = accountInfo.data;
+            // Extract bytecode from account data.
+            const scriptHeaderSize = 64;
+            let bytecode = data;
+            if (data.length >= scriptHeaderSize && data[0] === 0x35 && data[1] === 0x49 && data[2] === 0x56 && data[3] === 0x45) {
+                const readU32LE = (buffer, offset) => buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24);
+                const bytecodeLen = readU32LE(data, 48);
+                const metadataLen = readU32LE(data, 52);
+                const bytecodeStart = scriptHeaderSize + metadataLen;
+                if (bytecodeLen > 0 && (bytecodeStart + bytecodeLen) <= data.length) {
+                    bytecode = data.slice(bytecodeStart, bytecodeStart + bytecodeLen);
+                }
+            }
+            return await this.getFunctionNames(bytecode);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    static async createDeploymentTransaction(bytecode, connection, deployerPublicKey, options = {}) {
+        return Deploy.createDeploymentTransaction(bytecode, connection, deployerPublicKey, options);
+    }
+    static async deployToSolana(bytecode, connection, deployerKeypair, options = {}) {
+        return Deploy.deployToSolana(bytecode, connection, deployerKeypair, options);
+    }
+    static async deployLargeProgramToSolana(bytecode, connection, deployerKeypair, options = {}) {
+        return Deploy.deployLargeProgramToSolana(bytecode, connection, deployerKeypair, options);
+    }
+    static async deployLargeProgramOptimizedToSolana(bytecode, connection, deployerKeypair, options = {}) {
+        return Deploy.deployLargeProgramOptimizedToSolana(bytecode, connection, deployerKeypair, options);
+    }
+    static async fetchAccountAndDeserialize(accountAddress, connection, options = {}) {
+        return Accounts.fetchAccountAndDeserialize(accountAddress, connection, options);
+    }
+    static async fetchMultipleAccountsAndDeserialize(accountAddresses, connection, options = {}) {
+        return Accounts.fetchMultipleAccountsAndDeserialize(accountAddresses, connection, options);
+    }
+    static async deserializeParameters(instructionData, expectedTypes = [], options = {}) {
+        return Accounts.deserializeParameters(instructionData, expectedTypes, options);
+    }
+    static async validateBytecodeEncoding(bytecode, debug = false) {
+        return Accounts.validateBytecodeEncoding(bytecode, debug);
+    }
+    static async executeWithStateDiff(scriptAccount, connection, signerKeypair, functionName, parameters = [], options = {}) {
+        return StateDiff.executeWithStateDiff(scriptAccount, connection, signerKeypair, functionName, parameters, options);
+    }
+}
+FiveSDK.compiler = null;
+FiveSDK.parameterEncoder = null;
+FiveSDK.metadataCache = new MetadataCache();
+// Export helper functions
+export const createFiveSDK = (config) => new FiveSDK(config);
+// Export default
+export default FiveSDK;

package/dist/accounts/index.d.ts

@@ -0,0 +1,254 @@
+/**
+ * Five SDK Account System
+ *
+ * Client-agnostic account management system with validation, PDA derivation,
+ * and account size calculations. Uses serialization instead of direct blockchain calls.
+ */
+/**
+ * Account data interface (replaces Web3.js AccountInfo)
+ */
+export interface AccountData {
+    /** Account address */
+    address: string;
+    /** Account data */
+    data: Uint8Array;
+    /** Account owner program ID */
+    owner: string;
+    /** Account balance in lamports */
+    lamports: number;
+}
+/**
+ * Account types in the Five VM ecosystem
+ */
+export type AccountType = 'script' | 'metadata' | 'user_state' | 'system' | 'rent_sysvar' | 'clock_sysvar' | 'spl_token' | 'custom';
+/**
+ * AccountType enum for test compatibility
+ */
+export declare const AccountType: {
+    readonly SCRIPT: "script";
+    readonly METADATA: "metadata";
+    readonly USER_STATE: "user_state";
+    readonly SYSTEM: "system";
+    readonly RENT_SYSVAR: "rent_sysvar";
+    readonly CLOCK_SYSVAR: "clock_sysvar";
+    readonly SPL_TOKEN: "spl_token";
+    readonly CUSTOM: "custom";
+};
+/**
+ * Account information with Five VM context
+ */
+export interface FiveAccount {
+    /** Account address */
+    address: string;
+    /** Account type */
+    type: AccountType;
+    /** Whether account is signer */
+    isSigner: boolean;
+    /** Whether account is writable */
+    isWritable: boolean;
+    /** Whether account is required for execution */
+    required?: boolean;
+    /** Account owner program ID */
+    owner?: string;
+    /** Account data size */
+    size?: number;
+    /** Account lamports balance */
+    lamports?: number;
+    /** Account data */
+    data?: Uint8Array;
+    /** PDA derivation info (if applicable) */
+    pda?: {
+        seeds: Uint8Array[];
+        bump: number;
+    };
+}
+/**
+ * Account constraints for script execution
+ */
+export interface AccountConstraints {
+    /** Maximum number of accounts allowed */
+    maxAccounts?: number;
+    /** Maximum total size across all accounts */
+    maxTotalSize?: number;
+    /** Maximum rent cost allowed */
+    maxRentCost?: number;
+    /** Required account types that must be present */
+    requiredTypes?: AccountType[];
+    /** Required signers */
+    signers?: string[];
+    /** Required writable accounts */
+    writableAccounts?: string[];
+    /** Required readonly accounts */
+    readonlyAccounts?: string[];
+    /** Account type constraints */
+    typeConstraints?: Map<string, AccountType>;
+    /** Minimum rent exemption requirements */
+    rentRequirements?: Map<string, number>;
+}
+/**
+ * Account validation result
+ */
+export interface AccountValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Validation errors */
+    errors: string[];
+    /** Validation warnings */
+    warnings: string[];
+    /** Estimated costs */
+    costs?: {
+        rentExemption: number;
+        transactionFee: number;
+        totalCost: number;
+    };
+}
+/**
+ * Account creation parameters
+ */
+export interface CreateAccountParams {
+    /** Account size in bytes */
+    size: number;
+    /** Owner program ID */
+    owner: string;
+    /** Whether to make rent-exempt */
+    rentExempt: boolean;
+    /** Additional lamports beyond rent exemption */
+    additionalLamports?: number;
+}
+/**
+ * Solana transaction instruction interface
+ */
+export interface TransactionInstruction {
+    /** Program ID to invoke */
+    programId: string;
+    /** Account keys and metadata */
+    accounts: Array<{
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }>;
+    /** Instruction data */
+    data: Uint8Array;
+}
+/**
+ * Account manager for Five VM scripts (serialization-based)
+ */
+export declare class FiveAccountManager {
+    private programId;
+    constructor(programId?: string);
+    /**
+     * Encode System Program CreateAccount instruction
+     */
+    private encodeCreateAccountInstruction;
+    /**
+     * Create script account PDA and return serialized instruction
+     */
+    createScriptAccount(bytecode: Uint8Array, payerAddress: string): Promise<{
+        address: string;
+        bump: number;
+        createInstruction: TransactionInstruction;
+        rentLamports: number;
+    }>;
+    /**
+     * Create metadata account for script
+     */
+    createMetadataAccount(scriptAccount: string, payerAddress: string): Promise<{
+        address: string;
+        bump: number;
+        createInstruction: TransactionInstruction;
+        rentLamports: number;
+    }>;
+    /**
+     * Create user state account for script interaction
+     */
+    createUserStateAccount(userPublicKey: string, scriptAccount: string): Promise<{
+        address: string;
+        bump: number;
+        createInstruction: any;
+        rentLamports: number;
+    }>;
+    /**
+     * Validate account constraints for script execution
+     */
+    validateAccountConstraints(accounts: FiveAccount[], constraints: AccountConstraints): Promise<AccountValidationResult>;
+    /**
+     * Get account info using client-agnostic account fetcher interface
+     */
+    getAccountInfo(address: string, accountFetcher?: any): Promise<FiveAccount | null>;
+    /**
+     * Get multiple account infos in batch using client-agnostic interface
+     */
+    getMultipleAccountInfos(addresses: string[], accountFetcher?: any): Promise<Map<string, FiveAccount | null>>;
+    /**
+     * Check if accounts exist and are properly initialized
+     */
+    validateAccountsExist(addresses: string[]): Promise<{
+        existing: string[];
+        missing: string[];
+        invalid: string[];
+    }>;
+    /**
+     * Calculate total costs for account creation
+     */
+    calculateAccountCreationCosts(accounts: Array<{
+        type: AccountType;
+        size: number;
+    }>): Promise<{
+        rentExemption: number;
+        transactionFees: number;
+        total: number;
+        breakdown: Array<{
+            type: AccountType;
+            size: number;
+            rent: number;
+        }>;
+    }>;
+    /**
+     * Build standard account list for script execution
+     */
+    buildExecutionAccounts(scriptAccount: string, userAccount: string, additionalAccounts?: Array<{
+        address: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }>): FiveAccount[];
+    private determineAccountTypeFromData;
+}
+/**
+ * Account utilities for client-agnostic operations
+ */
+export declare class AccountUtils {
+    /**
+     * Build serializable account list (client-agnostic)
+     */
+    static buildSerializableAccounts(accounts: FiveAccount[]): Array<{
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }>;
+    /**
+     * Deduplicate account list while preserving most permissive permissions
+     */
+    static deduplicateAccounts(accounts: FiveAccount[]): FiveAccount[];
+    /**
+     * Sort accounts by standard Solana conventions
+     */
+    static sortAccounts(accounts: FiveAccount[]): FiveAccount[];
+    /**
+     * Validate account list structure and compute statistics
+     */
+    static validateAccountList(accounts: FiveAccount[]): {
+        valid: boolean;
+        errors: string[];
+        totalSize: number;
+        requiredAccounts: FiveAccount[];
+        optionalAccounts: FiveAccount[];
+    };
+    /**
+     * Filter accounts by type
+     */
+    static filterAccountsByType(accounts: FiveAccount[], type: AccountType): FiveAccount[];
+    /**
+     * Calculate total size of accounts
+     */
+    static calculateTotalSize(accounts: FiveAccount[]): number;
+}