@5ive-tech/sdk 1.1.12 → 1.1.14

package/dist/modules/execute.js

@@ -23,6 +23,10 @@ const FEE_VAULT_NAMESPACE_SEED = Buffer.from([
 ]);
 const EXECUTE_FEE_HEADER_A = 0xff;
 const EXECUTE_FEE_HEADER_B = 0x53;
+function clampShardCount(rawCount) {
+    const normalized = rawCount > 0 ? rawCount : DEFAULT_FEE_VAULT_SHARD_COUNT;
+    return Math.max(1, Math.min(DEFAULT_FEE_VAULT_SHARD_COUNT, normalized));
+}
 async function deriveProgramFeeVault(programId, shardIndex) {
     const { PublicKey } = await import("@solana/web3.js");
     const [pda, bump] = PublicKey.findProgramAddressSync([FEE_VAULT_NAMESPACE_SEED, Buffer.from([shardIndex])], new PublicKey(programId));
@@ -43,8 +47,7 @@ async function readVMStateShardCount(connection, vmStateAddress) {
         const data = new Uint8Array(info.data);
         if (data.length <= 50)
             return DEFAULT_FEE_VAULT_SHARD_COUNT;
-        const shardCount = data[50];
-        return shardCount > 0 ? shardCount : DEFAULT_FEE_VAULT_SHARD_COUNT;
+        return clampShardCount(data[50]);
     }
     catch {
         return DEFAULT_FEE_VAULT_SHARD_COUNT;
@@ -274,78 +277,142 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         : selectFeeShard(shardCount);
     const feeVault = await deriveProgramFeeVault(programId, feeShardIndex);
     const instructionAccounts = [
+        // Execute runtime reads script/vm_state; keep them readonly.
         { pubkey: scriptAccount, isSigner: false, isWritable: false },
         { pubkey: vmState, isSigner: false, isWritable: false },
     ];
     const abiAccountMetadata = new Map();
-    if (funcDef && funcDef.parameters) {
-        // First pass: detect if there's an @init constraint and find the payer
+    const normalizeAccountPubkey = (value) => {
+        if (!value)
+            return undefined;
+        if (typeof value === "string")
+            return value;
+        if (typeof value.toBase58 === "function")
+            return value.toBase58();
+        if (typeof value.toString === "function") {
+            const str = value.toString();
+            if (str && str !== "[object Object]")
+                return str;
+        }
+        return undefined;
+    };
+    const isAccountParam = (param) => {
+        if (!param)
+            return false;
+        if (param.is_account || param.isAccount)
+            return true;
+        const type = (param.type || param.param_type || "").toString().trim().toLowerCase();
+        return type === "account" || type === "mint" || type === "tokenaccount";
+    };
+    const allParams = funcDef && Array.isArray(funcDef.parameters) ? funcDef.parameters : [];
+    const accountParams = allParams.filter((param) => isAccountParam(param));
+    const hasFullParameterList = allParams.length > 0 && parameters.length === allParams.length;
+    if (accountParams.length > 0) {
+        // First pass: detect if there's an @init constraint and identify payer param.
         let hasInit = false;
-        let payerPubkey;
-        for (let i = 0; i < funcDef.parameters.length; i++) {
-            const param = funcDef.parameters[i];
-            if (param.is_account || param.isAccount) {
-                const attributes = param.attributes || [];
-                if (attributes.includes('init')) {
-                    hasInit = true;
-                    for (let j = 0; j < funcDef.parameters.length; j++) {
-                        const payerParam = funcDef.parameters[j];
-                        if (i !== j &&
-                            (payerParam.is_account || payerParam.isAccount) &&
-                            (payerParam.attributes || []).includes('signer')) {
-                            const payerValue = parameters[j];
-                            payerPubkey = payerValue?.toString();
-                            break;
-                        }
-                    }
+        let initParamName;
+        let payerParamName;
+        for (const param of accountParams) {
+            const attributes = param.attributes || [];
+            if (attributes.includes("init")) {
+                hasInit = true;
+                initParamName = param.name;
+                break;
+            }
+        }
+        if (hasInit) {
+            for (const param of accountParams) {
+                if (param.name !== initParamName &&
+                    (param.attributes || []).includes("signer")) {
+                    payerParamName = param.name;
                     break;
                 }
             }
         }
-        funcDef.parameters.forEach((param, paramIndex) => {
-            if (param.is_account || param.isAccount) {
-                const value = parameters[paramIndex];
-                const pubkey = value?.toString();
+        // Resolve pubkeys for account params in either full-param mode or args-only mode.
+        const accountPubkeysByParamName = new Map();
+        if (hasFullParameterList) {
+            allParams.forEach((param, paramIndex) => {
+                if (!isAccountParam(param))
+                    return;
+                const pubkey = normalizeAccountPubkey(parameters[paramIndex]);
                 if (pubkey) {
-                    const attributes = param.attributes || [];
-                    const isSigner = attributes.includes('signer');
-                    const isWritable = attributes.includes('mut') ||
-                        attributes.includes('init') ||
-                        (hasInit && pubkey === payerPubkey);
-                    const existing = abiAccountMetadata.get(pubkey) || { isSigner: false, isWritable: false };
-                    abiAccountMetadata.set(pubkey, {
-                        isSigner: existing.isSigner || isSigner,
-                        isWritable: existing.isWritable || isWritable
-                    });
+                    accountPubkeysByParamName.set(param.name, pubkey);
+                }
+            });
+        }
+        else {
+            const count = Math.min(accountParams.length, accounts.length);
+            for (let i = 0; i < count; i++) {
+                const paramName = accountParams[i]?.name;
+                const pubkey = accounts[i];
+                if (paramName && pubkey) {
+                    accountPubkeysByParamName.set(paramName, pubkey);
                 }
             }
-        });
+        }
+        for (const param of accountParams) {
+            const pubkey = accountPubkeysByParamName.get(param.name);
+            if (!pubkey)
+                continue;
+            const attributes = param.attributes || [];
+            const isSigner = attributes.includes("signer");
+            const isWritable = attributes.includes("mut") ||
+                attributes.includes("init") ||
+                (hasInit && payerParamName === param.name);
+            const existing = abiAccountMetadata.get(pubkey) || {
+                isSigner: false,
+                isWritable: false,
+            };
+            abiAccountMetadata.set(pubkey, {
+                isSigner: existing.isSigner || isSigner,
+                isWritable: existing.isWritable || isWritable,
+            });
+        }
     }
+    const unknownAccounts = [];
     const userInstructionAccounts = accounts.map((acc) => {
         // Check both derived ABI metadata and passed-in metadata (from FunctionBuilder)
         const abiMetadata = abiAccountMetadata.get(acc);
         const passedMetadata = options.accountMetadata?.get(acc);
-        const metadata = abiMetadata || passedMetadata;
+        const metadata = passedMetadata || abiMetadata;
         const isSigner = metadata ? metadata.isSigner : false;
-        const isWritable = metadata ? metadata.isWritable : true;
+        const isWritable = metadata
+            ? (metadata.isSystemAccount ? false : metadata.isWritable)
+            : false;
+        if (!metadata) {
+            unknownAccounts.push(acc);
+        }
         return {
             pubkey: acc,
             isSigner,
             isWritable
         };
     });
+    if (unknownAccounts.length > 0) {
+        const deduped = Array.from(new Set(unknownAccounts));
+        console.warn(`[FiveSDK] Missing account metadata for ${deduped.join(", ")}; defaulting readonly. Pass accountMetadata or use FiveProgram.function(...).instruction().`);
+    }
     instructionAccounts.push(...userInstructionAccounts);
     const instructionData = encodeExecuteInstruction(functionIndex, encodedParams, actualParamCount, feeShardIndex, options.debug === true);
     // Runtime requires strict tail: [payer, fee_vault, system_program].
+    // Prefer explicit payer, otherwise infer from signer+writable account metadata only.
     const signerCandidates = instructionAccounts
         .filter((acc) => acc.isSigner)
         .map((acc) => acc.pubkey);
-    const inferredPayer = options.payerAccount ||
-        (signerCandidates.length > 0
-            ? signerCandidates[signerCandidates.length - 1]
-            : accounts[0]);
+    const metadataFor = (pubkey) => options.accountMetadata?.get(pubkey) || abiAccountMetadata.get(pubkey);
+    const writableSignerCandidates = signerCandidates.filter((pubkey) => {
+        const metadata = metadataFor(pubkey);
+        if (!metadata)
+            return false;
+        return !metadata.isSystemAccount && metadata.isWritable;
+    });
+    const inferredPayer = options.payerAccount || writableSignerCandidates[0];
     if (!inferredPayer) {
-        throw new Error("Could not infer execute fee payer account. Provide a signer account or set options.payerAccount.");
+        if (signerCandidates.length > 0) {
+            throw new Error("Could not infer execute fee payer account from writable signer metadata. Pass options.payerAccount or use FiveProgram.function(...).payer(...).instruction().");
+        }
+        throw new Error("Could not infer execute fee payer account. Provide options.payerAccount or include a writable signer account.");
     }
     const feeTailAccounts = [
         { pubkey: inferredPayer, isSigner: true, isWritable: true },
@@ -396,6 +463,7 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
                 vmStateAccount: options.vmStateAccount,
                 fiveVMProgramId: options.fiveVMProgramId,
                 abi: options.abi,
+                accountMetadata: options.accountMetadata,
                 feeShardIndex: options.feeShardIndex,
                 payerAccount: options.payerAccount || signerKeypair.publicKey.toString(),
             });
@@ -422,7 +490,6 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
         for (const meta of accountKeys) {
             if (meta.pubkey === signerPubkey) {
                 meta.isSigner = true;
-                meta.isWritable = true;
                 signerFound = true;
             }
         }
@@ -430,7 +497,7 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
             accountKeys.push({
                 pubkey: signerPubkey,
                 isSigner: true,
-                isWritable: true,
+                isWritable: false,
             });
         }
         const executeInstruction = new TransactionInstruction({
@@ -444,8 +511,8 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
         });
         transaction.add(executeInstruction);
         transaction.feePayer = signerKeypair.publicKey;
-        const { blockhash } = await connection.getLatestBlockhash("confirmed");
-        transaction.recentBlockhash = blockhash;
+        const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+        transaction.recentBlockhash = latestBlockhash.blockhash;
         transaction.partialSign(signerKeypair);
         const firstSig = transaction.signatures[0]?.signature;
         if (firstSig) {
@@ -457,12 +524,11 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
             maxRetries: options.maxRetries || 3,
         });
         lastSignature = signature;
-        const latestBlockhash = await connection.getLatestBlockhash("confirmed");
         const confirmation = await confirmTransactionRobust(connection, signature, {
             commitment: "confirmed",
             timeoutMs: 120000,
             debug: options.debug,
-            blockhash,
+            blockhash: latestBlockhash.blockhash,
             lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
         });
         if (!confirmation.success) {

package/dist/modules/fees.js

@@ -24,7 +24,7 @@ export async function getFees(connection, fiveVMProgramId) {
 export async function calculateDeployFee(bytecodeSize, connection, fiveVMProgramId) {
     try {
         const accountSize = 64 + bytecodeSize;
-        const rentLamports = await RentCalculator.calculateRentExemption(accountSize);
+        const rentLamports = await RentCalculator.calculateRentExemptionWithConnection(accountSize, connection);
         const vmState = await getVMState(connection, fiveVMProgramId);
         const deployFeeLamports = vmState.deployFeeLamports;
         return {
@@ -41,7 +41,7 @@ export async function calculateDeployFee(bytecodeSize, connection, fiveVMProgram
     }
     catch (error) {
         const accountSize = 64 + bytecodeSize;
-        const rentLamports = await RentCalculator.calculateRentExemption(accountSize);
+        const rentLamports = await RentCalculator.calculateRentExemptionWithConnection(accountSize, connection);
         return {
             feeBps: 0,
             basisLamports: rentLamports,

package/dist/modules/namespaces.d.ts

@@ -36,4 +36,15 @@ export declare function resolveNamespaceOnChain(namespaceValue: string, options:
     resolvedScript?: string;
     bindingAddress: string;
 }>;
+export declare function setNamespaceSymbolPriceOnChain(symbol: string, priceLamports: number, options: NamespaceOnChainOptions): Promise<{
+    transactionId?: string;
+    symbol: ScopedNamespace["symbol"];
+    priceLamports: number;
+}>;
+export declare function getNamespaceSymbolPriceOnChain(symbol: string, options: NamespaceOnChainOptions): Promise<{
+    transactionId?: string;
+    symbol: ScopedNamespace["symbol"];
+    priceLamports: number;
+    priceSol: number;
+}>;
 export {};

package/dist/modules/namespaces.js

@@ -2,6 +2,7 @@ const SYMBOLS = new Set(["!", "@", "#", "$", "%"]);
 const NAMESPACE_CONFIG_SEED = "5ns_config";
 const NAMESPACE_TLD_SEED = "5ns_tld";
 const NAMESPACE_BINDING_SEED = "5ns_binding";
+const LAMPORTS_PER_SOL = 1000000000;
 export function canonicalizeScopedNamespace(input) {
     const value = input.trim();
     if (value.length < 2) {
@@ -52,6 +53,17 @@ export function resolveNamespaceFromLockfile(namespaceValue, lockfile) {
 function asBuffer(value) {
     return Buffer.from(value, "utf8");
 }
+function validateSymbol(symbol) {
+    if (!SYMBOLS.has(symbol)) {
+        throw new Error("namespace symbol must be one of ! @ # $ %");
+    }
+    return symbol;
+}
+async function deriveNamespaceConfigAccount(fiveVMProgramId) {
+    const { PDAUtils } = await import("../crypto/index.js");
+    const cfg = await PDAUtils.findProgramAddress([asBuffer(NAMESPACE_CONFIG_SEED)], fiveVMProgramId);
+    return cfg.address;
+}
 export async function deriveNamespaceAccounts(namespaceValue, fiveVMProgramId) {
     const { PDAUtils } = await import("../crypto/index.js");
     const parsed = canonicalizeScopedNamespace(namespaceValue);
@@ -188,3 +200,55 @@ export async function resolveNamespaceOnChain(namespaceValue, options) {
         bindingAddress: addresses.binding,
     };
 }
+export async function setNamespaceSymbolPriceOnChain(symbol, priceLamports, options) {
+    const { ProgramIdResolver } = await import("../config/ProgramIdResolver.js");
+    const { executeOnSolana } = await import("./execute.js");
+    const validatedSymbol = validateSymbol(symbol);
+    if (!Number.isFinite(priceLamports) || priceLamports <= 0 || !Number.isInteger(priceLamports)) {
+        throw new Error("priceLamports must be a positive integer");
+    }
+    const vmProgramId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const configAddress = await deriveNamespaceConfigAccount(vmProgramId);
+    const admin = options.signerKeypair.publicKey.toBase58();
+    const result = await executeOnSolana(options.managerScriptAccount, options.connection, options.signerKeypair, "set_symbol_price", [configAddress, admin, validatedSymbol, priceLamports], [configAddress, admin], {
+        debug: options.debug,
+        fiveVMProgramId: vmProgramId,
+        computeUnitLimit: 300000,
+    });
+    if (!result.success) {
+        throw new Error(result.error || "set_symbol_price failed");
+    }
+    return {
+        transactionId: result.transactionId,
+        symbol: validatedSymbol,
+        priceLamports,
+    };
+}
+export async function getNamespaceSymbolPriceOnChain(symbol, options) {
+    const { ProgramIdResolver } = await import("../config/ProgramIdResolver.js");
+    const { executeOnSolana } = await import("./execute.js");
+    const validatedSymbol = validateSymbol(symbol);
+    const vmProgramId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const configAddress = await deriveNamespaceConfigAccount(vmProgramId);
+    const result = await executeOnSolana(options.managerScriptAccount, options.connection, options.signerKeypair, "get_symbol_price", [configAddress, validatedSymbol], [configAddress], {
+        debug: options.debug,
+        fiveVMProgramId: vmProgramId,
+        computeUnitLimit: 300000,
+    });
+    if (!result.success) {
+        throw new Error(result.error || "get_symbol_price failed");
+    }
+    const priceLamportsRaw = typeof result.result === "number"
+        ? result.result
+        : Number(result.result);
+    if (!Number.isFinite(priceLamportsRaw) || priceLamportsRaw < 0) {
+        throw new Error(`invalid get_symbol_price result: ${String(result.result)}`);
+    }
+    const priceLamports = Math.trunc(priceLamportsRaw);
+    return {
+        transactionId: result.transactionId,
+        symbol: validatedSymbol,
+        priceLamports,
+        priceSol: priceLamports / LAMPORTS_PER_SOL,
+    };
+}

package/dist/program/FiveProgram.js

@@ -48,12 +48,13 @@ export class FiveProgram {
                 if (typeof prop === 'string') {
                     return (...args) => {
                         const builder = target.function(prop);
-                        // TODO: Robust argument mapping based on ABI types
-                        // Simple map: if args[0] is object, assume named params
                         if (args.length === 1 && typeof args[0] === 'object' && !Array.isArray(args[0])) {
                             builder.args(args[0]);
                         }
-                        // Logic for positional args would go here
+                        else if (args.length > 0) {
+                            throw new Error(`FiveProgram.methods.${prop} only supports a single named-arguments object. ` +
+                                `Use program.function("${prop}").args({...}) for now.`);
+                        }
                         return builder;
                     };
                 }

package/dist/program/FunctionBuilder.d.ts

@@ -29,6 +29,7 @@ export declare class FunctionBuilder {
     private accountsMap;
     private argsMap;
     private resolvedAccounts;
+    private vmPayerAccount?;
     constructor(functionDef: FunctionDefinition, scriptAccount: string, abi: ScriptABI, options: FiveProgramOptions);
     /**
      * Specify accounts for this function call
@@ -47,6 +48,13 @@ export declare class FunctionBuilder {
      * @returns this for method chaining
      */
     args(args: Record<string, any>): this;
+    /**
+     * Override the VM execute-fee payer account for this instruction.
+     * This is distinct from the outer transaction fee payer.
+     */
+    payer(payer: string | {
+        toBase58(): string;
+    }): this;
     /**
      * Build and return serialized instruction data
      * This is the main method that orchestrates parameter resolution and instruction generation

package/dist/program/FunctionBuilder.js

@@ -62,6 +62,15 @@ export class FunctionBuilder {
         }
         return this;
     }
+    /**
+     * Override the VM execute-fee payer account for this instruction.
+     * This is distinct from the outer transaction fee payer.
+     */
+    payer(payer) {
+        this.vmPayerAccount =
+            typeof payer === 'string' ? payer : payer.toBase58();
+        return this;
+    }
     /**
      * Build and return serialized instruction data
      * This is the main method that orchestrates parameter resolution and instruction generation
@@ -93,7 +102,7 @@ export class FunctionBuilder {
         // Now validate that all required parameters are provided (including auto-injected ones)
         this.validateParameters();
         // Merge parameters in ABI order (accounts first, then data)
-        const { mergedParams, accountPubkeys } = this.mergeParameters();
+        const { mergedParams, argParams, accountPubkeys } = this.mergeParameters();
         // Append system accounts to the account list (they go at the end)
         const allAccountPubkeys = [...accountPubkeys, ...systemAccountsList];
         // Build account metadata from ABI attributes
@@ -105,7 +114,7 @@ export class FunctionBuilder {
         }
         // Call existing SDK method to generate instruction
         // This reuses the proven parameter encoding logic
-        const instruction = await this.generateInstructionData(mergedParams, allAccountPubkeys, accountMetadata);
+        const instruction = await this.generateInstructionData(mergedParams, argParams, allAccountPubkeys, accountMetadata);
         if (this.options.debug) {
             console.log(`[FunctionBuilder] Generated instruction:`, instruction);
         }
@@ -178,6 +187,7 @@ export class FunctionBuilder {
      */
     mergeParameters() {
         const mergedParams = [];
+        const argParams = [];
         const accountPubkeys = [];
         for (const param of this.functionDef.parameters) {
             if (param.is_account) {
@@ -196,9 +206,10 @@ export class FunctionBuilder {
                     throw new Error(`Missing argument '${param.name}'`);
                 }
                 mergedParams.push(value);
+                argParams.push(value);
             }
         }
-        return { mergedParams, accountPubkeys };
+        return { mergedParams, argParams, accountPubkeys };
     }
     /**
      * Build account metadata (isSigner, isWritable) from ABI attributes
@@ -279,14 +290,14 @@ export class FunctionBuilder {
      * @param accountMetadata - Account metadata (isSigner, isWritable)
      * @returns SerializedInstruction
      */
-    async generateInstructionData(mergedParams, accountList, accountMetadata) {
+    async generateInstructionData(mergedParams, argParams, accountList, accountMetadata) {
         // Account list is already passed in
         // Dynamically import FiveSDK to avoid circular dependencies
         const { FiveSDK } = await import('../FiveSDK.js');
         // Call the SDK's generateExecuteInstruction method.
         // This handles fixed-size typed execute encoding and parameter validation.
         const executionResult = await FiveSDK.generateExecuteInstruction(this.scriptAccount, this.functionDef.index, // Use function index directly
-        mergedParams, // All parameters in merged order
+        argParams, // Current VM contract encodes non-account args only
         accountList, // Account pubkey list
         undefined, // No connection needed - we have ABI
         {
@@ -295,6 +306,8 @@ export class FunctionBuilder {
             fiveVMProgramId: this.options.fiveVMProgramId,
             vmStateAccount: this.options.vmStateAccount,
             adminAccount: this.options.feeReceiverAccount,
+            payerAccount: this.vmPayerAccount ||
+                this.options.provider?.publicKey?.toBase58?.(),
             accountMetadata: accountMetadata, // Pass account metadata for correct isWritable flags
         });
         // Map SDK's instruction format (with 'accounts') to SerializedInstruction format (with 'keys')

package/dist/program/TypeGenerator.js

@@ -20,12 +20,19 @@
  * }
  * ```
  */
+import { normalizeAbiFunctions } from '../utils/abi.js';
 /**
  * TypeGenerator creates TypeScript interfaces from ABI
  */
 export class TypeGenerator {
     constructor(abi, options) {
-        this.abi = abi;
+        this.abi = {
+            ...abi,
+            functions: normalizeAbiFunctions(abi.functions ?? abi).map((func) => ({
+                ...func,
+                visibility: func.visibility ?? 'public',
+            })),
+        };
         this.options = {
             scriptName: abi.name || 'Program',
             debug: false,

package/dist/project/config.js

@@ -1,14 +1,28 @@
+const SUPPORTED_SCHEMA_VERSION = 1;
 /**
  * Parses a raw TOML object into a strict ProjectConfig.
  */
 export function parseProjectConfig(parsedToml) {
+    const schemaVersionRaw = parsedToml.schema_version;
+    if (schemaVersionRaw === undefined) {
+        throw new Error(`Missing required top-level 'schema_version'. Add:\nschema_version = ${SUPPORTED_SCHEMA_VERSION}`);
+    }
+    if (!Number.isInteger(schemaVersionRaw) || Number(schemaVersionRaw) <= 0) {
+        throw new Error('schema_version must be a positive integer');
+    }
+    const schemaVersion = Number(schemaVersionRaw);
+    if (schemaVersion !== SUPPORTED_SCHEMA_VERSION) {
+        throw new Error(`Unsupported schema_version=${schemaVersion}. Supported schema_version: ${SUPPORTED_SCHEMA_VERSION}`);
+    }
     const project = parsedToml.project ?? {};
     const build = parsedToml.build ?? {};
     const optimizations = parsedToml.optimizations ?? {};
+    const dependencies = parsedToml.dependencies ?? {};
     const deploy = parsedToml.deploy ?? {};
     const name = project.name ?? 'five-project';
     const target = (project.target ?? 'vm');
     return {
+        schemaVersion,
         name,
         version: project.version ?? '0.1.0',
         description: project.description,
@@ -25,8 +39,106 @@ export function parseProjectConfig(parsedToml) {
         optimizations: {
             enableCompression: optimizations.enable_compression ?? true,
             enableConstraintOptimization: optimizations.enable_constraint_optimization ?? true,
+            // Public SDK config is locked to the canonical production mode.
             optimizationLevel: 'production'
         },
-        dependencies: []
+        dependencies: parseDependencies(dependencies)
     };
 }
+function parseDependencies(rawDeps) {
+    const out = [];
+    const seenNamespaces = new Set();
+    const seenAddresses = new Set();
+    const seenMoatTargets = new Set();
+    for (const [alias, rawValue] of Object.entries(rawDeps ?? {})) {
+        const value = (rawValue ?? {});
+        const dependency = {
+            alias,
+            package: String(value.package ?? ''),
+            version: value.version !== undefined ? String(value.version) : undefined,
+            source: String(value.source ?? ''),
+            link: String(value.link ?? ''),
+            path: value.path !== undefined ? String(value.path) : undefined,
+            namespace: value.namespace !== undefined ? String(value.namespace) : undefined,
+            address: value.address !== undefined ? String(value.address) : undefined,
+            moatAccount: value.moat_account !== undefined ? String(value.moat_account) : undefined,
+            module: value.module !== undefined ? String(value.module) : undefined,
+            pin: value.pin !== undefined ? String(value.pin) : undefined,
+            cluster: value.cluster !== undefined ? String(value.cluster) : undefined,
+        };
+        if (!dependency.package) {
+            throw new Error(`Invalid dependency '${alias}': missing required field 'package'`);
+        }
+        if (dependency.source !== 'bundled' &&
+            dependency.source !== 'path' &&
+            dependency.source !== 'namespace' &&
+            dependency.source !== 'address' &&
+            dependency.source !== 'moat') {
+            throw new Error(`Invalid dependency '${alias}': source must be one of bundled|path|namespace|address|moat`);
+        }
+        if (dependency.link !== 'inline' && dependency.link !== 'external') {
+            throw new Error(`Invalid dependency '${alias}': link must be one of inline|external`);
+        }
+        const hasPath = Boolean(dependency.path);
+        const hasNamespace = Boolean(dependency.namespace);
+        const hasAddress = Boolean(dependency.address);
+        const hasMoatAccount = Boolean(dependency.moatAccount);
+        const hasModule = Boolean(dependency.module);
+        if (dependency.source === 'path' && !hasPath) {
+            throw new Error(`Invalid dependency '${alias}': source=path requires 'path'`);
+        }
+        if (dependency.source === 'namespace' && !hasNamespace) {
+            throw new Error(`Invalid dependency '${alias}': source=namespace requires 'namespace'`);
+        }
+        if (dependency.source === 'address' && !hasAddress) {
+            throw new Error(`Invalid dependency '${alias}': source=address requires 'address'`);
+        }
+        if (dependency.source === 'moat' && (!hasMoatAccount || !hasModule)) {
+            throw new Error(`Invalid dependency '${alias}': source=moat requires 'moat_account' and 'module'`);
+        }
+        if (dependency.source !== 'path' && hasPath) {
+            throw new Error(`Invalid dependency '${alias}': 'path' is only valid for source=path`);
+        }
+        if (dependency.source !== 'namespace' && hasNamespace) {
+            throw new Error(`Invalid dependency '${alias}': 'namespace' is only valid for source=namespace`);
+        }
+        if (dependency.source !== 'address' && hasAddress) {
+            throw new Error(`Invalid dependency '${alias}': 'address' is only valid for source=address`);
+        }
+        if (dependency.source !== 'moat' && hasMoatAccount) {
+            throw new Error(`Invalid dependency '${alias}': 'moat_account' is only valid for source=moat`);
+        }
+        if (dependency.source !== 'moat' && hasModule) {
+            throw new Error(`Invalid dependency '${alias}': 'module' is only valid for source=moat`);
+        }
+        if (dependency.source === 'bundled' || dependency.source === 'path') {
+            if (dependency.link !== 'inline') {
+                throw new Error(`Invalid dependency '${alias}': source=${dependency.source} currently requires link=inline`);
+            }
+        }
+        else if (dependency.link !== 'external') {
+            throw new Error(`Invalid dependency '${alias}': source=${dependency.source} currently requires link=external`);
+        }
+        if (dependency.namespace) {
+            if (seenNamespaces.has(dependency.namespace)) {
+                throw new Error(`Invalid dependencies: duplicate namespace '${dependency.namespace}'`);
+            }
+            seenNamespaces.add(dependency.namespace);
+        }
+        if (dependency.address) {
+            if (seenAddresses.has(dependency.address)) {
+                throw new Error(`Invalid dependencies: duplicate address '${dependency.address}'`);
+            }
+            seenAddresses.add(dependency.address);
+        }
+        if (dependency.moatAccount && dependency.module) {
+            const moatTarget = `${dependency.moatAccount}::${dependency.module}`;
+            if (seenMoatTargets.has(moatTarget)) {
+                throw new Error(`Invalid dependencies: duplicate moat target '${moatTarget}'`);
+            }
+            seenMoatTargets.add(moatTarget);
+        }
+        out.push(dependency);
+    }
+    return out;
+}

package/dist/project/workspace.d.ts

@@ -106,6 +106,11 @@ export interface LockEntry {
     address: string;
     bytecode_hash: string;
     deployed_at?: string;
+    package?: string;
+    source?: 'bundled' | 'path' | 'namespace' | 'address';
+    link?: LinkType;
+    resolved_namespace?: string;
+    resolved_script_account?: string;
 }
 /**
  * Resolved workspace state for IDE