@5ive-tech/sdk 1.1.2

package/dist/modules/fees.js

@@ -0,0 +1,112 @@
+import { RentCalculator } from "../crypto/index.js";
+import { getVMState } from "./vm-state.js";
+export async function getFees(connection, fiveVMProgramId) {
+    try {
+        const state = await getVMState(connection, fiveVMProgramId);
+        return {
+            deployFeeBps: state.deployFeeBps,
+            executeFeeBps: state.executeFeeBps,
+            adminAccount: state.authority
+        };
+    }
+    catch (error) {
+        return {
+            deployFeeBps: 0,
+            executeFeeBps: 0,
+            adminAccount: null
+        };
+    }
+}
+export async function calculateDeployFee(bytecodeSize, connection, fiveVMProgramId) {
+    try {
+        const accountSize = 64 + bytecodeSize;
+        const rentLamports = await RentCalculator.calculateRentExemption(accountSize);
+        const vmState = await getVMState(connection, fiveVMProgramId);
+        const deployFeeBps = vmState.deployFeeBps;
+        const feeLamports = Math.floor((rentLamports * deployFeeBps) / 10000);
+        return {
+            feeBps: deployFeeBps,
+            basisLamports: rentLamports,
+            feeLamports,
+            totalEstimatedCost: rentLamports + feeLamports,
+            costBreakdown: {
+                basis: RentCalculator.formatSOL(rentLamports),
+                fee: RentCalculator.formatSOL(feeLamports),
+                total: RentCalculator.formatSOL(rentLamports + feeLamports),
+            },
+        };
+    }
+    catch (error) {
+        const accountSize = 64 + bytecodeSize;
+        const rentLamports = await RentCalculator.calculateRentExemption(accountSize);
+        return {
+            feeBps: 0,
+            basisLamports: rentLamports,
+            feeLamports: 0,
+            totalEstimatedCost: rentLamports,
+            costBreakdown: {
+                basis: RentCalculator.formatSOL(rentLamports),
+                fee: "0 SOL",
+                total: RentCalculator.formatSOL(rentLamports),
+            },
+        };
+    }
+}
+export async function calculateExecuteFee(connection, fiveVMProgramId) {
+    const STANDARD_TX_FEE = 5000;
+    try {
+        const vmState = await getVMState(connection, fiveVMProgramId);
+        const executeFeeBps = vmState.executeFeeBps;
+        const feeLamports = Math.floor((STANDARD_TX_FEE * executeFeeBps) / 10000);
+        return {
+            feeBps: executeFeeBps,
+            basisLamports: STANDARD_TX_FEE,
+            feeLamports,
+            totalEstimatedCost: STANDARD_TX_FEE + feeLamports,
+            costBreakdown: {
+                basis: RentCalculator.formatSOL(STANDARD_TX_FEE),
+                fee: RentCalculator.formatSOL(feeLamports),
+                total: RentCalculator.formatSOL(STANDARD_TX_FEE + feeLamports),
+            },
+        };
+    }
+    catch (error) {
+        return {
+            feeBps: 0,
+            basisLamports: 5000,
+            feeLamports: 0,
+            totalEstimatedCost: 5000,
+            costBreakdown: {
+                basis: "0.000005 SOL",
+                fee: "0 SOL",
+                total: "0.000005 SOL",
+            },
+        };
+    }
+}
+export async function getFeeInformation(bytecodeSize, connection, fiveVMProgramId) {
+    try {
+        const [deployFee, executeFee, vmState] = await Promise.all([
+            calculateDeployFee(bytecodeSize, connection, fiveVMProgramId),
+            calculateExecuteFee(connection, fiveVMProgramId),
+            getVMState(connection, fiveVMProgramId),
+        ]);
+        const feesEnabled = vmState.deployFeeBps > 0 || vmState.executeFeeBps > 0;
+        return {
+            deploy: deployFee,
+            execute: executeFee,
+            adminAccount: vmState.authority,
+            feesEnabled,
+        };
+    }
+    catch (error) {
+        const deployFee = await calculateDeployFee(bytecodeSize, connection, fiveVMProgramId);
+        const executeFee = await calculateExecuteFee(connection, fiveVMProgramId);
+        return {
+            deploy: deployFee,
+            execute: executeFee,
+            adminAccount: null,
+            feesEnabled: false,
+        };
+    }
+}

package/dist/modules/namespaces.d.ts

