@5ive-tech/sdk 1.1.19 → 1.1.20

package/dist/program/SessionManager.js

@@ -1,4 +1,4 @@
-import { PublicKey } from '@solana/web3.js';
+import { SessionClient, canonicalSessionManagerScriptAccount, scopeHashForFunctions, } from '../session/index.js';
 /**
  * Lightweight helper around a deployed session-manager script.
  * Uses normal Five execute flow; no VM opcode/runtime changes required.
@@ -32,66 +32,52 @@ export class SessionManager {
         }
     }
     static resolveCanonicalIdentity(input = {}) {
-        const vmProgramId = input.vmProgramId || process.env.FIVE_PROGRAM_ID;
+        const vmProgramId = input.vmProgramId || process.env.FIVE_PROGRAM_ID || '';
         if (!vmProgramId) {
             throw new Error('SessionManager canonical identity requires vmProgramId or FIVE_PROGRAM_ID');
         }
-        const vmProgram = new PublicKey(vmProgramId);
-        const [scriptPda] = PublicKey.findProgramAddressSync([Buffer.from('session_v1', 'utf-8')], vmProgram);
+        const scriptPda = canonicalSessionManagerScriptAccount(vmProgramId);
         const cluster = input.cluster || (process.env.FIVE_VM_CLUSTER || 'localnet');
         return {
             cluster,
-            scriptAccount: input.scriptAccount || scriptPda.toBase58(),
-            codeHash: input.codeHash || '11111111111111111111111111111111',
+            scriptAccount: input.scriptAccount || scriptPda,
             version: input.version ?? 1,
             status: input.status || 'active',
         };
     }
     static scopeHashForFunctions(functions) {
-        const sorted = [...functions].sort();
-        // Stable v1 hash seed; caller may replace with stronger domain-specific hashing if desired.
-        let acc = 0n;
-        for (const ch of sorted.join('|')) {
-            acc = (acc * 131n + BigInt(ch.charCodeAt(0))) & ((1n << 256n) - 1n);
-        }
-        return '0x' + acc.toString(16).padStart(64, '0');
+        return scopeHashForFunctions(functions);
     }
     async deriveSessionAddress(authority, delegate, targetProgram) {
         const [pda] = await this.managerProgram.findAddress(['session', authority, delegate, targetProgram], this.managerProgram.getFiveVMProgramId());
         return pda;
     }
     async buildCreateSessionInstruction(params) {
-        const sessionAddress = await this.deriveSessionAddress(params.authority, params.delegate, params.targetProgram);
-        const builder = this.managerProgram
-            .function('create_session')
-            .accounts({
-            session: sessionAddress,
+        const client = new SessionClient({
+            vmProgramId: this.managerProgram.getFiveVMProgramId(),
+            managerScriptAccount: this.managerProgram.getScriptAccount(),
+        });
+        return client.createSessionIx({
             authority: params.authority,
             delegate: params.delegate,
-        })
-            .args({
-            target_program: params.targetProgram,
-            expires_at_slot: params.expiresAtSlot,
-            scope_hash: params.scopeHash,
-            bind_account: params.bindAccount || '11111111111111111111111111111111',
-            nonce: params.nonce || '0x00',
+            targetProgram: params.targetProgram,
+            expiresAtSlot: params.expiresAtSlot,
+            scopeHash: params.scopeHash,
+            bindAccount: params.bindAccount,
+            nonce: params.nonce ? Number(params.nonce) : 0,
+            payer: params.payer,
         });
-        if (params.payer) {
-            builder.payer(params.payer);
-        }
-        return builder.instruction();
     }
     async buildRevokeSessionInstruction(authority, delegate, targetProgram, payer) {
-        const sessionAddress = await this.deriveSessionAddress(authority, delegate, targetProgram);
-        const builder = this.managerProgram
-            .function('revoke_session')
-            .accounts({
-            session: sessionAddress,
+        const client = new SessionClient({
+            vmProgramId: this.managerProgram.getFiveVMProgramId(),
+            managerScriptAccount: this.managerProgram.getScriptAccount(),
+        });
+        return client.revokeSessionIx({
             authority,
+            delegate,
+            targetProgram,
+            payer,
         });
-        if (payer) {
-            builder.payer(payer);
-        }
-        return builder.instruction();
     }
 }

package/dist/session/index.d.ts

@@ -0,0 +1,56 @@
+import { Keypair, PublicKey, TransactionInstruction, type Connection } from '@solana/web3.js';
+export type SessionExecutionMode = 'auto' | 'direct' | 'session' | 'force-direct' | 'force-session';
+export interface SessionExecutionConfig {
+    mode?: SessionExecutionMode;
+    sessionAccountByFunction?: Record<string, string>;
+    delegateSignerByFunction?: Record<string, any>;
+}
+export interface CreateSessionParams {
+    authority: string;
+    delegate: string;
+    targetProgram: string;
+    expiresAtSlot: number;
+    scopeHash: string;
+    bindAccount?: string;
+    nonce?: number;
+    payer?: string;
+}
+export interface RevokeSessionParams {
+    authority: string;
+    delegate: string;
+    targetProgram: string;
+    payer?: string;
+}
+export interface CreateSessionCompatResult {
+    signature: string;
+    schema: 'minimal';
+}
+export declare function scopeHashForFunctions(functionNames: string[]): string;
+export declare function canonicalSessionManagerScriptAccount(vmProgramId: string): string;
+export declare class SessionClient {
+    readonly vmProgramId: string;
+    readonly managerScriptAccount: string;
+    constructor(input: {
+        vmProgramId: string;
+        managerScriptAccount?: string;
+    });
+    static scopeHashForFunctions(functionNames: string[]): string;
+    static canonicalManagerScriptAccount(vmProgramId: string): string;
+    deriveSessionAddress(authority: string, delegate: string, targetProgram: string): Promise<string>;
+    createSessionIx(params: CreateSessionParams): Promise<TransactionInstruction>;
+    createSessionWithCompat(params: CreateSessionParams, send: (ix: TransactionInstruction, schema: 'minimal') => Promise<string>): Promise<CreateSessionCompatResult>;
+    revokeSessionIx(params: RevokeSessionParams): Promise<TransactionInstruction>;
+    prepareSessionAccountTx(input: {
+        connection: Connection;
+        payer: PublicKey;
+        sessionAccount: PublicKey;
+        sessionSpace?: number;
+        delegate?: PublicKey;
+        delegateMinLamports?: number;
+        delegateTopupLamports?: number;
+    }): Promise<{
+        createIx: TransactionInstruction | null;
+        topupIx: TransactionInstruction | null;
+    }>;
+}
+export type SessionDelegateSigner = Keypair;

package/dist/session/index.js

@@ -0,0 +1,153 @@
+import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+import { FiveProgram } from '../program/FiveProgram.js';
+const SYSTEM_PROGRAM = '11111111111111111111111111111111';
+const SESSION_MANAGER_ABI_MINIMAL = {
+    name: 'SessionManager',
+    functions: [
+        {
+            name: 'create_session',
+            index: 0,
+            parameters: [
+                { name: 'session', type: 'Account', is_account: true, attributes: ['mut'] },
+                { name: 'authority', type: 'Account', is_account: true, attributes: ['signer'] },
+                { name: 'delegate', type: 'Account', is_account: true, attributes: [] },
+                { name: 'target_program', type: 'pubkey', is_account: false, attributes: [] },
+                { name: 'expires_at_slot', type: 'u64', is_account: false, attributes: [] },
+                { name: 'scope_hash', type: 'u64', is_account: false, attributes: [] },
+                { name: 'bind_account', type: 'pubkey', is_account: false, attributes: [] },
+                { name: 'nonce', type: 'u64', is_account: false, attributes: [] },
+            ],
+            return_type: null,
+            visibility: 'public',
+            is_public: true,
+            bytecode_offset: 0,
+        },
+        {
+            name: 'revoke_session',
+            index: 1,
+            parameters: [
+                { name: 'session', type: 'Account', is_account: true, attributes: ['mut'] },
+                { name: 'authority', type: 'Account', is_account: true, attributes: ['signer'] },
+            ],
+            return_type: null,
+            visibility: 'public',
+            is_public: true,
+            bytecode_offset: 0,
+        },
+    ],
+};
+export function scopeHashForFunctions(functionNames) {
+    const sorted = [...functionNames].sort();
+    let acc = 0n;
+    const mask = (1n << 64n) - 1n;
+    for (const ch of sorted.join('|')) {
+        acc = (acc * 131n + BigInt(ch.charCodeAt(0))) & mask;
+    }
+    return acc.toString();
+}
+export function canonicalSessionManagerScriptAccount(vmProgramId) {
+    const [scriptPda] = PublicKey.findProgramAddressSync([Buffer.from('session_v1', 'utf-8')], new PublicKey(vmProgramId));
+    return scriptPda.toBase58();
+}
+export class SessionClient {
+    constructor(input) {
+        this.vmProgramId = input.vmProgramId;
+        this.managerScriptAccount =
+            input.managerScriptAccount || canonicalSessionManagerScriptAccount(input.vmProgramId);
+    }
+    static scopeHashForFunctions(functionNames) {
+        return scopeHashForFunctions(functionNames);
+    }
+    static canonicalManagerScriptAccount(vmProgramId) {
+        return canonicalSessionManagerScriptAccount(vmProgramId);
+    }
+    async deriveSessionAddress(authority, delegate, targetProgram) {
+        const [session] = await FiveProgram.fromABI(this.managerScriptAccount, SESSION_MANAGER_ABI_MINIMAL, {
+            fiveVMProgramId: this.vmProgramId,
+        }).findAddress(['session', authority, delegate, targetProgram], this.vmProgramId);
+        return session;
+    }
+    async createSessionIx(params) {
+        const session = await this.deriveSessionAddress(params.authority, params.delegate, params.targetProgram);
+        const program = FiveProgram.fromABI(this.managerScriptAccount, SESSION_MANAGER_ABI_MINIMAL, {
+            fiveVMProgramId: this.vmProgramId,
+        });
+        const argMap = {
+            target_program: params.targetProgram,
+            expires_at_slot: params.expiresAtSlot,
+            scope_hash: params.scopeHash,
+            bind_account: params.bindAccount || SYSTEM_PROGRAM,
+            nonce: params.nonce ?? 0,
+        };
+        const builder = program
+            .function('create_session')
+            .accounts({
+            session,
+            authority: params.authority,
+            delegate: params.delegate,
+        })
+            .args(argMap);
+        builder.payer(params.payer || params.authority);
+        const encoded = await builder.instruction();
+        return new TransactionInstruction({
+            programId: new PublicKey(encoded.programId),
+            keys: encoded.keys.map((k) => ({
+                pubkey: new PublicKey(k.pubkey),
+                isSigner: k.isSigner,
+                isWritable: k.isWritable,
+            })),
+            data: Buffer.from(encoded.data, 'base64'),
+        });
+    }
+    async createSessionWithCompat(params, send) {
+        const minimalIx = await this.createSessionIx(params);
+        return { signature: await send(minimalIx, 'minimal'), schema: 'minimal' };
+    }
+    async revokeSessionIx(params) {
+        const session = await this.deriveSessionAddress(params.authority, params.delegate, params.targetProgram);
+        const program = FiveProgram.fromABI(this.managerScriptAccount, SESSION_MANAGER_ABI_MINIMAL, {
+            fiveVMProgramId: this.vmProgramId,
+        });
+        const builder = program
+            .function('revoke_session')
+            .accounts({ session, authority: params.authority });
+        builder.payer(params.payer || params.authority);
+        const encoded = await builder.instruction();
+        return new TransactionInstruction({
+            programId: new PublicKey(encoded.programId),
+            keys: encoded.keys.map((k) => ({
+                pubkey: new PublicKey(k.pubkey),
+                isSigner: k.isSigner,
+                isWritable: k.isWritable,
+            })),
+            data: Buffer.from(encoded.data, 'base64'),
+        });
+    }
+    async prepareSessionAccountTx(input) {
+        const sessionSpace = input.sessionSpace ?? 256;
+        const accountInfo = await input.connection.getAccountInfo(input.sessionAccount, 'confirmed');
+        let createIx = null;
+        if (!accountInfo) {
+            const lamports = await input.connection.getMinimumBalanceForRentExemption(sessionSpace);
+            createIx = SystemProgram.createAccount({
+                fromPubkey: input.payer,
+                newAccountPubkey: input.sessionAccount,
+                lamports,
+                space: sessionSpace,
+                programId: new PublicKey(this.vmProgramId),
+            });
+        }
+        let topupIx = null;
+        if (input.delegate && input.delegateMinLamports && input.delegateTopupLamports) {
+            const delegateBalance = await input.connection.getBalance(input.delegate, 'confirmed');
+            if (delegateBalance < input.delegateMinLamports) {
+                topupIx = SystemProgram.transfer({
+                    fromPubkey: input.payer,
+                    toPubkey: input.delegate,
+                    lamports: input.delegateTopupLamports,
+                });
+            }
+        }
+        return { createIx, topupIx };
+    }
+}

package/dist/testing/AccountTestFixture.js

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

package/dist/types.d.ts

@@ -224,7 +224,7 @@ export interface CLIError extends Error {
     details?: any;
 }
 /** @deprecated Use ProgramIdResolver with explicit config or cluster config instead. */
