@layerzerolabs/lz-iotal1-sdk-v2 3.0.143

package/src/module-manager.ts

@@ -0,0 +1,360 @@
+import { createHash } from 'crypto'
+
+import { IotaClient } from '@iota/iota-sdk/client'
+
+import {
+    BlockedMessageLib,
+    BlockedMessageLibPtbBuilder,
+    Call,
+    Counter,
+    DVN,
+    DVNFeeLib,
+    DvnLayerZero,
+    DvnPtbBuilder,
+    Endpoint,
+    EndpointPtbBuilder,
+    Executor,
+    ExecutorFeeLib,
+    ExecutorLayerZero,
+    ExecutorPtbBuilder,
+    LayerZeroViews,
+    OApp,
+    PackageWhitelistValidator,
+    PriceFeed,
+    PtbBuilder,
+    SimpleMessageLib,
+    SimpleMessageLibPtbBuilder,
+    Treasury,
+    Uln302,
+    Uln302PtbBuilder,
+    Utils,
+    WorkerRegistry,
+    Zro,
+} from './modules'
+import { ModuleOptions, ObjectOptions, PackageOptions } from './types'
+import { Modules } from './types/modules'
+
+/**
+ * Module Manager - Centralized management for all SDK modules
+ * Uses unified storage for both core modules and cached modules with options
+ */
+export class ModuleManager {
+    public packages: PackageOptions
+    public objects: ObjectOptions
+
+    private storage = new Map<string, unknown>()
+
+    constructor(packages: PackageOptions, objects: ObjectOptions) {
+        this.packages = packages
+        this.objects = objects
+    }
+
+    /**
+     * Generate a cache key using hash for modules with options
+     */
+    private generateCacheKey(moduleName: string, options?: ModuleOptions): string {
+        if (!options) {
+            return `${moduleName}:default`
+        }
+
+        // Create hash from JSON string
+        const jsonStr = JSON.stringify(options, Object.keys(options).sort())
+        const hash = createHash('sha256').update(jsonStr).digest('hex').substring(0, 16)
+
+        return `${moduleName}:${hash}`
+    }
+
+    private setCoreModules(modules: { [key: string]: unknown }): void {
+        Object.entries(modules).forEach(([name, instance]) => {
+            this.setModule(name, undefined, instance)
+        })
+    }
+
+    /**
+     * Get module instance (with options), throws error if not found
+     */
+    getModule<T>(moduleName: string, options?: ModuleOptions): T {
+        const key = this.generateCacheKey(moduleName, options)
+        const module = this.storage.get(key) as T | undefined
+        if (module === undefined) {
+            const optionsStr = options ? ` with options ${JSON.stringify(options)}` : ''
+            throw new Error(`Module '${moduleName}'${optionsStr} not found`)
+        }
+        return module
+    }
+
+    /**
+     * Store module instance (with options)
+     */
+    setModule<T>(moduleName: string, options: ModuleOptions | undefined, instance: T): void {
+        const key = this.generateCacheKey(moduleName, options)
+        this.storage.set(key, instance)
+    }
+
+    /**
+     * Check if module (with options) exists
+     */
+    hasModule(moduleName: string, options?: ModuleOptions): boolean {
+        const key = this.generateCacheKey(moduleName, options)
+        return this.storage.has(key)
+    }
+
+    /**
+     * Get module instance or create new one using factory function
+     */
+    getOrCreateModule<T>(moduleName: string, options: ModuleOptions | undefined, factory: () => T): T {
+        // Check if module exists first
+        if (this.hasModule(moduleName, options)) {
+            return this.getModule<T>(moduleName, options)
+        }
+
+        // Create new instance and store it
+        const instance = factory()
+        this.setModule(moduleName, options, instance)
+        return instance
+    }
+
+    /**
+     * Get all core modules as an object
+     */
+    getAllCoreModules(): { [key: string]: unknown } {
+        const result: { [key: string]: unknown } = {}
+        const coreModuleKeys = Array.from(this.storage.keys()).filter((key) => key.endsWith(':default'))
+
+        for (const key of coreModuleKeys) {
+            const moduleName = key.replace(':default', '')
+            result[moduleName] = this.storage.get(key)
+        }
+
+        return result
+    }
+
+    /**
+     * Clear all modules and cache
+     */
+    clear(): void {
+        this.storage.clear()
+    }
+
+    /**
+     * Remove a module with specific options
+     */
+    removeModule(moduleName: string, options?: ModuleOptions): boolean {
+        const key = this.generateCacheKey(moduleName, options)
+        return this.storage.delete(key)
+    }
+
+    /**
+     * Initialize all standard LayerZero modules
+     * @param packages - Package addresses configuration
+     * @param objects - Object addresses configuration
+     * @param client - Iota client instance
+     * @param context - Context object to be populated with module references
+     */
+    initializeCoreModules(packages: PackageOptions, objects: ObjectOptions, client: IotaClient): void {
+        this.setCoreModules({
+            [Modules.Endpoint]: new Endpoint(packages.endpointV2, client, objects, this),
+            [Modules.SimpleMessageLib]: new SimpleMessageLib(packages.simpleMessageLib, client, objects, this),
+            [Modules.BlockedMessageLib]: new BlockedMessageLib(packages.blockedMessageLib, client, objects, this),
+            [Modules.Uln302]: new Uln302(packages.uln302, client, objects, this),
+            [Modules.Utils]: new Utils(packages.utils, client),
+            [Modules.Zro]: new Zro(packages.zro, client, this),
+            [Modules.Call]: new Call(packages.call, client),
+            [Modules.Treasury]: new Treasury(packages.treasury, client, objects, this),
+            [Modules.LayerZeroViews]: new LayerZeroViews(packages.layerzeroViews, client, objects, this),
+            [Modules.PtbBuilder]: new PtbBuilder(packages.ptbMoveCall, client),
+        })
+    }
+
+    // === Core Module Getters ===
+
+    getEndpoint(): Endpoint {
+        return this.getModule(Modules.Endpoint)
+    }
+
+    getSimpleMessageLib(): SimpleMessageLib {
+        return this.getModule(Modules.SimpleMessageLib)
+    }
+
+    getBlockedMessageLib(): BlockedMessageLib {
+        return this.getModule(Modules.BlockedMessageLib)
+    }
+
+    getUln302(): Uln302 {
+        return this.getModule(Modules.Uln302)
+    }
+
+    getUtils(): Utils {
+        return this.getModule(Modules.Utils)
+    }
+
+    getZro(): Zro {
+        return this.getModule(Modules.Zro)
+    }
+
+    getCall(): Call {
+        return this.getModule(Modules.Call)
+    }
+
+    getTreasury(): Treasury {
+        return this.getModule(Modules.Treasury)
+    }
+
+    getLayerZeroViews(): LayerZeroViews {
+        return this.getModule(Modules.LayerZeroViews)
+    }
+
+    getPtbBuilder(): PtbBuilder {
+        return this.getModule(Modules.PtbBuilder)
+    }
+
+    getOApp(client: IotaClient, callCapId: string, options?: ModuleOptions): OApp {
+        return this.getOrCreateModule(Modules.Oapp + callCapId, options, () => {
+            const packageId = options?.packageId ?? this.packages.oapp
+            const objects = this.mergeObjectsOptions(options)
+            return new OApp(packageId, callCapId, client, objects, this)
+        })
+    }
+
+    // === Non-core Module Getters (created on-demand with caching) ===
+
+    getCounter(client: IotaClient, options?: ModuleOptions): Counter {
+        return this.getOrCreateModule(Modules.Counter, options, () => {
+            const packageId = options?.packageId ?? this.packages.counterV2
+            const objects = this.mergeObjectsOptions(options)
+            return new Counter(packageId, client, objects, this)
+        })
+    }
+
+    getExecutor(client: IotaClient, options?: ModuleOptions): Executor {
+        return this.getOrCreateModule(Modules.Executor, options, () => {
+            const packageId = options?.packageId ?? this.packages.executor
+            const objects = this.mergeObjectsOptions(options)
+            return new Executor(packageId, client, objects, this)
+        })
+    }
+
+    getDvn(client: IotaClient, options?: ModuleOptions): DVN {
+        return this.getOrCreateModule(Modules.Dvn, options, () => {
+            const packageId = options?.packageId ?? this.packages.dvn
+            const objects = this.mergeObjectsOptions(options)
+            return new DVN(packageId, client, objects, this)
+        })
+    }
+
+    getDvnFeeLib(client: IotaClient, options?: ModuleOptions): DVNFeeLib {
+        return this.getOrCreateModule(Modules.DvnFeeLib, options, () => {
+            const packageId = options?.packageId ?? this.packages.dvnFeeLib
+            const objects = this.mergeObjectsOptions(options)
+            return new DVNFeeLib(packageId, client, objects, this)
+        })
+    }
+
+    getExecutorFeeLib(client: IotaClient, options?: ModuleOptions): ExecutorFeeLib {
+        return this.getOrCreateModule(Modules.ExecutorFeeLib, options, () => {
+            const packageId = options?.packageId ?? this.packages.executorFeeLib
+            const objects = this.mergeObjectsOptions(options)
+            return new ExecutorFeeLib(packageId, client, objects, this)
+        })
+    }
+
+    getPriceFeed(client: IotaClient, options?: ModuleOptions): PriceFeed {
+        return this.getOrCreateModule(Modules.PriceFeed, options, () => {
+            const packageId = options?.packageId ?? this.packages.priceFeed
+            const objects = this.mergeObjectsOptions(options)
+            return new PriceFeed(packageId, client, objects, this)
+        })
+    }
+
+    getDvnLayerZero(client: IotaClient, options?: ModuleOptions): DvnLayerZero {
+        return this.getOrCreateModule(Modules.DvnLayerZero, options, () => {
+            const packageId = options?.packageId ?? this.packages.dvnLayerzero
+            return new DvnLayerZero(packageId, client, this)
+        })
+    }
+
+    getExecutorLayerZero(client: IotaClient, options?: ModuleOptions): ExecutorLayerZero {
+        return this.getOrCreateModule(Modules.ExecutorLayerZero, options, () => {
+            const packageId = options?.packageId ?? this.packages.executorLayerzero
+            return new ExecutorLayerZero(packageId, client, this)
+        })
+    }
+
+    getDvnPtbBuilder(client: IotaClient, options?: ModuleOptions): DvnPtbBuilder {
+        return this.getOrCreateModule(Modules.DvnPtbBuilder, options, () => {
+            const packageId = options?.packageId ?? this.packages.dvnPtbBuilder
+            const objects = this.mergeObjectsOptions(options)
+            return new DvnPtbBuilder(packageId, client, objects, this)
+        })
+    }
+
+    getExecutorPtbBuilder(client: IotaClient, options?: ModuleOptions): ExecutorPtbBuilder {
+        return this.getOrCreateModule(Modules.ExecutorPtbBuilder, options, () => {
+            const packageId = options?.packageId ?? this.packages.executorPtbBuilder
+            const objects = this.mergeObjectsOptions(options)
+            return new ExecutorPtbBuilder(packageId, client, objects, this)
+        })
+    }
+
+    getPackageWhitelistValidator(client: IotaClient, options?: ModuleOptions): PackageWhitelistValidator {
+        return this.getOrCreateModule(Modules.PackageWhitelistValidator, options, () => {
+            const packageId = options?.packageId ?? this.packages.packageWhitelistValidator
+            const objects = this.mergeObjectsOptions(options)
+            return new PackageWhitelistValidator(packageId, client, objects, this)
+        })
+    }
+
+    getUln302PtbBuilder(client: IotaClient, options?: ModuleOptions): Uln302PtbBuilder {
+        return this.getOrCreateModule(Modules.Uln302PtbBuilder, options, () => {
+            const packageId = options?.packageId ?? this.packages.uln302PtbBuilder
+            const objects = this.mergeObjectsOptions(options)
+            return new Uln302PtbBuilder(packageId, client, objects, this)
+        })
+    }
+
+    getEndpointPtbBuilder(client: IotaClient, options?: ModuleOptions): EndpointPtbBuilder {
+        return this.getOrCreateModule(Modules.EndpointPtbBuilder, options, () => {
+            const packageId = options?.packageId ?? this.packages.endpointPtbBuilder
+            const objects = this.mergeObjectsOptions(options)
+            return new EndpointPtbBuilder(packageId, client, objects, this)
+        })
+    }
+
+    getSimpleMessageLibPtbBuilder(client: IotaClient, options?: ModuleOptions): SimpleMessageLibPtbBuilder {
+        return this.getOrCreateModule(Modules.SimpleMessageLibPtbBuilder, options, () => {
+            const packageId = options?.packageId ?? this.packages.simpleMessageLibPtbBuilder
+            const objects = this.mergeObjectsOptions(options)
+            return new SimpleMessageLibPtbBuilder(packageId, client, objects, this)
+        })
+    }
+    getBlockedMessageLibPtbBuilder(client: IotaClient, options?: ModuleOptions): BlockedMessageLibPtbBuilder {
+        return this.getOrCreateModule(Modules.BlockedMessageLibPtbBuilder, options, () => {
+            const packageId = options?.packageId ?? this.packages.blockedMessageLibPtbBuilder
+            const objects = this.mergeObjectsOptions(options)
+            return new BlockedMessageLibPtbBuilder(packageId, client, objects, this)
+        })
+    }
+
+    getWorkerRegistry(client: IotaClient, options?: ModuleOptions): WorkerRegistry {
+        return this.getOrCreateModule(Modules.WorkerRegistry, options, () => {
+            const packageId = options?.packageId ?? this.packages.workerRegistry
+            const objects = this.mergeObjectsOptions(options)
+            return new WorkerRegistry(packageId, client, objects, this)
+        })
+    }
+
+    // === Private Utility Methods ===
+
+    /**
+     * Merge objects configuration with options, avoiding unnecessary object spreading
+     */
+    private mergeObjectsOptions(options?: ModuleOptions): ObjectOptions {
+        // If no options or options.objects is empty, return original objects
+        if (!options?.objects || Object.keys(options.objects).length === 0) {
+            return this.objects
+        }
+
+        // Only perform object spreading when there are actual properties to merge
+        return { ...this.objects, ...options.objects }
+    }
+}