@@ -0,0 +1,39 @@
+export interface ScopedNamespace {
+    symbol: "!" | "@" | "#" | "$" | "%";
+    domain: string;
+    subprogram?: string;
+    canonical: string;
+}
+export declare function canonicalizeScopedNamespace(input: string): ScopedNamespace;
+export declare function namespaceSeedBytes(namespaceValue: string): Uint8Array;
+export declare function resolveNamespaceFromLockfile(namespaceValue: string, lockfile: any): string | undefined;
+export interface NamespaceDerivedAccounts {
+    config: string;
+    tld: string;
+    binding?: string;
+}
+export declare function deriveNamespaceAccounts(namespaceValue: string, fiveVMProgramId: string): Promise<NamespaceDerivedAccounts>;
+interface NamespaceOnChainOptions {
+    managerScriptAccount: string;
+    connection: any;
+    signerKeypair: any;
+    fiveVMProgramId?: string;
+    debug?: boolean;
+}
+export declare function registerNamespaceTldOnChain(namespaceValue: string, options: NamespaceOnChainOptions): Promise<{
+    transactionId?: string;
+    tldAddress: string;
+    owner: string;
+    treasuryAccount: string;
+}>;
+export declare function bindNamespaceOnChain(namespaceValue: string, scriptAccount: string, options: NamespaceOnChainOptions): Promise<{
+    transactionId?: string;
+    bindingAddress: string;
+    owner: string;
+}>;
+export declare function resolveNamespaceOnChain(namespaceValue: string, options: NamespaceOnChainOptions): Promise<{
+    transactionId?: string;
+    resolvedScript?: string;
+    bindingAddress: string;
+}>;
+export {};

package/dist/modules/namespaces.js

