@5ive-tech/sdk 1.1.7 → 1.1.9

package/dist/FiveSDK.d.ts

@@ -4,6 +4,7 @@
 import { FiveSDKConfig, FiveScriptSource, FiveBytecode, CompilationOptions, CompilationResult, DeploymentOptions, SerializedDeployment, SerializedExecution, FiveCompiledFile, FunctionNameEntry, FeeInformation } from "./types.js";
 import { ScriptMetadata } from "./metadata/index.js";
 import * as Namespaces from "./modules/namespaces.js";
+import * as Admin from "./modules/admin.js";
 /**
  * Main Five SDK class - entry point for all Five VM interactions
  */
@@ -14,6 +15,16 @@ export declare class FiveSDK {
     private fiveVMProgramId?;
     private debug;
     private network?;
+    static admin: {
+        generateInitializeVmStateInstruction: typeof Admin.generateInitializeVmStateInstruction;
+        generateSetFeesInstruction: typeof Admin.generateSetFeesInstruction;
+        generateInitFeeVaultInstruction: typeof Admin.generateInitFeeVaultInstruction;
+        generateWithdrawScriptFeesInstruction: typeof Admin.generateWithdrawScriptFeesInstruction;
+        initializeVmStateOnSolana: typeof Admin.initializeVmStateOnSolana;
+        setFeesOnSolana: typeof Admin.setFeesOnSolana;
+        initFeeVaultOnSolana: typeof Admin.initFeeVaultOnSolana;
+        withdrawScriptFeesOnSolana: typeof Admin.withdrawScriptFeesOnSolana;
+    };
     constructor(config?: FiveSDKConfig);
     getConfig(): FiveSDKConfig & {
         network?: string;
@@ -168,11 +179,17 @@ export declare class FiveSDK {
     static getVMState(connection: any, fiveVMProgramId?: string): Promise<{
         authority: string;
         scriptCount: number;
+        deployFeeLamports: number;
+        executeFeeLamports: number;
         deployFeeBps: number;
         executeFeeBps: number;
+        feeVaultShardCount: number;
+        vmStateBump: number;
         isInitialized: boolean;
     }>;
     static getFees(connection: any, fiveVMProgramId?: string): Promise<{
+        deployFeeLamports: number;
+        executeFeeLamports: number;
         deployFeeBps: number;
         executeFeeBps: number;
         adminAccount: string | null;

package/dist/FiveSDK.js

@@ -15,6 +15,7 @@ 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";
+import * as Admin from "./modules/admin.js";
 /**
  * Main Five SDK class - entry point for all Five VM interactions
  */
@@ -389,6 +390,16 @@ export class FiveSDK {
 FiveSDK.compiler = null;
 FiveSDK.parameterEncoder = null;
 FiveSDK.metadataCache = new MetadataCache();
+FiveSDK.admin = {
+    generateInitializeVmStateInstruction: Admin.generateInitializeVmStateInstruction,
+    generateSetFeesInstruction: Admin.generateSetFeesInstruction,
+    generateInitFeeVaultInstruction: Admin.generateInitFeeVaultInstruction,
+    generateWithdrawScriptFeesInstruction: Admin.generateWithdrawScriptFeesInstruction,
+    initializeVmStateOnSolana: Admin.initializeVmStateOnSolana,
+    setFeesOnSolana: Admin.setFeesOnSolana,
+    initFeeVaultOnSolana: Admin.initFeeVaultOnSolana,
+    withdrawScriptFeesOnSolana: Admin.withdrawScriptFeesOnSolana,
+};
 // Export helper functions
 export const createFiveSDK = (config) => new FiveSDK(config);
 // Export default

package/dist/assets/vm/five_vm_wasm_bg.wasm.d.ts

@@ -227,19 +227,19 @@ export const bytecodeencoder_encoded_size_u32: (a: number) => number;
 export const bytecodeencoder_encoded_size_u16: (a: number) => number;
 export const parameterencoder_encode_execute: (a: number, b: number, c: number) => void;
 export const get_wasm_compiler_info: () => number;
-export const __wbg_set_wasmsuggestion_confidence: (a: number, b: number) => void;
-export const __wbg_set_wasmenhancedcompilationresult_compilation_time: (a: number, b: number) => void;
-export const __wbg_set_wasmcompilationwithmetrics_compilation_time: (a: number, b: number) => void;
-export const __wbg_set_wasmcompilationresult_compilation_time: (a: number, b: number) => void;
 export const __wbg_get_wasmsuggestion_confidence: (a: number) => number;
 export const __wbg_get_wasmenhancedcompilationresult_compilation_time: (a: number) => number;
 export const __wbg_get_wasmcompilationwithmetrics_compilation_time: (a: number) => number;
 export const __wbg_get_wasmcompilationresult_compilation_time: (a: number) => number;
 export const __wbg_set_wasmenhancedcompilationresult_success: (a: number, b: number) => void;
 export const __wbg_get_wasmenhancedcompilationresult_success: (a: number) => number;
+export const __wbg_set_wasmsuggestion_confidence: (a: number, b: number) => void;
+export const __wbg_set_wasmenhancedcompilationresult_compilation_time: (a: number, b: number) => void;
+export const __wbg_set_wasmcompilationwithmetrics_compilation_time: (a: number, b: number) => void;
+export const __wbg_set_wasmcompilationresult_compilation_time: (a: number, b: number) => void;
 export const __wbg_wasmfivecompiler_free: (a: number, b: number) => void;
-export const __wbg_bytecodeencoder_free: (a: number, b: number) => void;
 export const __wbg_parameterencoder_free: (a: number, b: number) => void;
+export const __wbg_bytecodeencoder_free: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/dist/config/ProgramIdResolver.d.ts

@@ -6,7 +6,7 @@
  * Baked program ID injected at release time (set by scripts/set-default-program-id.sh)
  * Empty string by default; overridden in npm published packages.
  */
-export declare const FIVE_BAKED_PROGRAM_ID = "";
+export declare const FIVE_BAKED_PROGRAM_ID = "4Qxf3pbCse2veUgZVMiAm3nWqJrYo2pT4suxHKMJdK1d";
 /**
  * Centralized resolver for program IDs across all SDK operations.
  * Ensures consistent validation and error messaging.

package/dist/config/ProgramIdResolver.js

@@ -7,7 +7,7 @@ import { validator } from '../validation/index.js';
  * Baked program ID injected at release time (set by scripts/set-default-program-id.sh)
  * Empty string by default; overridden in npm published packages.
  */
-export const FIVE_BAKED_PROGRAM_ID = '';
+export const FIVE_BAKED_PROGRAM_ID = '4Qxf3pbCse2veUgZVMiAm3nWqJrYo2pT4suxHKMJdK1d';
 /**
  * Centralized resolver for program IDs across all SDK operations.
  * Ensures consistent validation and error messaging.

package/dist/crypto/index.js

@@ -2,8 +2,8 @@
  * Five SDK crypto utilities.
  */
 import bs58 from 'bs58';
-import { Point } from '@noble/ed25519';
 import { randomBytes } from 'crypto';
+import { PublicKey } from '@solana/web3.js';
 /**
  * Program Derived Address (PDA) utilities - pure implementation
  */
@@ -65,15 +65,7 @@ export class PDAUtils {
      * Check if hash is off the Ed25519 curve (valid PDA)
      */
     static isOffCurve(hash) {
-        try {
-            // If point conversion succeeds, it's ON the curve
-            Point.fromHex(hash.toString('hex'));
-            return false;
-        }
-        catch {
-            // If point conversion fails, it's OFF the curve (valid PDA)
-            return true;
-        }
+        return !PublicKey.isOnCurve(hash);
     }
     /**
      * Derive metadata account PDA for script

package/dist/modules/admin.d.ts

@@ -0,0 +1,121 @@
+export declare function generateInitializeVmStateInstruction(authority: string, options?: {
+    fiveVMProgramId?: string;
+    payer?: string;
+    vmStateAccount?: string;
+}): Promise<{
+    programId: string;
+    vmStateAccount: string;
+    bump: number;
+    instruction: {
+        programId: string;
+        accounts: Array<{
+            pubkey: string;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+        data: string;
+    };
+    requiredSigners: string[];
+}>;
+export declare function generateSetFeesInstruction(authority: string, deployFeeLamports: number, executeFeeLamports: number, options?: {
+    fiveVMProgramId?: string;
+    vmStateAccount?: string;
+}): Promise<{
+    programId: string;
+    vmStateAccount: string;
+    instruction: {
+        programId: string;
+        accounts: Array<{
+            pubkey: string;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+        data: string;
+    };
+    requiredSigners: string[];
+}>;
+export declare function generateInitFeeVaultInstruction(payer: string, shardIndex: number, options?: {
+    fiveVMProgramId?: string;
+    vmStateAccount?: string;
+    feeVaultAccount?: string;
+}): Promise<{
+    programId: string;
+    vmStateAccount: string;
+    feeVaultAccount: string;
+    bump: number;
+    instruction: {
+        programId: string;
+        accounts: Array<{
+            pubkey: string;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+        data: string;
+    };
+    requiredSigners: string[];
+}>;
+export declare function generateWithdrawScriptFeesInstruction(authority: string, recipient: string, scriptAccount: string, shardIndex: number, lamports: number, options?: {
+    fiveVMProgramId?: string;
+    vmStateAccount?: string;
+    feeVaultAccount?: string;
+}): Promise<{
+    programId: string;
+    vmStateAccount: string;
+    feeVaultAccount: string;
+    instruction: {
+        programId: string;
+        accounts: Array<{
+            pubkey: string;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+        data: string;
+    };
+    requiredSigners: string[];
+}>;
+export declare function initializeVmStateOnSolana(connection: any, authorityKeypair: any, options?: {
+    fiveVMProgramId?: string;
+    payerKeypair?: any;
+    vmStateAccount?: string;
+    maxRetries?: number;
+    debug?: boolean;
+}): Promise<{
+    success: boolean;
+    transactionId?: string;
+    vmStateAccount?: string;
+    error?: string;
+}>;
+export declare function setFeesOnSolana(connection: any, authorityKeypair: any, deployFeeLamports: number, executeFeeLamports: number, options?: {
+    fiveVMProgramId?: string;
+    vmStateAccount?: string;
+    maxRetries?: number;
+}): Promise<{
+    success: boolean;
+    transactionId?: string;
+    vmStateAccount?: string;
+    error?: string;
+}>;
+export declare function initFeeVaultOnSolana(connection: any, payerKeypair: any, shardIndex: number, options?: {
+    fiveVMProgramId?: string;
+    vmStateAccount?: string;
+    feeVaultAccount?: string;
+    maxRetries?: number;
+}): Promise<{
+    success: boolean;
+    transactionId?: string;
+    vmStateAccount?: string;
+    feeVaultAccount?: string;
+    error?: string;
+}>;
+export declare function withdrawScriptFeesOnSolana(connection: any, authorityKeypair: any, recipient: string, scriptAccount: string, shardIndex: number, lamports: number, options?: {
+    fiveVMProgramId?: string;
+    vmStateAccount?: string;
+    feeVaultAccount?: string;
+    maxRetries?: number;
+}): Promise<{
+    success: boolean;
+    transactionId?: string;
+    vmStateAccount?: string;
+    feeVaultAccount?: string;
+    error?: string;
+}>;

package/dist/modules/admin.js

@@ -0,0 +1,327 @@
+import { validator } from "../validation/index.js";
+import { ProgramIdResolver } from "../config/ProgramIdResolver.js";
+import bs58 from "bs58";
+const VM_STATE_SEED = Buffer.from("vm_state", "utf8");
+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,
+]);
+async function deriveCanonicalVmState(programId) {
+    const { PublicKey } = await import("@solana/web3.js");
+    const [pda, bump] = PublicKey.findProgramAddressSync([VM_STATE_SEED], new PublicKey(programId));
+    return { address: pda.toBase58(), bump };
+}
+async function deriveFeeVault(programId, shardIndex) {
+    const { PublicKey } = await import("@solana/web3.js");
+    const [pda, bump] = PublicKey.findProgramAddressSync([FEE_VAULT_NAMESPACE_SEED, Buffer.from([shardIndex & 0xff])], new PublicKey(programId));
+    return { address: pda.toBase58(), bump };
+}
+function encodeInitializeVmState(bump) {
+    return Uint8Array.from([0, bump & 0xff]);
+}
+function encodeSetFees(deployFeeLamports, executeFeeLamports) {
+    const out = new Uint8Array(9);
+    out[0] = 6;
+    const view = new DataView(out.buffer);
+    view.setUint32(1, deployFeeLamports >>> 0, true);
+    view.setUint32(5, executeFeeLamports >>> 0, true);
+    return out;
+}
+function encodeInitFeeVault(shardIndex, bump) {
+    return Uint8Array.from([11, shardIndex & 0xff, bump & 0xff]);
+}
+function encodeWithdrawScriptFees(scriptAccount, shardIndex, lamports) {
+    const out = new Uint8Array(42);
+    out[0] = 12;
+    const scriptBytes = bs58.decode(scriptAccount);
+    if (scriptBytes.length !== 32) {
+        throw new Error("scriptAccount must decode to 32 bytes");
+    }
+    out.set(scriptBytes, 1);
+    out[33] = shardIndex & 0xff;
+    const view = new DataView(out.buffer);
+    view.setBigUint64(34, BigInt(lamports), true);
+    return out;
+}
+function requireU32(name, value) {
+    validator.validateNumber(value, name);
+    if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+        throw new Error(`${name} must be a u32 integer`);
+    }
+}
+function requireU64(name, value) {
+    validator.validateNumber(value, name);
+    if (!Number.isInteger(value) || value < 0 || value > Number.MAX_SAFE_INTEGER) {
+        throw new Error(`${name} must be a non-negative safe integer`);
+    }
+}
+function requireShardIndex(shardIndex) {
+    validator.validateNumber(shardIndex, "shardIndex");
+    if (!Number.isInteger(shardIndex) || shardIndex < 0 || shardIndex > 255) {
+        throw new Error("shardIndex must be in range 0..255");
+    }
+}
+export async function generateInitializeVmStateInstruction(authority, options = {}) {
+    validator.validateBase58Address(authority, "authority");
+    const payer = options.payer || authority;
+    validator.validateBase58Address(payer, "payer");
+    const programId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const canonical = await deriveCanonicalVmState(programId);
+    if (options.vmStateAccount && options.vmStateAccount !== canonical.address) {
+        throw new Error(`vmStateAccount must be canonical PDA ${canonical.address}; got ${options.vmStateAccount}`);
+    }
+    const accounts = [
+        { pubkey: canonical.address, isSigner: false, isWritable: true },
+        { pubkey: authority, isSigner: true, isWritable: false },
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: "11111111111111111111111111111111", isSigner: false, isWritable: false },
+    ];
+    return {
+        programId,
+        vmStateAccount: canonical.address,
+        bump: canonical.bump,
+        instruction: {
+            programId,
+            accounts,
+            data: Buffer.from(encodeInitializeVmState(canonical.bump)).toString("base64"),
+        },
+        requiredSigners: Array.from(new Set([authority, payer])),
+    };
+}
+export async function generateSetFeesInstruction(authority, deployFeeLamports, executeFeeLamports, options = {}) {
+    validator.validateBase58Address(authority, "authority");
+    requireU32("deployFeeLamports", deployFeeLamports);
+    requireU32("executeFeeLamports", executeFeeLamports);
+    const programId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const canonical = await deriveCanonicalVmState(programId);
+    if (options.vmStateAccount && options.vmStateAccount !== canonical.address) {
+        throw new Error(`vmStateAccount must be canonical PDA ${canonical.address}; got ${options.vmStateAccount}`);
+    }
+    const accounts = [
+        { pubkey: canonical.address, isSigner: false, isWritable: true },
+        { pubkey: authority, isSigner: true, isWritable: false },
+    ];
+    return {
+        programId,
+        vmStateAccount: canonical.address,
+        instruction: {
+            programId,
+            accounts,
+            data: Buffer.from(encodeSetFees(deployFeeLamports, executeFeeLamports)).toString("base64"),
+        },
+        requiredSigners: [authority],
+    };
+}
+export async function generateInitFeeVaultInstruction(payer, shardIndex, options = {}) {
+    validator.validateBase58Address(payer, "payer");
+    requireShardIndex(shardIndex);
+    const programId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const canonical = await deriveCanonicalVmState(programId);
+    const feeVault = await deriveFeeVault(programId, shardIndex);
+    if (options.vmStateAccount && options.vmStateAccount !== canonical.address) {
+        throw new Error(`vmStateAccount must be canonical PDA ${canonical.address}; got ${options.vmStateAccount}`);
+    }
+    if (options.feeVaultAccount && options.feeVaultAccount !== feeVault.address) {
+        throw new Error(`feeVaultAccount must be canonical PDA ${feeVault.address}; got ${options.feeVaultAccount}`);
+    }
+    const accounts = [
+        { pubkey: canonical.address, isSigner: false, isWritable: false },
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: feeVault.address, isSigner: false, isWritable: true },
+        { pubkey: "11111111111111111111111111111111", isSigner: false, isWritable: false },
+    ];
+    return {
+        programId,
+        vmStateAccount: canonical.address,
+        feeVaultAccount: feeVault.address,
+        bump: feeVault.bump,
+        instruction: {
+            programId,
+            accounts,
+            data: Buffer.from(encodeInitFeeVault(shardIndex, feeVault.bump)).toString("base64"),
+        },
+        requiredSigners: [payer],
+    };
+}
+export async function generateWithdrawScriptFeesInstruction(authority, recipient, scriptAccount, shardIndex, lamports, options = {}) {
+    validator.validateBase58Address(authority, "authority");
+    validator.validateBase58Address(recipient, "recipient");
+    validator.validateBase58Address(scriptAccount, "scriptAccount");
+    requireShardIndex(shardIndex);
+    requireU64("lamports", lamports);
+    const programId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const canonical = await deriveCanonicalVmState(programId);
+    const feeVault = await deriveFeeVault(programId, shardIndex);
+    if (options.vmStateAccount && options.vmStateAccount !== canonical.address) {
+        throw new Error(`vmStateAccount must be canonical PDA ${canonical.address}; got ${options.vmStateAccount}`);
+    }
+    if (options.feeVaultAccount && options.feeVaultAccount !== feeVault.address) {
+        throw new Error(`feeVaultAccount must be canonical PDA ${feeVault.address}; got ${options.feeVaultAccount}`);
+    }
+    const accounts = [
+        { pubkey: canonical.address, isSigner: false, isWritable: false },
+        { pubkey: authority, isSigner: true, isWritable: false },
+        { pubkey: feeVault.address, isSigner: false, isWritable: true },
+        { pubkey: recipient, isSigner: false, isWritable: true },
+    ];
+    return {
+        programId,
+        vmStateAccount: canonical.address,
+        feeVaultAccount: feeVault.address,
+        instruction: {
+            programId,
+            accounts,
+            data: Buffer.from(encodeWithdrawScriptFees(scriptAccount, shardIndex, lamports)).toString("base64"),
+        },
+        requiredSigners: [authority],
+    };
+}
+export async function initializeVmStateOnSolana(connection, authorityKeypair, options = {}) {
+    const { PublicKey, Transaction, TransactionInstruction } = await import("@solana/web3.js");
+    const payerKeypair = options.payerKeypair || authorityKeypair;
+    const generated = await generateInitializeVmStateInstruction(authorityKeypair.publicKey.toBase58(), {
+        fiveVMProgramId: options.fiveVMProgramId,
+        payer: payerKeypair.publicKey.toBase58(),
+        vmStateAccount: options.vmStateAccount,
+    });
+    const tx = new Transaction().add(new TransactionInstruction({
+        keys: generated.instruction.accounts.map((a) => ({
+            pubkey: new PublicKey(a.pubkey),
+            isSigner: a.isSigner,
+            isWritable: a.isWritable,
+        })),
+        programId: new PublicKey(generated.instruction.programId),
+        data: Buffer.from(generated.instruction.data, "base64"),
+    }));
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = payerKeypair.publicKey;
+    tx.partialSign(payerKeypair);
+    if (authorityKeypair.publicKey.toBase58() !== payerKeypair.publicKey.toBase58()) {
+        tx.partialSign(authorityKeypair);
+    }
+    const signature = await connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: false,
+        preflightCommitment: "confirmed",
+        maxRetries: options.maxRetries || 3,
+    });
+    const confirmation = await connection.confirmTransaction(signature, "confirmed");
+    if (confirmation?.value?.err) {
+        return { success: false, transactionId: signature, vmStateAccount: generated.vmStateAccount, error: JSON.stringify(confirmation.value.err) };
+    }
+    return { success: true, transactionId: signature, vmStateAccount: generated.vmStateAccount };
+}
+export async function setFeesOnSolana(connection, authorityKeypair, deployFeeLamports, executeFeeLamports, options = {}) {
+    const { PublicKey, Transaction, TransactionInstruction } = await import("@solana/web3.js");
+    const generated = await generateSetFeesInstruction(authorityKeypair.publicKey.toBase58(), deployFeeLamports, executeFeeLamports, {
+        fiveVMProgramId: options.fiveVMProgramId,
+        vmStateAccount: options.vmStateAccount,
+    });
+    const tx = new Transaction().add(new TransactionInstruction({
+        keys: generated.instruction.accounts.map((a) => ({
+            pubkey: new PublicKey(a.pubkey),
+            isSigner: a.isSigner,
+            isWritable: a.isWritable,
+        })),
+        programId: new PublicKey(generated.instruction.programId),
+        data: Buffer.from(generated.instruction.data, "base64"),
+    }));
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = authorityKeypair.publicKey;
+    tx.partialSign(authorityKeypair);
+    const signature = await connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: false,
+        preflightCommitment: "confirmed",
+        maxRetries: options.maxRetries || 3,
+    });
+    const confirmation = await connection.confirmTransaction(signature, "confirmed");
+    if (confirmation?.value?.err) {
+        return { success: false, transactionId: signature, vmStateAccount: generated.vmStateAccount, error: JSON.stringify(confirmation.value.err) };
+    }
+    return { success: true, transactionId: signature, vmStateAccount: generated.vmStateAccount };
+}
+export async function initFeeVaultOnSolana(connection, payerKeypair, shardIndex, options = {}) {
+    const { PublicKey, Transaction, TransactionInstruction } = await import("@solana/web3.js");
+    const generated = await generateInitFeeVaultInstruction(payerKeypair.publicKey.toBase58(), shardIndex, {
+        fiveVMProgramId: options.fiveVMProgramId,
+        vmStateAccount: options.vmStateAccount,
+        feeVaultAccount: options.feeVaultAccount,
+    });
+    const tx = new Transaction().add(new TransactionInstruction({
+        keys: generated.instruction.accounts.map((a) => ({
+            pubkey: new PublicKey(a.pubkey),
+            isSigner: a.isSigner,
+            isWritable: a.isWritable,
+        })),
+        programId: new PublicKey(generated.instruction.programId),
+        data: Buffer.from(generated.instruction.data, "base64"),
+    }));
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = payerKeypair.publicKey;
+    tx.partialSign(payerKeypair);
+    const signature = await connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: false,
+        preflightCommitment: "confirmed",
+        maxRetries: options.maxRetries || 3,
+    });
+    const confirmation = await connection.confirmTransaction(signature, "confirmed");
+    if (confirmation?.value?.err) {
+        return {
+            success: false,
+            transactionId: signature,
+            vmStateAccount: generated.vmStateAccount,
+            feeVaultAccount: generated.feeVaultAccount,
+            error: JSON.stringify(confirmation.value.err),
+        };
+    }
+    return {
+        success: true,
+        transactionId: signature,
+        vmStateAccount: generated.vmStateAccount,
+        feeVaultAccount: generated.feeVaultAccount,
+    };
+}
+export async function withdrawScriptFeesOnSolana(connection, authorityKeypair, recipient, scriptAccount, shardIndex, lamports, options = {}) {
+    const { PublicKey, Transaction, TransactionInstruction } = await import("@solana/web3.js");
+    const generated = await generateWithdrawScriptFeesInstruction(authorityKeypair.publicKey.toBase58(), recipient, scriptAccount, shardIndex, lamports, {
+        fiveVMProgramId: options.fiveVMProgramId,
+        vmStateAccount: options.vmStateAccount,
+        feeVaultAccount: options.feeVaultAccount,
+    });
+    const tx = new Transaction().add(new TransactionInstruction({
+        keys: generated.instruction.accounts.map((a) => ({
+            pubkey: new PublicKey(a.pubkey),
+            isSigner: a.isSigner,
+            isWritable: a.isWritable,
+        })),
+        programId: new PublicKey(generated.instruction.programId),
+        data: Buffer.from(generated.instruction.data, "base64"),
+    }));
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = authorityKeypair.publicKey;
+    tx.partialSign(authorityKeypair);
+    const signature = await connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: false,
+        preflightCommitment: "confirmed",
+        maxRetries: options.maxRetries || 3,
+    });
+    const confirmation = await connection.confirmTransaction(signature, "confirmed");
+    if (confirmation?.value?.err) {
+        return {
+            success: false,
+            transactionId: signature,
+            vmStateAccount: generated.vmStateAccount,
+            feeVaultAccount: generated.feeVaultAccount,
+            error: JSON.stringify(confirmation.value.err),
+        };
+    }
+    return {
+        success: true,
+        transactionId: signature,
+        vmStateAccount: generated.vmStateAccount,
+        feeVaultAccount: generated.feeVaultAccount,
+    };
+}

package/dist/modules/deploy.d.ts

@@ -32,6 +32,7 @@ options?: {
     maxRetries?: number;
     fiveVMProgramId?: string;
     vmStateAccount?: string;
+    adminAccount?: string;
     exportMetadata?: ExportMetadataInput;
 }): Promise<{
     success: boolean;
@@ -52,6 +53,8 @@ options?: {
     fiveVMProgramId?: string;
     progressCallback?: (chunk: number, total: number) => void;
     vmStateAccount?: string;
+    adminAccount?: string;
+    forceChunkedSmallProgram?: boolean;
 }): Promise<{
     success: boolean;
     scriptAccount?: string;
@@ -71,7 +74,11 @@ options?: {
     network?: string;
     maxRetries?: number;
     fiveVMProgramId?: string;
+    vmStateAccount?: string;
+    adminAccount?: string;
+    exportMetadata?: ExportMetadataInput;
     progressCallback?: (transaction: number, total: number) => void;
+    forceChunkedSmallProgram?: boolean;
 }): Promise<{
     success: boolean;
     scriptAccount?: string;
@@ -87,4 +94,14 @@ options?: {
     error?: string;
     logs?: string[];
 }>;
+declare function buildInitializeVmStateInstructionData(bump?: number): Buffer;
+declare function createInitLargeProgramInstructionData(expectedSize: number, firstChunk?: Uint8Array): Buffer;
+declare function createAppendBytecodeInstructionData(chunk: Uint8Array): Buffer;
+declare function createFinalizeScriptInstructionData(): Buffer;
+export declare const __deployTestUtils: {
+    buildInitializeVmStateInstructionData: typeof buildInitializeVmStateInstructionData;
+    createInitLargeProgramInstructionData: typeof createInitLargeProgramInstructionData;
+    createAppendBytecodeInstructionData: typeof createAppendBytecodeInstructionData;
+    createFinalizeScriptInstructionData: typeof createFinalizeScriptInstructionData;
+};
 export {};