@layerzerolabs/lz-sui-sdk-v2 3.0.134-sui.1 → 3.0.134-sui.2

package/src/modules/workers/dvn.ts

@@ -268,6 +268,37 @@ export class DVN {
 
     // === Set Functions with Signatures ===
 
+    /**
+     * Set supported message library (admin with signatures)
+     * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
+     * @param messageLib - The message library address
+     * @param supported - Whether to support or remove support for the message library
+     * @param expiration - Signature expiration timestamp
+     * @param signatures - Multisig signatures for authorization
+     */
+    setSupportedMessageLibMoveCall(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        messageLib: string | TransactionArgument,
+        supported: boolean | TransactionArgument,
+        expiration: bigint | number | string | TransactionArgument,
+        signatures: Uint8Array | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('set_supported_message_lib'),
+            arguments: [
+                tx.object(this.objects.dvn),
+                asObject(tx, adminCap),
+                asAddress(tx, messageLib),
+                asBool(tx, supported),
+                asU64(tx, expiration),
+                asBytes(tx, signatures),
+                tx.object.clock(),
+            ],
+        })
+    }
+
     /**
      * Set allowlist status for an OApp sender (admin with signatures)
      * @param tx - The transaction to add the move call to
@@ -448,32 +479,33 @@ export class DVN {
     // Verification Functions
 
     /**
-     * Verify a packet with DVN signatures (admin with signatures)
+     * Verify a packet with DVN signatures (admin with signatures) - returns Call object for ULN302
      * @param tx - The transaction to add the move call to
      * @param adminCap - The admin capability object ID
-     * @param verification - The verification object address
+     * @param targetMessageLib - The target message library address (usually ULN302)
      * @param packetHeader - The packet header as bytes
      * @param payloadHash - The payload hash as bytes
      * @param confirmations - Required confirmations count
      * @param expiration - Signature expiration timestamp
      * @param signatures - DVN multisig signatures
+     * @returns Transaction result containing the verification Call object
      */
     verifyMoveCall(
         tx: Transaction,
         adminCap: string | TransactionArgument,
-        verification: string | TransactionArgument,
+        targetMessageLib: string | TransactionArgument,
         packetHeader: Uint8Array | TransactionArgument,
         payloadHash: Uint8Array | TransactionArgument,
         confirmations: bigint | number | string | TransactionArgument,
         expiration: bigint | number | string | TransactionArgument,
         signatures: Uint8Array | TransactionArgument
-    ): void {
-        tx.moveCall({
+    ): TransactionResult {
+        return tx.moveCall({
             target: this.#target('verify'),
             arguments: [
                 tx.object(this.objects.dvn),
                 asObject(tx, adminCap),
-                asObject(tx, verification),
+                asAddress(tx, targetMessageLib),
                 asBytes(tx, packetHeader),
                 asBytes32(tx, payloadHash, this.moduleManager.getUtils()),
                 asU64(tx, confirmations),
@@ -770,6 +802,34 @@ export class DVN {
         )
     }
 
+    /**
+     * Check if a message library is supported by this DVN
+     * @param tx - The transaction to add the move call to
+     * @param messageLib - The message library address to check
+     * @returns Transaction result containing the support status
+     */
+    isSupportedMessageLibMoveCall(tx: Transaction, messageLib: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_supported_message_lib'),
+            arguments: [tx.object(this.objects.dvn), asAddress(tx, messageLib)],
+        })
+    }
+
+    /**
+     * Check if a message library is supported by this DVN
+     * @param messageLib - The message library address to check
+     * @returns Promise<boolean> - True if the message library is supported
+     */
+    async isSupportedMessageLib(messageLib: string): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isSupportedMessageLibMoveCall(tx, messageLib)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
     /**
      * Check if an address is allowlisted
      * @param tx - The transaction to add the move call to
@@ -1580,6 +1640,80 @@ export class DVN {
         })
     }
 
+    /**
+     * Populate verify with DVN verification and ULN verify call
+     * @param tx - The transaction to add the move call to
+     * @param adminCap - The admin capability object ID
+     * @param targetMessageLib - The target message library address (usually ULN302)
+     * @param targetVerification - The verification object address for the target message library
+     * @param packetHeader - The packet header as bytes
+     * @param payloadHash - The payload hash as bytes
+     * @param confirmations - Required confirmations count
+     * @param expiration - Signature expiration timestamp
+     * @param signatures - DVN multisig signatures
+     */
+    populateVerify(
+        tx: Transaction,
+        adminCap: string | TransactionArgument,
+        targetMessageLib: string,
+        targetVerification: string,
+        packetHeader: Uint8Array | TransactionArgument,
+        payloadHash: Uint8Array | TransactionArgument,
+        confirmations: bigint | number | string | TransactionArgument,
+        expiration: bigint | number | string | TransactionArgument,
+        signatures: Uint8Array | TransactionArgument
+    ): void {
+        // Step 1: Call DVN's verifyMoveCall to get the verification call
+        const dvnCall = this.verifyMoveCall(
+            tx,
+            adminCap,
+            targetMessageLib,
+            packetHeader,
+            payloadHash,
+            confirmations,
+            expiration,
+            signatures
+        )
+
+        // Step 2: Get the message library object address based on targetMessageLib
+        const messageLibObjectAddress = this.#getUlnObjectAddress(targetMessageLib)
+
+        tx.moveCall({
+            target: this.#getUlnVerifyTarget(targetMessageLib),
+            arguments: [tx.object(messageLibObjectAddress), asObject(tx, targetVerification), dvnCall],
+        })
+    }
+
+    /**
+     * Get message library object address based on targetMessageLib package address
+     * @param targetMessageLib - The target message library package address
+     * @returns Message library object address
+     * @throws Error if targetMessageLib doesn't match any known message library
+     * @private
+     */
+    #getUlnObjectAddress(targetMessageLib: string): string {
+        // Check if targetMessageLib equals ULN302 package address
+        if (targetMessageLib === this.moduleManager.packages.uln302) {
+            return this.objects.uln302
+        }
+
+        throw new Error('Target message library not match objects')
+    }
+
+    /**
+     * Get ULN verify target path based on targetMessageLib package address
+     * @param targetMessageLib - The target message library package address
+     * @returns Message library verify target path
+     * @throws Error if targetMessageLib doesn't match any known message library
+     * @private
+     */
+    #getUlnVerifyTarget(targetMessageLib: string): string {
+        if (targetMessageLib === this.moduleManager.packages.uln302) {
+            return `${targetMessageLib}::uln_302::verify`
+        }
+
+        throw new Error('Target message library not match any target')
+    }
     /**
      * Generate the full target path for move calls
      * @param name - The function name to call

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

@@ -32,6 +32,7 @@ export class ExecutorLayerZero {
      * @param tx - The transaction to add the move call to
      * @param workerCap - Worker capability object ID or transaction argument
      * @param depositAddress - Address for fee deposits or transaction argument
+     * @param supportedMessageLibs - Array of supported message library addresses or transaction argument
      * @param priceFeed - Price feed object address or transaction argument
      * @param workerFeeLib - Worker fee library address or transaction argument
      * @param defaultMultiplierBps - Default multiplier in basis points or transaction argument
@@ -42,6 +43,7 @@ export class ExecutorLayerZero {
         tx: Transaction,
         workerCap: string | TransactionArgument,
         depositAddress: string | TransactionArgument,
+        supportedMessageLibs: string[] | TransactionArgument,
         priceFeed: string | TransactionArgument,
         workerFeeLib: string | TransactionArgument,
         defaultMultiplierBps: number | TransactionArgument,
@@ -53,6 +55,7 @@ export class ExecutorLayerZero {
             arguments: [
                 asObject(tx, workerCap),
                 asAddress(tx, depositAddress),
+                asAddressVector(tx, supportedMessageLibs),
                 asAddress(tx, priceFeed),
                 asAddress(tx, workerFeeLib),
                 asU16(tx, defaultMultiplierBps),

package/src/modules/workers/executor.ts

@@ -528,6 +528,30 @@ export class Executor {
         })
     }
 
+    /**
+     * Set supported message library (owner only)
+     * @param tx - The transaction to add the move call to
+     * @param ownerCap - The owner capability object ID
+     * @param messageLib - The message library address
+     * @param supported - Whether to support or remove support for the message library
+     */
+    setSupportedMessageLibMoveCall(
+        tx: Transaction,
+        ownerCap: string | TransactionArgument,
+        messageLib: string | TransactionArgument,
+        supported: boolean | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('set_supported_message_lib'),
+            arguments: [
+                tx.object(this.objects.executor),
+                asObject(tx, ownerCap),
+                asAddress(tx, messageLib),
+                asBool(tx, supported),
+            ],
+        })
+    }
+
     /**
      * Set allowlist status for an OApp sender (owner only)
      * @param tx - The transaction to add the move call to
@@ -814,6 +838,34 @@ export class Executor {
         )
     }
 
+    /**
+     * Check if a message library is supported by this executor
+     * @param tx - The transaction to add the move call to
+     * @param messageLib - The message library address to check
+     * @returns Transaction result containing the support status
+     */
+    isSupportedMessageLibMoveCall(tx: Transaction, messageLib: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_supported_message_lib'),
+            arguments: [tx.object(this.objects.executor), asAddress(tx, messageLib)],
+        })
+    }
+
+    /**
+     * Check if a message library is supported by this executor
+     * @param messageLib - The message library address to check
+     * @returns Promise<boolean> - True if the message library is supported
+     */
+    async isSupportedMessageLib(messageLib: string): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isSupportedMessageLibMoveCall(tx, messageLib)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
     /**
      * Check if an address is allowlisted
      * @param tx - The transaction to add the move call to