@@ -0,0 +1,190 @@
+const SYMBOLS = new Set(["!", "@", "#", "$", "%"]);
+const NAMESPACE_CONFIG_SEED = "5ns_config";
+const NAMESPACE_TLD_SEED = "5ns_tld";
+const NAMESPACE_BINDING_SEED = "5ns_binding";
+export function canonicalizeScopedNamespace(input) {
+    const value = input.trim();
+    if (value.length < 2) {
+        throw new Error("namespace is too short");
+    }
+    const symbol = value[0];
+    if (!SYMBOLS.has(symbol)) {
+        throw new Error("namespace symbol must be one of ! @ # $ %");
+    }
+    const parts = value.slice(1).split("/");
+    if (parts.length === 0 || parts.length > 2) {
+        throw new Error("namespace must be !domain or !domain/subprogram");
+    }
+    const normalize = (seg) => seg.trim().toLowerCase();
+    const domain = normalize(parts[0]);
+    const subprogram = parts[1] ? normalize(parts[1]) : undefined;
+    const validSegment = (seg) => seg.length > 0 && /^[a-z0-9-]+$/.test(seg);
+    if (!validSegment(domain)) {
+        throw new Error("domain must be lowercase alphanumeric + hyphen");
+    }
+    if (subprogram && !validSegment(subprogram)) {
+        throw new Error("subprogram must be lowercase alphanumeric + hyphen");
+    }
+    const canonical = subprogram ? `${symbol}${domain}/${subprogram}` : `${symbol}${domain}`;
+    return {
+        symbol: symbol,
+        domain,
+        subprogram,
+        canonical,
+    };
+}
+export function namespaceSeedBytes(namespaceValue) {
+    const parsed = canonicalizeScopedNamespace(namespaceValue);
+    if (!parsed.subprogram) {
+        throw new Error("namespace seed requires !domain/subprogram");
+    }
+    const seed = `5NS/${parsed.canonical}`;
+    return new TextEncoder().encode(seed);
+}
+export function resolveNamespaceFromLockfile(namespaceValue, lockfile) {
+    const parsed = canonicalizeScopedNamespace(namespaceValue);
+    if (!parsed.subprogram)
+        return undefined;
+    const namespaces = Array.isArray(lockfile?.namespaces) ? lockfile.namespaces : [];
+    const match = namespaces.find((entry) => entry?.namespace === parsed.canonical);
+    return match?.address;
+}
+function asBuffer(value) {
+    return Buffer.from(value, "utf8");
+}
+export async function deriveNamespaceAccounts(namespaceValue, fiveVMProgramId) {
+    const { PDAUtils } = await import("../crypto/index.js");
+    const parsed = canonicalizeScopedNamespace(namespaceValue);
+    const cfg = await PDAUtils.findProgramAddress([asBuffer(NAMESPACE_CONFIG_SEED)], fiveVMProgramId);
+    const tld = await PDAUtils.findProgramAddress([asBuffer(NAMESPACE_TLD_SEED), asBuffer(parsed.symbol), asBuffer(parsed.domain)], fiveVMProgramId);
+    if (!parsed.subprogram) {
+        return {
+            config: cfg.address,
+            tld: tld.address,
+        };
+    }
+    const binding = await PDAUtils.findProgramAddress([
+        asBuffer(NAMESPACE_BINDING_SEED),
+        asBuffer(parsed.symbol),
+        asBuffer(parsed.domain),
+        asBuffer(parsed.subprogram),
+    ], fiveVMProgramId);
+    return {
+        config: cfg.address,
+        tld: tld.address,
+        binding: binding.address,
+    };
+}
+function nowUnix() {
+    return Math.floor(Date.now() / 1000);
+}
+export async function registerNamespaceTldOnChain(namespaceValue, options) {
+    const { ProgramIdResolver } = await import("../config/ProgramIdResolver.js");
+    const { executeOnSolana } = await import("./execute.js");
+    const { getVMState } = await import("./vm-state.js");
+    const parsed = canonicalizeScopedNamespace(namespaceValue);
+    if (parsed.subprogram) {
+        throw new Error("register expects top-level namespace like @domain");
+    }
+    const vmProgramId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const addresses = await deriveNamespaceAccounts(parsed.canonical, vmProgramId);
+    const owner = options.signerKeypair.publicKey.toBase58();
+    const now = nowUnix();
+    const vmState = await getVMState(options.connection, vmProgramId);
+    const treasuryAccount = vmState.authority;
+    if (!treasuryAccount) {
+        throw new Error("VM state authority (treasury) is unavailable");
+    }
+    const result = await executeOnSolana(options.managerScriptAccount, options.connection, options.signerKeypair, "register_tld", [
+        addresses.config,
+        addresses.tld,
+        owner,
+        treasuryAccount,
+        parsed.symbol,
+        parsed.domain,
+        now,
+    ], [addresses.config, addresses.tld, owner, treasuryAccount], {
+        debug: options.debug,
+        fiveVMProgramId: vmProgramId,
+        computeUnitLimit: 500000,
+    });
+    if (!result.success) {
+        throw new Error(result.error || "register_tld failed");
+    }
+    return {
+        transactionId: result.transactionId,
+        tldAddress: addresses.tld,
+        owner,
+        treasuryAccount,
+    };
+}
+export async function bindNamespaceOnChain(namespaceValue, scriptAccount, options) {
+    const { ProgramIdResolver } = await import("../config/ProgramIdResolver.js");
+    const { executeOnSolana } = await import("./execute.js");
+    const parsed = canonicalizeScopedNamespace(namespaceValue);
+    if (!parsed.subprogram) {
+        throw new Error("bind expects namespace with subprogram like @domain/subprogram");
+    }
+    const vmProgramId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const addresses = await deriveNamespaceAccounts(parsed.canonical, vmProgramId);
+    const owner = options.signerKeypair.publicKey.toBase58();
+    const now = nowUnix();
+    const result = await executeOnSolana(options.managerScriptAccount, options.connection, options.signerKeypair, "bind_subprogram", [
+        addresses.tld,
+        addresses.binding,
+        owner,
+        parsed.symbol,
+        parsed.domain,
+        parsed.subprogram,
+        scriptAccount,
+        now,
+    ], [addresses.tld, addresses.binding, owner], {
+        debug: options.debug,
+        fiveVMProgramId: vmProgramId,
+        computeUnitLimit: 650000,
+    });
+    if (!result.success) {
+        throw new Error(result.error || "bind_subprogram failed");
+    }
+    return {
+        transactionId: result.transactionId,
+        bindingAddress: addresses.binding,
+        owner,
+    };
+}
+export async function resolveNamespaceOnChain(namespaceValue, options) {
+    const { ProgramIdResolver } = await import("../config/ProgramIdResolver.js");
+    const { executeOnSolana } = await import("./execute.js");
+    const parsed = canonicalizeScopedNamespace(namespaceValue);
+    if (!parsed.subprogram) {
+        throw new Error("resolve expects namespace with subprogram like @domain/subprogram");
+    }
+    const vmProgramId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const addresses = await deriveNamespaceAccounts(parsed.canonical, vmProgramId);
+    const result = await executeOnSolana(options.managerScriptAccount, options.connection, options.signerKeypair, "resolve", [addresses.binding], [addresses.binding], {
+        debug: options.debug,
+        fiveVMProgramId: vmProgramId,
+        computeUnitLimit: 300000,
+    });
+    if (!result.success) {
+        throw new Error(result.error || "resolve failed");
+    }
+    const raw = result.result;
+    let resolvedScript;
+    if (typeof raw === "string" && raw.length > 0) {
+        resolvedScript = raw;
+    }
+    else if (raw && typeof raw === "object") {
+        if (typeof raw.script_account === "string")
+            resolvedScript = raw.script_account;
+        if (typeof raw.scriptAccount === "string")
+            resolvedScript = raw.scriptAccount;
+        if (typeof raw.value === "string")
+            resolvedScript = raw.value;
+    }
+    return {
+        transactionId: result.transactionId,
+        resolvedScript,
+        bindingAddress: addresses.binding,
+    };
+}

package/dist/modules/state-diff.d.ts

@@ -0,0 +1,35 @@
+export declare function executeWithStateDiff(scriptAccount: string, connection: any, signerKeypair: any, functionName: string | number, parameters?: any[], options?: {
+    debug?: boolean;
+    network?: string;
+    computeUnitLimit?: number;
+    trackGlobalFields?: boolean;
+    additionalAccounts?: string[];
+    includeVMState?: boolean;
+    fiveVMProgramId?: string;
+}): Promise<{
+    success: boolean;
+    execution?: {
+        transactionId?: string;
+        result?: any;
+        computeUnitsUsed?: number;
+        logs?: string[];
+    };
+    stateDiff?: {
+        beforeState: Map<string, any>;
+        afterState: Map<string, any>;
+        changes: Array<{
+            account: string;
+            fieldName?: string;
+            oldValue: any;
+            newValue: any;
+            changeType: "created" | "modified" | "deleted";
+        }>;
+        globalFieldChanges?: Array<{
+            fieldName: string;
+            oldValue: any;
+            newValue: any;
+        }>;
+    };
+    error?: string;
+    logs?: string[];
+}>;