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

package/src/modules/endpoint.ts

@@ -62,18 +62,23 @@ export const EndpointErrorCode = {
     MessagingChannel_ESendReentrancy: 10,
     MessagingChannel_EUninitializedChannel: 11,
 
+    // MessagingComposer related errors (with MessagingComposer_ prefix)
+    MessagingComposer_EComposeExists: 1,
+    MessagingComposer_EComposeMessageMismatch: 2,
+    MessagingComposer_EComposeNotFound: 3,
+    MessagingComposer_EComposerNotRegistered: 4,
+    MessagingComposer_EComposerRegistered: 5,
     // OAppRegistry related errors (with OAppRegistry_ prefix)
-    OAppRegistry_EInvalidLZReceiveInfo: 1,
-    OAppRegistry_EInvalidOriginalPackage: 2,
-    OAppRegistry_EOAppNotRegistered: 3,
-    OAppRegistry_EOAppRegistered: 4,
+    OAppRegistry_EOAppNotRegistered: 1,
+    OAppRegistry_EOAppRegistered: 2,
 
     // Endpoint related errors (with Endpoint_ prefix)
     Endpoint_EAlreadyInitialized: 1,
     Endpoint_EInvalidEid: 2,
     Endpoint_ENotInitialized: 3,
     Endpoint_ERefundAddressNotFound: 4,
-    Endpoint_EUnauthorizedSendLibrary: 5,
+    Endpoint_EUnauthorizedOApp: 5,
+    Endpoint_EUnauthorizedSendLibrary: 6,
 } as const
 
 export class Endpoint {
@@ -112,16 +117,17 @@ export class Endpoint {
      * Register an OApp with the endpoint
      * @param tx - The transaction to add the move call to
      * @param oappCap - The OApp capability object ID or transaction argument
-     * @param lzReceiveInfo - Transaction result containing LayerZero receive information
+     * @param oappInfo - OApp information including lz_receive execution information
+     * @returns Transaction result containing the messaging channel address
      */
     registerOAppMoveCall(
         tx: Transaction,
         oappCap: string | TransactionArgument,
-        lzReceiveInfo: Uint8Array | TransactionArgument
-    ): void {
-        tx.moveCall({
+        oappInfo: Uint8Array | TransactionArgument
+    ): TransactionResult {
+        return tx.moveCall({
             target: this.#target('register_oapp'),
-            arguments: [tx.object(this.objects.endpointV2), asObject(tx, oappCap), asBytes(tx, lzReceiveInfo)],
+            arguments: [tx.object(this.objects.endpointV2), asObject(tx, oappCap), asBytes(tx, oappInfo)],
         })
     }
 
@@ -143,25 +149,25 @@ export class Endpoint {
     }
 
     /**
-     * Set LayerZero receive information for an OApp
+     * Set OApp information for an OApp
      * @param tx - The transaction to add the move call to
      * @param callerCap - The caller capability object ID or transaction argument
      * @param oapp - The OApp address or transaction argument
-     * @param lzReceiveInfo - The LayerZero receive information as bytes or transaction argument
+     * @param oappInfo - The OApp information including lz_receive execution information as bytes or transaction argument
      */
-    setLzReceiveInfoMoveCall(
+    setOappInfoMoveCall(
         tx: Transaction,
         callerCap: string | TransactionArgument,
         oapp: string | TransactionArgument,
-        lzReceiveInfo: Uint8Array | TransactionArgument
+        oappInfo: Uint8Array | TransactionArgument
     ): void {
         tx.moveCall({
-            target: this.#target('set_lz_receive_info'),
+            target: this.#target('set_oapp_info'),
             arguments: [
                 tx.object(this.objects.endpointV2),
                 asObject(tx, callerCap),
                 asAddress(tx, oapp),
-                asBytes(tx, lzReceiveInfo),
+                asBytes(tx, oappInfo),
             ],
         })
     }
@@ -547,33 +553,34 @@ export class Endpoint {
      * Register a composer with the endpoint
      * @param tx - The transaction to add the move call to
      * @param composerCap - The composer capability object ID or transaction argument
-     * @param lzComposeInfo - LayerZero compose information as bytes
+     * @param composerInfo - Composer information including lz_compose execution information as bytes
+     * @returns Transaction result containing the compose queue address
      */
     registerComposerMoveCall(
         tx: Transaction,
         composerCap: string | TransactionArgument,
-        lzComposeInfo: Uint8Array | TransactionArgument
-    ): void {
-        tx.moveCall({
+        composerInfo: Uint8Array | TransactionArgument
+    ): TransactionResult {
+        return tx.moveCall({
             target: this.#target('register_composer'),
-            arguments: [tx.object(this.objects.endpointV2), asObject(tx, composerCap), asBytes(tx, lzComposeInfo)],
+            arguments: [tx.object(this.objects.endpointV2), asObject(tx, composerCap), asBytes(tx, composerInfo)],
         })
     }
 
     /**
-     * Set LayerZero compose information for a composer
+     * Set composer information for a composer
      * @param tx - The transaction to add the move call to
      * @param composerCap - The composer capability object ID or transaction argument
-     * @param lzComposeInfo - LayerZero compose information as bytes or transaction argument
+     * @param composerInfo - Composer information including lz_compose execution information as bytes or transaction argument
      */
-    setLzComposeInfoMoveCall(
+    setComposerInfoMoveCall(
         tx: Transaction,
         composerCap: string | TransactionArgument,
-        lzComposeInfo: Uint8Array | TransactionArgument
+        composerInfo: Uint8Array | TransactionArgument
     ): void {
         tx.moveCall({
-            target: this.#target('set_lz_compose_info'),
-            arguments: [tx.object(this.objects.endpointV2), asObject(tx, composerCap), asBytes(tx, lzComposeInfo)],
+            target: this.#target('set_composer_info'),
+            arguments: [tx.object(this.objects.endpointV2), asObject(tx, composerCap), asBytes(tx, composerInfo)],
         })
     }
 
@@ -1024,28 +1031,28 @@ export class Endpoint {
     }
 
     /**
-     * Get LayerZero receive information for an OApp
+     * Get OApp information for an OApp
      * @param tx - The transaction to add the move call to
      * @param oapp - The OApp address or transaction argument
-     * @returns Transaction result containing the receive information
+     * @returns Transaction result containing the OApp information including lz_receive execution information
      */
-    getLzReceiveInfoMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult {
+    getOappInfoMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult {
         return tx.moveCall({
-            target: this.#target('get_lz_receive_info'),
+            target: this.#target('get_oapp_info'),
             arguments: [tx.object(this.objects.endpointV2), asAddress(tx, oapp)],
         })
     }
 
     /**
-     * Get LayerZero receive information for an OApp
+     * Get OApp information for an OApp
      * @param oapp - The OApp address
-     * @returns Promise<Uint8Array> - The receive information as bytes
+     * @returns Promise<Uint8Array> - The OApp information including lz_receive execution information as bytes
      */
-    async getLzReceiveInfo(oapp: string): Promise<Uint8Array> {
+    async getOappInfo(oapp: string): Promise<Uint8Array> {
         return executeSimulate(
             this.client,
             (tx) => {
-                return this.getLzReceiveInfoMoveCall(tx, oapp)
+                return this.getOappInfoMoveCall(tx, oapp)
             },
             (result) => {
                 const parsed = bcs.vector(bcs.u8()).parse(result[0].value)
@@ -1139,28 +1146,28 @@ export class Endpoint {
     }
 
     /**
-     * Get LayerZero compose information for a composer
+     * Get composer information for a registered composer
      * @param tx - The transaction to add the move call to
      * @param composer - The composer address or transaction argument
-     * @returns Transaction result containing the compose information
+     * @returns Transaction result containing the composer information
      */
-    getLzComposeInfoMoveCall(tx: Transaction, composer: string | TransactionArgument): TransactionResult {
+    getComposerInfoMoveCall(tx: Transaction, composer: string | TransactionArgument): TransactionResult {
         return tx.moveCall({
-            target: this.#target('get_lz_compose_info'),
+            target: this.#target('get_composer_info'),
             arguments: [tx.object(this.objects.endpointV2), asAddress(tx, composer)],
         })
     }
 
     /**
-     * Get LayerZero compose information for a composer
+     * Get composer information for a registered composer
      * @param composer - The composer address
-     * @returns Promise<Uint8Array> - The compose information as bytes
+     * @returns Promise<Uint8Array> - The composer information as bytes
      */
-    async getLzComposeInfo(composer: string): Promise<Uint8Array> {
+    async getComposerInfo(composer: string): Promise<Uint8Array> {
         return executeSimulate(
             this.client,
             (tx) => {
-                this.getLzComposeInfoMoveCall(tx, composer)
+                this.getComposerInfoMoveCall(tx, composer)
             },
             (result) => {
                 const parsed = bcs.vector(bcs.u8()).parse(result[0].value)
@@ -2309,16 +2316,13 @@ export class Endpoint {
     async populateLzReceiveTransaction(
         tx: Transaction,
         lzReceiveCall: TransactionResult,
-        oapp: string, // receiver oapp
+        oapp: string | TransactionArgument, // receiver oapp
         sender: string | undefined = undefined,
         validators: IPTBValidator[] = [],
         maxSimulationTimes = DEFAULT_SIMULATION_TIMES
     ): Promise<MoveCall[]> {
         const simulateTx = Transaction.from(tx)
-        simulateTx.moveCall({
-            target: this.#target('get_lz_receive_info'),
-            arguments: [simulateTx.object(this.objects.endpointV2), simulateTx.pure.address(oapp)],
-        })
+        this.getOappInfoMoveCall(simulateTx, oapp)
         const moveCalls = await this.moduleManager.getPtbBuilder().simulateLzReceivePtb(simulateTx, sender)
 
         const [_, finalMoveCalls] = await this.moduleManager
@@ -2353,16 +2357,13 @@ export class Endpoint {
     async populateLzComposeTransaction(
         tx: Transaction,
         endpointLzComposeCall: TransactionResult,
-        composer: string,
+        composer: string | TransactionArgument,
         sender: string | undefined = undefined,
         validators: IPTBValidator[] = [],
         maxSimulationTimes = DEFAULT_SIMULATION_TIMES
     ): Promise<MoveCall[]> {
         const simulateTx = Transaction.from(tx)
-        simulateTx.moveCall({
-            target: this.#target('get_lz_compose_info'),
-            arguments: [simulateTx.object(this.objects.endpointV2), simulateTx.pure.address(composer)],
-        })
+        this.getComposerInfoMoveCall(simulateTx, composer)
         const moveCalls = await this.moduleManager.getPtbBuilder().simulateLzComposePtb(simulateTx, sender)
 
         const [_, finalMoveCalls] = await this.moduleManager

package/src/modules/message-libs/simple-message-lib.ts

@@ -9,9 +9,10 @@ import { asAddress, asBytes, asBytes32, asObject, asU64, executeSimulate } from
 const MODULE_NAME = 'simple_message_lib'
 
 export const SimpleMessageLibErrorCode = {
-    // SimpleMessageLib related errors (with SimpleMessageLib_ prefix)
-    SimpleMessageLib_EConfigNotFound: 1,
+    // SimpleMessageLib related errors (matching simple_message_lib.move)
+    SimpleMessageLib_ENotImplemented: 1,
     SimpleMessageLib_EZROFeeNotEnabled: 2,
+    SimpleMessageLib_EInvalidEid: 3,
 } as const
 
 export class SimpleMessageLib {

package/src/modules/message-libs/uln302.ts

@@ -19,7 +19,7 @@ import {
 
 const MODULE_NAME = 'uln_302'
 
-// ULN-302 specific error codes
+// ULN-302 specific error codes (matching uln-302 contract files)
 export const Uln302ErrorCode = {
     SendUln302_EDefaultExecutorConfigNotFound: 1,
     SendUln302_EDefaultUlnConfigNotFound: 2,
@@ -33,10 +33,28 @@ export const Uln302ErrorCode = {
     ReceiveUln302_EOAppUlnConfigNotFound: 4,
     ReceiveUln302_EVerifying: 5,
 
-    Uln302_EEndpointInitialized: 1,
-    Uln302_EInvalidConfigType: 2,
-    Uln302_EInvalidMessagingChannel: 3,
-    Uln302_EUnsupportedEid: 4,
+    Uln302_EInvalidConfigType: 1,
+    Uln302_EInvalidMessagingChannel: 2,
+    Uln302_EUnsupportedEid: 3,
+
+    // UlnConfig related errors (matching uln_config.move)
+    UlnConfig_EAtLeastOneDVN: 1,
+    UlnConfig_EDuplicateOptionalDVNs: 2,
+    UlnConfig_EDuplicateRequiredDVNs: 3,
+    UlnConfig_EInvalidOptionalDVNCount: 4,
+    UlnConfig_EInvalidOptionalDVNThreshold: 5,
+    UlnConfig_EInvalidRequiredDVNCount: 6,
+    UlnConfig_EInvalidUlnConfigBytes: 7,
+
+    // OAppUlnConfig related errors (matching oapp_uln_config.move)
+    OAppUlnConfig_EInvalidConfirmations: 1,
+    OAppUlnConfig_EInvalidRequiredDVNs: 2,
+    OAppUlnConfig_EInvalidOptionalDVNs: 3,
+
+    // ExecutorConfig related errors (matching executor_config.move)
+    ExecutorConfig_EInvalidExecutorAddress: 1,
+    ExecutorConfig_EInvalidExecutorBytes: 2,
+    ExecutorConfig_EZeroMessageSize: 3,
 } as const
 
 export class Uln302 {
@@ -162,32 +180,16 @@ export class Uln302 {
     }
 
     /**
-     * Verify packet move call with DVN signatures
-     * Note: This is typically called by DVNs, not directly by users
+     * Verify packet move call with DVN call (new API)
+     * Note: This is typically called by DVNs via Call objects, not directly by users
      * @param tx - The transaction to add the move call to
      * @param verification - The verification object address or transaction argument
-     * @param dvn - The DVN address performing verification or transaction argument
-     * @param packetHeader - The packet header as bytes or transaction argument
-     * @param payloadHash - The payload hash as bytes or transaction argument
-     * @param confirmations - Required confirmations count or transaction argument
+     * @param call - The DVN verification call containing verification parameters
      */
-    verifyMoveCall(
-        tx: Transaction,
-        verification: string | TransactionArgument,
-        dvn: string | TransactionArgument,
-        packetHeader: Uint8Array | TransactionArgument,
-        payloadHash: Uint8Array | TransactionArgument,
-        confirmations: bigint | TransactionArgument
-    ): void {
+    verifyMoveCall(tx: Transaction, verification: string | TransactionArgument, call: TransactionArgument): void {
         tx.moveCall({
             target: this.#target('verify'),
-            arguments: [
-                asObject(tx, verification),
-                asObject(tx, dvn),
-                asBytes(tx, packetHeader),
-                asBytes32(tx, payloadHash, this.moduleManager.getUtils()),
-                asU64(tx, confirmations),
-            ],
+            arguments: [tx.object(this.objects.uln302), asObject(tx, verification), call],
         })
     }
 

package/src/modules/oapps/counter.ts

@@ -7,11 +7,11 @@ import { EndpointId } from '@layerzerolabs/lz-definitions'
 import { ModuleManager } from '../../module-manager'
 import { MessagingFee, ObjectOptions } from '../../types'
 import {
+    IPTBValidator,
     asAddress,
     asBool,
     asBytes,
     asBytes32,
-    asObject,
     asU32,
     asU64,
     asU8,
@@ -22,15 +22,16 @@ import {
 const MODULE_NAME = 'counter'
 
 export const CounterErrorCode = {
-    // Counter related errors
+    // Counter related errors (matching counter.move)
     Counter_EInvalidMsgType: 0,
     Counter_EInvalidValue: 1,
     Counter_EInvalidNonce: 2,
     Counter_EOnlyEndpoint: 3,
     Counter_ESelfComposeOnly: 4,
     Counter_EInvalidOApp: 5,
-    Counter_EInvalidAdminCap: 6,
-    Counter_EAlreadyInitialized: 7,
+
+    // OptionsBuilder related errors (matching options_builder.move)
+    OptionsBuilder_EInvalidSize: 1,
 } as const
 
 export class Counter {
@@ -83,7 +84,8 @@ export class Counter {
         dstEid: EndpointId | TransactionArgument,
         msgType: number | TransactionArgument,
         options: Uint8Array | TransactionArgument,
-        payInZero: boolean | TransactionArgument
+        payInZero: boolean | TransactionArgument,
+        validators?: IPTBValidator[]
     ): Promise<MessagingFee> {
         const tx = new Transaction()
         const quoteCall = tx.moveCall({
@@ -97,7 +99,7 @@ export class Counter {
                 asBool(tx, payInZero),
             ],
         })
-        return this.moduleManager.getEndpoint().quote(tx, quoteCall)
+        return this.moduleManager.getEndpoint().quote(tx, quoteCall, undefined, validators)
     }
 
     /**
@@ -107,7 +109,6 @@ export class Counter {
      * @param dstEid - Destination endpoint ID
      * @param msgType - Message type (SEND or SEND_AND_CALL)
      * @param options - Execution options as bytes
-     * @param sendValue - Value to send with the message
      * @param nativeFee - Native token fee amount
      * @param zroFee - ZRO token fee amount
      * @param refundAddress - Address for fee refunds
@@ -118,10 +119,10 @@ export class Counter {
         dstEid: EndpointId | TransactionArgument,
         msgType: number | TransactionArgument,
         options: Uint8Array | TransactionArgument,
-        sendValue: bigint | TransactionArgument,
         nativeFee: bigint | TransactionArgument,
         zroFee: bigint | TransactionArgument,
-        refundAddress: string | TransactionArgument
+        refundAddress: string | TransactionArgument,
+        validators?: IPTBValidator[]
     ): Promise<void> {
         const [nativeToken] = tx.splitCoins(tx.gas, [asU64(tx, nativeFee)])
         const zroToken = isTransactionArgument(zroFee)
@@ -135,80 +136,60 @@ export class Counter {
                 asU32(tx, dstEid),
                 asU8(tx, msgType),
                 asBytes(tx, options),
-                asU64(tx, sendValue),
                 nativeToken,
                 zroToken,
                 asAddress(tx, refundAddress),
             ],
         })
-        await this.moduleManager.getEndpoint().populateSendTransaction(tx, incrementCall, sender)
+        await this.moduleManager.getEndpoint().populateSendTransaction(tx, incrementCall, sender, validators)
     }
 
     /**
-     * Set peer counter on another chain
+     * Set composer information for counter
      * @param tx - The transaction to add the move call to
-     * @param messagingChannel - The messaging channel object ID or transaction argument
-     * @param eid - The peer endpoint ID or transaction argument
-     * @param peer - The peer counter address as bytes or transaction argument
+     * @param composerInfo - Composer information including lz_compose execution information as bytes
      */
-    setPeerMoveCall(
-        tx: Transaction,
-        messagingChannel: string | TransactionArgument,
-        eid: number | TransactionArgument,
-        peer: Uint8Array | TransactionArgument
-    ): void {
+    setComposerInfoMoveCall(tx: Transaction, composerInfo: Uint8Array | TransactionArgument): void {
         tx.moveCall({
-            target: this.#target('set_peer'),
+            target: this.#target('set_composer_info'),
             arguments: [
                 tx.object(this.objects.counter),
                 tx.object(this.objects.counterOapp),
                 tx.object(this.objects.counterAdminCap),
                 tx.object(this.objects.endpointV2),
-                asObject(tx, messagingChannel),
-                asU32(tx, eid),
-                asBytes32(tx, peer, this.moduleManager.getUtils()),
+                asBytes(tx, composerInfo),
             ],
         })
     }
 
+    // === View Functions ===
+
     /**
-     * Set delegate for the counter
+     * Get counter EID
      * @param tx - The transaction to add the move call to
-     * @param newDelegate - The new delegate address or transaction argument
+     * @returns Transaction result containing the counter EID
      */
-    setDelegateMoveCall(tx: Transaction, newDelegate: string | TransactionArgument): void {
-        tx.moveCall({
-            target: this.#target('set_delegate'),
-            arguments: [
-                tx.object(this.objects.counter),
-                tx.object(this.objects.counterOapp),
-                tx.object(this.objects.counterAdminCap),
-                tx.object(this.objects.endpointV2),
-                asAddress(tx, newDelegate),
-            ],
+    getEidMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('eid'),
+            arguments: [tx.object(this.objects.counter)],
         })
     }
 
     /**
-     * Set LayerZero compose information for counter
-     * @param tx - The transaction to add the move call to
-     * @param lzComposeInfo - LayerZero compose information as bytes
+     * Get counter EID
+     * @returns Promise<number> - The counter EID
      */
-    setLzComposeInfoMoveCall(tx: Transaction, lzComposeInfo: Uint8Array | TransactionArgument): void {
-        tx.moveCall({
-            target: this.#target('set_lz_compose_info'),
-            arguments: [
-                tx.object(this.objects.counter),
-                tx.object(this.objects.counterOapp),
-                tx.object(this.objects.counterAdminCap),
-                tx.object(this.objects.endpointV2),
-                asBytes(tx, lzComposeInfo),
-            ],
-        })
+    async getEid(): Promise<number> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getEidMoveCall(tx)
+            },
+            (result) => bcs.U32.parse(result[0].value)
+        )
     }
 
-    // === View Functions ===
-
     /**
      * Get call capability address for counter
      * @param tx - The transaction to add the move call to