@layerzerolabs/lz-sui-sdk-v2 3.0.134 → 3.0.135

package/src/modules/workers/worker-registry.ts

@@ -0,0 +1,110 @@
+import { SuiClient } from '@mysten/sui/client'
+import { Transaction, TransactionArgument, TransactionResult } from '@mysten/sui/transactions'
+
+import { ModuleManager } from '../../module-manager'
+import { ObjectOptions } from '../../types'
+import { asAddress, executeSimulate } from '../../utils'
+
+const MODULE_NAME = 'worker_registry'
+
+export const WorkerRegistryErrorCode = {
+    // WorkerRegistry related errors (matching worker_registry.move)
+    EWorkerInfoInvalid: 1,
+    EWorkerInfoNotFound: 2,
+} as const
+
+/**
+ * WorkerRegistry provides access to the worker registry contract functionality
+ * This module maintains mappings between worker addresses and their associated information.
+ */
+export class WorkerRegistry {
+    public packageId: string
+    public readonly client: SuiClient
+    private readonly objects: ObjectOptions
+
+    /**
+     * Create a new WorkerRegistry instance
+     * @param packageId - The package ID of the worker registry contract
+     * @param client - The Sui client instance
+     * @param objects - Object options containing contract object IDs
+     * @param moduleManager - Module manager for handling dependencies
+     */
+    constructor(
+        packageId: string,
+        client: SuiClient,
+        objects: ObjectOptions,
+        private readonly moduleManager: ModuleManager
+    ) {
+        this.packageId = packageId
+        this.client = client
+        this.objects = objects
+    }
+
+    // === View Functions ===
+
+    /**
+     * Get worker info for a specific worker address (as a move call)
+     * This creates a move call that can be used in a PTB (Programmable Transaction Block)
+     * @param tx - The transaction to add the move call to
+     * @param worker - The worker address or transaction argument
+     * @returns TransactionResult - The move call result containing worker info bytes
+     * @throws Will throw an error if worker info is not found (EWorkerInfoNotFound)
+     */
+    getWorkerInfoMoveCall(tx: Transaction, worker: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('get_worker_info'),
+            arguments: [tx.object(this.objects.workerRegistry), asAddress(tx, worker)],
+        })
+    }
+
+    /**
+     * Get worker info for a specific worker address
+     * Executes the get_worker_info function and returns the worker information bytes
+     * @param worker - The worker address to get info for
+     * @returns Promise<Uint8Array> - The worker information bytes containing encoded worker data
+     * @throws Will throw an error if worker info is not found (EWorkerInfoNotFound)
+     */
+    async getWorkerInfo(worker: string): Promise<Uint8Array> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getWorkerInfoMoveCall(tx, worker)
+            },
+            (result) => {
+                return result[0].value
+            }
+        )
+    }
+
+    /**
+     * Check if worker info exists for a specific worker address
+     * This is a convenience method that catches EWorkerInfoNotFound errors
+     * @param worker - The worker address to check
+     * @returns Promise<boolean> - True if worker info exists, false if not found
+     * @throws Will re-throw any errors other than EWorkerInfoNotFound
+     */
+    async hasWorkerInfo(worker: string): Promise<boolean> {
+        try {
+            await this.getWorkerInfo(worker)
+            return true
+        } catch (error) {
+            // If the error is EWorkerInfoNotFound, return false
+            if (error instanceof Error && error.message.includes('EWorkerInfoNotFound')) {
+                return false
+            }
+            // Re-throw other errors
+            throw error
+        }
+    }
+
+    // === Private Functions ===
+
+    /**
+     * Generate the target string for move calls
+     * @param functionName - The function name to call
+     * @returns The fully qualified target string for the move call
+     */
+    #target(functionName: string): string {
+        return `${this.packageId}::${MODULE_NAME}::${functionName}`
+    }
+}

package/src/resource.ts

