@layerzerolabs/lz-sui-sdk-v2 3.0.132 → 3.0.134-sui.0

package/src/modules/ptb-builders/ptb-builder.ts

@@ -2,14 +2,14 @@ import { bcs } from '@mysten/sui/bcs'
 import { SuiClient } from '@mysten/sui/client'
 import { Transaction, TransactionResult } from '@mysten/sui/transactions'
 
-import { VectorMoveCallBCS } from '../../bcs'
+import { OAppInfoV1Bcs, VectorMoveCallBCS } from '../../bcs'
 import {
     Argument,
     BuilderPlaceholderInfo,
     DEFAULT_SIMULATION_TIMES,
     LzComposeVersion,
-    LzReceiveVersion,
     MoveCall,
+    OAppInfoVersion,
     SimulateResult,
 } from '../../types'
 import { simulateTransaction } from '../../utils/transaction'
@@ -48,9 +48,10 @@ export class PtbBuilder {
     async simulateLzReceivePtb(tx: Transaction, sender?: string): Promise<MoveCall[]> {
         const ptbCallsResult = await simulateTransaction(this.client, tx, sender)
         const buffer = Buffer.from(bcs.vector(bcs.u8()).parse(ptbCallsResult[0].value))
+
         const version = buffer.readInt16BE()
-        if (version === LzReceiveVersion.VERSION_1) {
-            return this.#decodeMoveCallsBytes(new Uint8Array(buffer.subarray(2)))
+        if (version === OAppInfoVersion.VERSION_1) {
+            return this.#decodeMoveCallsFromOAppInfoV1(new Uint8Array(buffer.subarray(2)))
         }
         throw new Error(`Unknown version: ${version}`)
     }
@@ -285,6 +286,11 @@ export class PtbBuilder {
         return this.#decodeMoveCallsBytes(value)
     }
 
+    #decodeMoveCallsFromOAppInfoV1(bytes: Uint8Array): MoveCall[] {
+        const oappInfo = OAppInfoV1Bcs.parse(bytes)
+        return this.#decodeMoveCallsBytes(new Uint8Array(oappInfo.lz_receive_info).subarray(2)) // remove the version prefix
+    }
+
     /**
      * Decode move calls from raw bytes
      * @param bytes - The raw bytes containing encoded move calls

package/src/modules/workers/dvn-layerzero.ts

@@ -59,6 +59,7 @@ export class DvnLayerZero {
                 asAddressVector(tx, admins),
                 asBytesVector(tx, signers),
                 asU64(tx, quorum),
+                tx.object(this.moduleManager.objects.workerRegistry),
             ],
         })
     }

package/src/modules/workers/dvn.ts

@@ -1135,6 +1135,65 @@ export class DVN {
         )
     }
 
+    /**
+     * Get DVN object address from worker registry using this DVN's worker capability (as a move call)
+     * This function chains Move calls to decode worker info and extract the DVN object address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the DVN object address
+     */
+    getDvnObjectAddressMoveCall(tx: Transaction): TransactionResult {
+        // Step 1: Get this DVN's worker capability address
+        const workerCapAddress = this.workerCapAddressMoveCall(tx)
+
+        // Step 2: Get worker info bytes from registry
+        const workerInfoBytes = this.moduleManager
+            .getWorkerRegistry(this.client)
+            .getWorkerInfoMoveCall(tx, workerCapAddress)
+
+        // Step 3: Decode worker info using worker_common::worker_info_v1::decode
+        const workerInfo = tx.moveCall({
+            target: `${this.moduleManager.packages.workerCommon}::worker_info_v1::decode`,
+            arguments: [workerInfoBytes],
+        })
+
+        // Step 4: Extract worker_info field from decoded WorkerInfoV1
+        const dvnInfoBytes = tx.moveCall({
+            target: `${this.moduleManager.packages.workerCommon}::worker_info_v1::worker_info`,
+            arguments: [workerInfo],
+        })
+
+        // Step 5: Decode DVN info using dvn::dvn_info_v1::decode
+        const dvnInfo = tx.moveCall({
+            target: `${this.packageId}::dvn_info_v1::decode`,
+            arguments: [dvnInfoBytes],
+        })
+
+        // Step 6: Extract dvn_object address from decoded DVNInfoV1
+        return tx.moveCall({
+            target: `${this.packageId}::dvn_info_v1::dvn_object`,
+            arguments: [dvnInfo],
+        })
+    }
+
+    /**
+     * Get DVN object address from worker registry using this DVN's worker capability
+     * This function uses Move calls to decode worker info and extract the DVN object address
+     * @returns Promise<string> - The DVN object address
+     * @throws Will throw an error if worker info is not found or if decoding fails
+     */
+    async getDvnObjectAddress(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getDvnObjectAddressMoveCall(tx)
+            },
+            (result) => {
+                // The result is the DVN object address directly from the Move call chain
+                return bcs.Address.parse(result[0].value)
+            }
+        )
+    }
+
     // === Witness Functions ===
 
     /**

package/src/modules/workers/executor-layerzero.ts

@@ -53,6 +53,7 @@ export class ExecutorLayerZero {
                 asU16(tx, defaultMultiplierBps),
                 asAddress(tx, owner),
                 asAddressVector(tx, admins),
+                tx.object(this.moduleManager.objects.workerRegistry),
             ],
         })
     }

package/src/modules/workers/executor.ts

@@ -1029,6 +1029,65 @@ export class Executor {
         )
     }
 
+    /**
+     * Get Executor object address from worker registry using this Executor's worker capability (as a move call)
+     * This function chains Move calls to decode worker info and extract the Executor object address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the Executor object address
+     */
+    getExecutorObjectAddressMoveCall(tx: Transaction): TransactionResult {
+        // Step 1: Get this Executor's worker capability address
+        const workerCapAddress = this.workerCapAddressMoveCall(tx)
+
+        // Step 2: Get worker info bytes from registry
+        const workerInfoBytes = this.moduleManager
+            .getWorkerRegistry(this.client)
+            .getWorkerInfoMoveCall(tx, workerCapAddress)
+
+        // Step 3: Decode worker info using worker_common::worker_info_v1::decode
+        const workerInfo = tx.moveCall({
+            target: `${this.moduleManager.packages.workerCommon}::worker_info_v1::decode`,
+            arguments: [workerInfoBytes],
+        })
+
+        // Step 4: Extract worker_info field from decoded WorkerInfoV1
+        const executorInfoBytes = tx.moveCall({
+            target: `${this.moduleManager.packages.workerCommon}::worker_info_v1::worker_info`,
+            arguments: [workerInfo],
+        })
+
+        // Step 5: Decode Executor info using executor::executor_info_v1::decode
+        const executorInfo = tx.moveCall({
+            target: `${this.packageId}::executor_info_v1::decode`,
+            arguments: [executorInfoBytes],
+        })
+
+        // Step 6: Extract executor_object address from decoded ExecutorInfoV1
+        return tx.moveCall({
+            target: `${this.packageId}::executor_info_v1::executor_object`,
+            arguments: [executorInfo],
+        })
+    }
+
+    /**
+     * Get Executor object address from worker registry using this Executor's worker capability
+     * This function uses Move calls to decode worker info and extract the Executor object address
+     * @returns Promise<string> - The Executor object address
+     * @throws Will throw an error if worker info is not found or if decoding fails
+     */
+    async getExecutorObjectAddress(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getExecutorObjectAddressMoveCall(tx)
+            },
+            (result) => {
+                // The result is the Executor object address directly from the Move call chain
+                return bcs.Address.parse(result[0].value)
+            }
+        )
+    }
+
     // === Private Helper Functions ===
 
     private parseDstConfig(data: Uint8Array): DstConfig {

package/src/modules/workers/index.ts

@@ -7,3 +7,4 @@ export * from './executor-fee-lib'
 export * from './executor-layerzero'
 export * from './price-feed'
 export * from './treasury'
+export * from './worker-registry'

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

@@ -0,0 +1,109 @@
+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 = {
+    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)
 }