-export declare const FIVE_VM_PROGRAM_ID = "5ive58PJUPaTyAe7tvU1bvBi25o7oieLLTRsJDoQNJst";
+export declare const FIVE_VM_PROGRAM_ID = "5ive5uKDkc3Yhyfu1Sk7i3eVPDQUmG2GmTm2FnUZiTJd";
 export interface FiveSDKConfig {
     network?: string;
     connection?: any;

package/dist/types.js

@@ -3,7 +3,7 @@
  */
 // ==================== Legacy SDK Types (for compatibility) ====================
 /** @deprecated Use ProgramIdResolver with explicit config or cluster config instead. */
-export const FIVE_VM_PROGRAM_ID = "5ive58PJUPaTyAe7tvU1bvBi25o7oieLLTRsJDoQNJst";
+export const FIVE_VM_PROGRAM_ID = "5ive5uKDkc3Yhyfu1Sk7i3eVPDQUmG2GmTm2FnUZiTJd";
 export class FiveSDKError extends Error {
     constructor(message, code, details) {
         super(message);

package/dist/wasm/loader.js

@@ -24,10 +24,10 @@ export async function getWasmModule() {
         './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',
+        '../../assets/wasm/five_vm_wasm.cjs',
+        '../assets/wasm/five_vm_wasm.cjs',
+        '../../assets/wasm/five_vm_wasm.js',
+        '../assets/wasm/five_vm_wasm.js',
         // Fallback for direct import (bundler alias)
         'five-wasm',
         'five-vm-wasm'
@@ -45,6 +45,40 @@ export async function getWasmModule() {
         candidates.push(...nodeCandidates);
     }
     const tried = [];
+    const tryResolveLoadedModule = async (mod, pathLabel) => {
+        if (mod && typeof mod.default === 'function') {
+            try {
+                const initialized = await mod.default();
+                const normalizedInit = resolveEncoderModule(initialized);
+                if (normalizedInit) {
+                    wasmModule = normalizedInit;
+                    return wasmModule;
+                }
+            }
+            catch (initErr) {
+                tried.push({ path: pathLabel, error: initErr });
+            }
+        }
+        const normalized = resolveEncoderModule(mod);
+        if (normalized) {
+            wasmModule = normalized;
+            return wasmModule;
+        }
+        return null;
+    };
+    // Browser-first explicit imports so bundlers can statically include wasm modules.
+    if (!isNode) {
+        try {
+            const mod = await import('../assets/wasm/five_vm_wasm.js');
+            const resolved = await tryResolveLoadedModule(mod, '../assets/wasm/five_vm_wasm.js');
+            if (resolved)
+                return resolved;
+            tried.push({ path: '../assets/wasm/five_vm_wasm.js', error: 'Module missing ParameterEncoder export' });
+        }
+        catch (e) {
+            tried.push({ path: '../assets/wasm/five_vm_wasm.js', error: e });
+        }
+    }
     for (const candidate of candidates) {
         try {
             const mod = await import(candidate);
@@ -86,25 +120,9 @@ export async function getWasmModule() {
                     // tried.push({ path: candidate, error: syncErr });
                 }
             }
-            // Universal initialization (Browser/Node) if default export is init function
-            if (mod && typeof mod.default === 'function') {
-                try {
-                    const initialized = await mod.default();
-                    const normalizedInit = resolveEncoderModule(initialized);
-                    if (normalizedInit) {
-                        wasmModule = normalizedInit;
-                        return wasmModule;
-                    }
-                }
-                catch (initErr) {
-                    tried.push({ path: candidate, error: initErr });
-                }
-            }
-            const normalized = resolveEncoderModule(mod);
-            if (normalized) {
-                wasmModule = normalized;
-                return wasmModule;
-            }
+            const resolved = await tryResolveLoadedModule(mod, candidate);
+            if (resolved)
+                return resolved;
             tried.push({ path: candidate, error: 'Module missing ParameterEncoder export' });
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@5ive-tech/sdk",
-  "version": "1.1.19",
+  "version": "1.1.20",
   "description": "Client-agnostic TypeScript SDK for Five VM scripts on Solana",
   "type": "module",
   "main": "dist/index.js",
@@ -33,7 +33,7 @@
     "sync:wasm": "bash ../scripts/sync-wasm-assets.sh",
     "sync:wasm:rebuild": "bash ../scripts/sync-wasm-assets.sh --rebuild",
     "verify:wasm": "bash ../scripts/verify-wasm-sync.sh",
-    "copy-assets": "mkdir -p dist/assets/vm && COPYFILE_DISABLE=1 cp src/assets/vm/* dist/assets/vm/",
+    "copy-assets": "mkdir -p dist/assets/vm dist/assets/wasm && COPYFILE_DISABLE=1 cp src/assets/vm/* dist/assets/vm/ && COPYFILE_DISABLE=1 cp src/assets/wasm/* dist/assets/wasm/",
     "test": "npm run test:jest --",
     "test:example": "node src/examples/basic-usage.js",
     "test:jest": "NODE_OPTIONS=--experimental-vm-modules jest --runInBand",