@@ -33,6 +33,8 @@ const PACKAGE_ADDRESS_MAP: { [K in keyof PackageOptions]: Partial<{ [S in Stage]
     oapp: AddressConstants.PACKAGE_OAPP_ADDRESS,
     layerzeroViews: AddressConstants.PACKAGE_LAYERZERO_VIEWS_ADDRESS,
     packageWhitelistValidator: AddressConstants.PACKAGE_PACKAGE_WHITELIST_VALIDATOR_ADDRESS,
+    workerRegistry: AddressConstants.PACKAGE_WORKER_REGISTRY_ADDRESS,
+    workerCommon: AddressConstants.PACKAGE_WORKER_COMMON_ADDRESS,
 }
 
 /**
@@ -67,6 +69,7 @@ const OBJECT_ADDRESS_MAP: { [K in keyof ObjectOptions]: Partial<{ [S in Stage]:
     priceFeed: AddressConstants.OBJECT_PRICE_FEED_ADDRESS,
     priceFeedOwnerCap: AddressConstants.OBJECT_PRICE_FEED_OWNER_CAP_ADDRESS,
     packageWhitelistValidator: AddressConstants.OBJECT_PACKAGE_WHITELIST_VALIDATOR_ADDRESS,
+    workerRegistry: AddressConstants.OBJECT_WORKER_REGISTRY_ADDRESS,
 }
 
 /**

package/src/sdk.ts

@@ -29,6 +29,7 @@ import {
     Uln302,
     Uln302PtbBuilder,
     Utils,
+    WorkerRegistry,
     Zro,
 } from './modules'
 import { ResourceManager } from './resource'
@@ -106,8 +107,8 @@ export class SDK {
         return this.moduleManager.getLayerZeroViews()
     }
 
-    getOApp(): OApp {
-        return this.moduleManager.getOApp()
+    getOApp(callCapId: string, options?: ModuleOptions): OApp {
+        return this.moduleManager.getOApp(this.client, callCapId, options)
     }
 
     // === Non-Core Module Getters (created on-demand with caching) ===
@@ -172,6 +173,10 @@ export class SDK {
         return this.moduleManager.getBlockedMessageLibPtbBuilder(this.client, options)
     }
 
+    getWorkerRegistry(options?: ModuleOptions): WorkerRegistry {
+        return this.moduleManager.getWorkerRegistry(this.client, options)
+    }
+
     getOrCreateModule<T>(moduleName: string, options: ModuleOptions | undefined, factory: () => T): T {
         return this.moduleManager.getOrCreateModule(moduleName, options, factory)
     }

package/src/types/endpoint.ts

@@ -11,5 +11,6 @@ export interface Timeout {
  * LayerZero protocol version constants
  */
 
-export const LzReceiveVersion = { VERSION_1: 1 } as const
+export const OAppInfoVersion = { VERSION_1: 1, VERSION_2: 2 } as const
+export const LzReceiveVersion = { VERSION_1: 1 } as const 
 export const LzComposeVersion = { VERSION_1: 1 } as const

package/src/types/modules.ts

@@ -32,4 +32,5 @@ export enum Modules {
     Counter = 'counter',
     DvnPtbBuilder = 'dvnPtbBuilder',
     ExecutorPtbBuilder = 'executorPtbBuilder',
+    WorkerRegistry = 'workerRegistry',
 }

package/src/types/oapp.ts

@@ -0,0 +1,6 @@
+export interface OAppInfoV1 {
+    oapp_object: string
+    next_nonce_info: number[]
+    lz_receive_info: number[]
+    extra_info: number[]
+}

package/src/types/options.ts

@@ -136,6 +136,16 @@ export interface PackageOptions {
      */
     blockedMessageLibPtbBuilder: string
 
+    /**
+     * The worker registry address.
+     */
+    workerRegistry: string
+
+    /**
+     * The worker common address.
+     */
+    workerCommon: string
+
     /**
      * Allow additional properties beyond the explicitly defined ones
      */
@@ -285,6 +295,11 @@ export interface ObjectOptions {
      */
     packageWhitelistValidator: string
 
+    /**
+     * The worker registry object address.
+     */
+    workerRegistry: string
+
     /**
      * Allow additional properties beyond the explicitly defined ones
      */

package/src/utils/transaction.ts

@@ -101,17 +101,17 @@ export async function validateTransaction(
 /**
  * Execute simulate using a moveCall function
  * @param client - The Sui client
- * @param moveCallFn - Function that adds moveCall to the transaction
+ * @param moveCallFn - Function that adds moveCall to the transaction (supports both sync and async, any return type)
  * @param parser - Function to parse the result
  * @returns The parsed result
  */
 export async function executeSimulate<T>(
     client: SuiClient,
-    moveCallFn: (tx: Transaction) => void,
+    moveCallFn: (tx: Transaction) => unknown,
     parser: (result: { value: Uint8Array }[]) => T
 ): Promise<T> {
     const tx = new Transaction()
-    moveCallFn(tx)
+    await moveCallFn(tx)
     const result = await simulateTransaction(client, tx)
     return parser(result)
 }