package/src/modules/call.ts

@@ -0,0 +1,245 @@
+import { bcs } from '@iota/iota-sdk/bcs'
+import { IotaClient } from '@iota/iota-sdk/client'
+import { Transaction, TransactionArgument, TransactionResult } from '@iota/iota-sdk/transactions'
+
+import { asObject, executeSimulate } from '../utils'
+
+const DEFAULT_MODULE_NAME = 'call'
+
+export const CallErrorCode = {
+    // Call related errors (matching call.move)
+    Call_ECallNotActive: 1,
+    Call_ECallNotCompleted: 2,
+    Call_ECallNotCreating: 3,
+    Call_ECallNotRoot: 4,
+    Call_ECallNotWaiting: 5,
+    Call_EInvalidChild: 6,
+    Call_EInvalidNonce: 7,
+    Call_EInvalidParent: 8,
+    Call_EParameterNotMutable: 9,
+    Call_EUnauthorized: 10,
+
+    // CallCap related errors (matching call_cap.move)
+    CallCap_EBadWitness: 1,
+
+    // MultiCall related errors (matching dynamic-call/multi-call/multi_call.move)
+    MultiCall_ENoMoreCalls: 1,
+    MultiCall_EUnauthorized: 2,
+} as const
+
+export class Call {
+    public packageId: string
+    public readonly client: IotaClient
+
+    constructor(packageId: string, client: IotaClient) {
+        this.packageId = packageId
+        this.client = client
+    }
+
+    // === Set function ===
+
+    /**
+     * Create a new CallCap for a user (direct interaction)
+     * Creates a user-based CallCap that uses its own UID as the identifier
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the new individual CallCap
+     */
+    newIndividualCapMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('new_individual_cap', 'call_cap'),
+            arguments: [],
+        })
+    }
+
+    /**
+     * Create a void result for calls with no meaningful return value
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing a void result
+     */
+    voidMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('void'),
+            arguments: [],
+        })
+    }
+
+    // === View function ===
+
+    /**
+     * Get the result from a call
+     * @param tx - The transaction to add the move call to
+     * @param paramType - The parameter type for the call
+     * @param resultType - The result type for the call
+     * @param call - The call transaction result or transaction argument
+     * @returns Transaction result containing the call result
+     */
+    resultMoveCall(
+        tx: Transaction,
+        paramType: string,
+        resultType: string,
+        call: TransactionArgument
+    ): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('result'),
+            typeArguments: [paramType, resultType],
+            arguments: [call],
+        })
+    }
+
+    /**
+     * Get the recipient from a call
+     * @param tx - The transaction to add the move call to
+     * @param paramType - The parameter type for the call
+     * @param resultType - The result type for the call
+     * @param call - The call transaction result or transaction argument
+     * @returns Transaction result containing the call recipient
+     */
+    recipientMoveCall(
+        tx: Transaction,
+        paramType: string,
+        resultType: string,
+        call: TransactionArgument
+    ): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('recipient'),
+            typeArguments: [paramType, resultType],
+            arguments: [call],
+        })
+    }
+
+    /**
+     * Get the unique identifier for a CallCap
+     * Returns the appropriate identifier based on the source type
+     * @param tx - The transaction to add the move call to
+     * @param callCap - The CallCap object ID or transaction argument
+     * @returns Transaction result containing the CallCap identifier
+     */
+    callCapIdMoveCall(tx: Transaction, callCap: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('id', 'call_cap'),
+            arguments: [asObject(tx, callCap)],
+        })
+    }
+
+    /**
+     * Get the unique identifier for a CallCap
+     * Returns the appropriate identifier based on the source type
+     * @param callCap - The CallCap object ID
+     * @returns Promise resolving to the CallCap identifier as a string
+     */
+    async getCallCapId(callCap: string): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.callCapIdMoveCall(tx, callCap)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Check if this is an Individual CallCap
+     * @param tx - The transaction to add the move call to
+     * @param callCap - The CallCap object ID or transaction argument
+     * @returns Transaction result containing a boolean indicating if it's an Individual CallCap
+     */
+    isIndividualCapMoveCall(tx: Transaction, callCap: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_individual', 'call_cap'),
+            arguments: [asObject(tx, callCap)],
+        })
+    }
+
+    /**
+     * Check if this is an Individual CallCap
+     * @param callCap - The CallCap object ID
+     * @returns Promise resolving to true if it's an Individual CallCap
+     */
+    async isIndividualCap(callCap: string): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isIndividualCapMoveCall(tx, callCap)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Check if this is a Package CallCap
+     * @param tx - The transaction to add the move call to
+     * @param callCap - The CallCap object ID or transaction argument
+     * @returns Transaction result containing a boolean indicating if it's a Package CallCap
+     */
+    isPackageCapMoveCall(tx: Transaction, callCap: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_package', 'call_cap'),
+            arguments: [asObject(tx, callCap)],
+        })
+    }
+
+    /**
+     * Check if this is a Package CallCap
+     * @param callCap - The CallCap object ID
+     * @returns Promise resolving to true if it's a Package CallCap
+     */
+    async isPackageCap(callCap: string): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isPackageCapMoveCall(tx, callCap)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get the package address for a Package CallCap
+     * Returns None if this is a User CallCap
+     * @param tx - The transaction to add the move call to
+     * @param callCap - The CallCap object ID or transaction argument
+     * @returns Transaction result containing the package address option
+     */
+    packageAddressMoveCall(tx: Transaction, callCap: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('package_address', 'call_cap'),
+            arguments: [asObject(tx, callCap)],
+        })
+    }
+
+    /**
+     * Get the package address for a Package CallCap
+     * Returns null if this is an Individual CallCap
+     * @param callCap - The CallCap object ID
+     * @returns Promise resolving to the package address or null if Individual CallCap
+     */
+    async getPackageAddress(callCap: string): Promise<string | null> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.packageAddressMoveCall(tx, callCap)
+            },
+            (result) => {
+                try {
+                    // Try to parse as Option<address>
+                    const option = bcs.option(bcs.Address).parse(result[0].value)
+                    return option ?? null
+                } catch {
+                    // If parsing fails, it might be None
+                    return null
+                }
+            }
+        )
+    }
+
+    /**
+     * Generate the full target path for move calls
+     * @param name - The function name to call
+     * @param module_name - The module name (defaults to DEFAULT_MODULE_NAME)
+     * @returns The full module path for the move call
+     * @private
+     */
+    #target(name: string, module_name = DEFAULT_MODULE_NAME): string {
+        return `${this.packageId}::${module_name}::${name}`
+    }
+}