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

package/src/modules/oapps/oapp.ts

@@ -2,43 +2,72 @@ import { bcs } from '@mysten/sui/bcs'
 import { SuiClient } from '@mysten/sui/client'
 import { Transaction, TransactionArgument, TransactionResult } from '@mysten/sui/transactions'
 
+import { OAppInfoV1Bcs } from '../../bcs'
 import { ModuleManager } from '../../module-manager'
 import { ObjectOptions } from '../../types'
-import { asBytes, asBytes32, asObject, asU16, asU32, executeSimulate } from '../../utils'
+import { OAppInfoV1 } from '../../types/oapp'
+import {
+    asAddress,
+    asBytes,
+    asBytes32,
+    asObject,
+    asU16,
+    asU32,
+    asU64,
+    executeSimulate,
+    isTransactionArgument,
+} from '../../utils'
 
 const MODULE_NAME = 'oapp'
 
 export const OAppErrorCode = {
-    // OApp related errors
-    OApp_EAlreadyInited: 1,
-    OApp_EChannelNotInited: 2,
-    OApp_EEndpointNotInited: 3,
-    OApp_EInvalidAdminCap: 4,
-    OApp_EInvalidCallCap: 5,
-    OApp_EOnlyEndpoint: 6,
-    OApp_EOnlyPeer: 7,
-    // EndpointConfig related errors
-    EndpointConfig_EInvalidAdminCap: 1,
-    EndpointConfig_EInvalidIntentType: 2,
-    EndpointConfig_EInvalidOAppCallCap: 3,
+    // OApp related errors (matching oapp.move)
+    OApp_EInvalidAdminCap: 1,
+    OApp_EInvalidOAppCap: 2,
+    OApp_EInvalidRefundAddress: 3,
+    OApp_EInvalidSendingCall: 4,
+    OApp_EOnlyEndpoint: 5,
+    OApp_EOnlyPeer: 6,
+    OApp_ESendingInProgress: 7,
+
+    // OAppPeer related errors (matching oapp_peer.move)
+    OAppPeer_EPeerNotFound: 0,
+    OAppPeer_EInvalidPeer: 1,
+
+    // EnforcedOptions related errors (matching enforced_options.move)
+    EnforcedOptions_EEnforcedOptionsNotFound: 1,
+    EnforcedOptions_EInvalidOptionsLength: 2,
+    EnforcedOptions_EInvalidOptionsType: 3,
+
+    // OAppInfoV1 related errors (matching oapp_info_v1.move)
+    OAppInfoV1_EInvalidData: 1,
+    OAppInfoV1_EInvalidVersion: 2,
 } as const
 
 export class OApp {
     public packageId: string
+    public oappCallCapId: string
     public readonly client: SuiClient
+    public oappInfo: OAppInfoV1 | null = null
     private readonly objects: ObjectOptions
 
     constructor(
         packageId: string,
+        oappCallCapId: string,
         client: SuiClient,
         objects: ObjectOptions,
         private readonly moduleManager: ModuleManager
     ) {
         this.packageId = packageId
+        this.oappCallCapId = oappCallCapId
         this.client = client
         this.objects = objects
     }
 
+    // setOAppInfo(oappInfo: OAppInfoV1): void {
+    //     this.oappInfo = oappInfo
+    // }
+
     // === Set Functions ===
 
     /**
@@ -50,18 +79,18 @@ export class OApp {
      * @param msgType - Message type or transaction argument
      * @param options - Enforced options as bytes or transaction argument
      */
-    setEnforcedOptionsMoveCall(
+    async setEnforcedOptionsMoveCall(
         tx: Transaction,
-        oapp: string | TransactionArgument,
-        adminCap: string | TransactionArgument,
         eid: number | TransactionArgument,
         msgType: number | TransactionArgument,
         options: Uint8Array | TransactionArgument
-    ): void {
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
         tx.moveCall({
             target: this.#target('set_enforced_options'),
             arguments: [
-                asObject(tx, oapp),
+                asObject(tx, oappInfo.oapp_object),
                 asObject(tx, adminCap),
                 asU32(tx, eid),
                 asU16(tx, msgType),
@@ -78,18 +107,21 @@ export class OApp {
      * @param eid - Peer endpoint ID or transaction argument
      * @param peer - Peer OApp address as bytes or transaction argument
      */
-    setPeerMoveCall(
+    async setPeerMoveCall(
         tx: Transaction,
-        oapp: string | TransactionArgument,
-        adminCap: string | TransactionArgument,
         eid: number | TransactionArgument,
         peer: Uint8Array | TransactionArgument
-    ): void {
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        const messagingChannel = await this.moduleManager.getEndpoint().getMessagingChannel(this.oappCallCapId)
         tx.moveCall({
             target: this.#target('set_peer'),
             arguments: [
-                asObject(tx, oapp),
+                asObject(tx, oappInfo.oapp_object),
                 asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asObject(tx, messagingChannel),
                 asU32(tx, eid),
                 asBytes32(tx, peer, this.moduleManager.getUtils()),
             ],
@@ -99,56 +131,57 @@ export class OApp {
     // === View Functions ===
 
     /**
-     * Get admin address for OApp
+     * Get admin capability address for OApp
      * @param tx - The transaction to add the move call to
      * @param oapp - The OApp object ID or transaction argument
-     * @returns Transaction result containing the admin address
+     * @returns Transaction result containing the admin capability address
      */
-    getAdminMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult {
+    getAdminCapMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult {
         return tx.moveCall({
-            target: this.#target('admin'),
+            target: this.#target('admin_cap'),
             arguments: [asObject(tx, oapp)],
         })
     }
 
     /**
-     * Get admin address for OApp
+     * Get admin capability address for OApp
      * @param oapp - The OApp object ID
-     * @returns Promise<string> - The admin address
+     * @returns Promise<string> - The admin capability address
      */
-    async getAdmin(oapp: string): Promise<string> {
+    async getAdminCap(oapp: string): Promise<string> {
         return executeSimulate(
             this.client,
             (tx) => {
-                this.getAdminMoveCall(tx, oapp)
+                this.getAdminCapMoveCall(tx, oapp)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
     }
 
     /**
-     * Get OApp address (call capability ID)
+     * Get OApp CallCap identifier
      * @param tx - The transaction to add the move call to
      * @param oapp - The OApp object ID or transaction argument
-     * @returns Transaction result containing the OApp address
+     * @returns Transaction result containing the OApp CallCap identifier
      */
-    getOAppAddressMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult {
+    async getOAppCapIdMoveCall(tx: Transaction): Promise<TransactionResult> {
+        const oappInfo = await this.#oappInfo()
         return tx.moveCall({
-            target: this.#target('oapp_address'),
-            arguments: [asObject(tx, oapp)],
+            target: this.#target('oapp_cap_id'),
+            arguments: [asObject(tx, oappInfo.oapp_object)],
         })
     }
 
     /**
-     * Get OApp address (call capability ID)
-     * @param oapp - The OApp object ID
-     * @returns Promise<string> - The OApp address
+     * Get OApp CallCap identifier
+     * @param oapp - The OApp object ID (optional, uses configured oapp if not provided)
+     * @returns Promise<string> - The OApp CallCap identifier
      */
-    async getOAppAddress(oapp: string): Promise<string> {
+    async getOAppCapId(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.getOAppAddressMoveCall(tx, oapp)
+            async (tx) => {
+                await this.getOAppCapIdMoveCall(tx)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -163,16 +196,21 @@ export class OApp {
      * @param extraOptions - Extra options to combine with enforced options or transaction argument
      * @returns Transaction result containing combined options
      */
-    combineOptionsMoveCall(
+    async combineOptionsMoveCall(
         tx: Transaction,
-        oapp: string | TransactionArgument,
         eid: number | TransactionArgument,
         msgType: number | TransactionArgument,
         extraOptions: Uint8Array | TransactionArgument
-    ): TransactionResult {
+    ): Promise<TransactionResult> {
+        const oappInfo = await this.#oappInfo()
         return tx.moveCall({
             target: this.#target('combine_options'),
-            arguments: [asObject(tx, oapp), asU32(tx, eid), asU16(tx, msgType), asBytes(tx, extraOptions)],
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asU32(tx, eid),
+                asU16(tx, msgType),
+                asBytes(tx, extraOptions),
+            ],
         })
     }
 
@@ -184,11 +222,11 @@ export class OApp {
      * @param extraOptions - Extra options to combine with enforced options
      * @returns Promise<Uint8Array> - Combined options as bytes
      */
-    async combineOptions(oapp: string, eid: number, msgType: number, extraOptions: Uint8Array): Promise<Uint8Array> {
+    async combineOptions(eid: number, msgType: number, extraOptions: Uint8Array): Promise<Uint8Array> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.combineOptionsMoveCall(tx, oapp, eid, msgType, extraOptions)
+            async (tx) => {
+                await this.combineOptionsMoveCall(tx, eid, msgType, extraOptions)
             },
             (result) => new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
         )
@@ -202,15 +240,15 @@ export class OApp {
      * @param msgType - Message type or transaction argument
      * @returns Transaction result containing enforced options
      */
-    getEnforcedOptionsMoveCall(
+    async getEnforcedOptionsMoveCall(
         tx: Transaction,
-        oapp: string | TransactionArgument,
         eid: number | TransactionArgument,
         msgType: number | TransactionArgument
-    ): TransactionResult {
+    ): Promise<TransactionResult> {
+        const oappInfo = await this.#oappInfo()
         return tx.moveCall({
             target: this.#target('get_enforced_options'),
-            arguments: [asObject(tx, oapp), asU32(tx, eid), asU16(tx, msgType)],
+            arguments: [asObject(tx, oappInfo.oapp_object), asU32(tx, eid), asU16(tx, msgType)],
         })
     }
 
@@ -221,11 +259,11 @@ export class OApp {
      * @param msgType - Message type
      * @returns Promise<Uint8Array> - Enforced options as bytes
      */
-    async getEnforcedOptions(oapp: string, eid: number, msgType: number): Promise<Uint8Array> {
+    async getEnforcedOptions(eid: number, msgType: number): Promise<Uint8Array> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.getEnforcedOptionsMoveCall(tx, oapp, eid, msgType)
+            async (tx) => {
+                await this.getEnforcedOptionsMoveCall(tx, eid, msgType)
             },
             (result) => new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
         )
@@ -238,14 +276,11 @@ export class OApp {
      * @param dstEid - Destination endpoint ID or transaction argument
      * @returns Transaction result containing boolean result
      */
-    hasPeerMoveCall(
-        tx: Transaction,
-        oapp: string | TransactionArgument,
-        dstEid: number | TransactionArgument
-    ): TransactionResult {
+    async hasPeerMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult> {
+        const oappInfo = await this.#oappInfo()
         return tx.moveCall({
             target: this.#target('has_peer'),
-            arguments: [asObject(tx, oapp), asU32(tx, dstEid)],
+            arguments: [asObject(tx, oappInfo.oapp_object), asU32(tx, dstEid)],
         })
     }
 
@@ -255,11 +290,11 @@ export class OApp {
      * @param dstEid - Destination endpoint ID
      * @returns Promise<boolean> - True if peer is configured, false otherwise
      */
-    async hasPeer(oapp: string, dstEid: number): Promise<boolean> {
+    async hasPeer(dstEid: number): Promise<boolean> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.hasPeerMoveCall(tx, oapp, dstEid)
+            async (tx) => {
+                await this.hasPeerMoveCall(tx, dstEid)
             },
             (result) => bcs.Bool.parse(result[0].value)
         )
@@ -272,14 +307,11 @@ export class OApp {
      * @param dstEid - Destination endpoint ID or transaction argument
      * @returns Transaction result containing peer address
      */
-    getPeerMoveCall(
-        tx: Transaction,
-        oapp: string | TransactionArgument,
-        dstEid: number | TransactionArgument
-    ): TransactionResult {
+    async getPeerMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult> {
+        const oappInfo = await this.#oappInfo()
         return tx.moveCall({
             target: this.#target('get_peer'),
-            arguments: [asObject(tx, oapp), asU32(tx, dstEid)],
+            arguments: [asObject(tx, oappInfo.oapp_object), asU32(tx, dstEid)],
         })
     }
 
@@ -289,11 +321,11 @@ export class OApp {
      * @param dstEid - Destination endpoint ID
      * @returns Promise<Uint8Array> - Peer address as bytes32
      */
-    async getPeer(oapp: string, dstEid: number): Promise<Uint8Array> {
+    async getPeer(dstEid: number): Promise<Uint8Array> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.getPeerMoveCall(tx, oapp, dstEid)
+            async (tx) => {
+                await this.getPeerMoveCall(tx, dstEid)
             },
             (result) => {
                 return new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
@@ -301,8 +333,391 @@ export class OApp {
         )
     }
 
+    getOAppInfoV1MoveCall(tx: Transaction): TransactionResult {
+        const endpoint = this.moduleManager.getEndpoint()
+        const oappInfoRaw = endpoint.getLzReceiveInfoMoveCall(tx, this.oappCallCapId) // the new OAppInfo used to be named as lz_receive_info
+        return tx.moveCall({
+            target: `${this.packageId}::oapp_info_v1::decode`,
+            arguments: [oappInfoRaw],
+        })
+    }
+
+    async getOAppInfoV1(): Promise<OAppInfoV1> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.getOAppInfoV1MoveCall(tx)
+            },
+            (result) => {
+                return OAppInfoV1Bcs.parse(result[0].value)
+            }
+        )
+    }
+
+    // === Endpoint Call Functions ===
+
+    /**
+     * Register OApp with the endpoint
+     * @param tx - The transaction to add the move call to
+     * @param oappInfo - OApp information as bytes (optional)
+     * @returns Transaction result containing the messaging channel address
+     */
+    async registerOAppMoveCall(
+        tx: Transaction,
+        oappInfo?: Uint8Array | TransactionArgument
+    ): Promise<TransactionResult> {
+        let oappInfoArg: TransactionArgument
+        if (isTransactionArgument(oappInfo)) {
+            oappInfoArg = oappInfo
+        } else if (oappInfo) {
+            // For Some(vector<u8>), convert Uint8Array to number[] and wrap in Option
+            oappInfoArg = tx.pure.option('vector<u8>', Array.from(oappInfo))
+        } else {
+            // For None
+            oappInfoArg = tx.pure.option('vector<u8>', null)
+        }
+
+        const oappInfoObj = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfoObj.oapp_object)
+        return tx.moveCall({
+            target: this.#target('register_oapp', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfoObj.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                oappInfoArg,
+            ],
+        })
+    }
+
+    /**
+     * Set delegate for OApp
+     * @param tx - The transaction to add the move call to
+     * @param newDelegate - New delegate address
+     */
+    async setDelegateMoveCall(tx: Transaction, newDelegate: string | TransactionArgument): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        tx.moveCall({
+            target: this.#target('set_delegate', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asAddress(tx, newDelegate),
+            ],
+        })
+    }
+
+    /**
+     * Set OApp information in the endpoint
+     * @param tx - The transaction to add the move call to
+     * @param oappInfo - OApp information as bytes
+     */
+    async setOAppInfoMoveCall(tx: Transaction, oappInfo: Uint8Array | TransactionArgument): Promise<void> {
+        const oappInfoObj = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfoObj.oapp_object)
+        tx.moveCall({
+            target: this.#target('set_oapp_info', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfoObj.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asBytes(tx, oappInfo),
+            ],
+        })
+    }
+
+    /**
+     * Initialize channel with remote OApp
+     * @param tx - The transaction to add the move call to
+     * @param remoteEid - Remote endpoint ID
+     * @param remoteOApp - Remote OApp address as bytes32
+     */
+    async initChannelMoveCall(
+        tx: Transaction,
+        remoteEid: number | TransactionArgument,
+        remoteOApp: Uint8Array | TransactionArgument
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        const messagingChannel = await this.moduleManager.getEndpoint().getMessagingChannel(this.oappCallCapId)
+        tx.moveCall({
+            target: this.#target('init_channel', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asObject(tx, messagingChannel),
+                asU32(tx, remoteEid),
+                asBytes32(tx, remoteOApp, this.moduleManager.getUtils()),
+            ],
+        })
+    }
+
+    /**
+     * Clear a message from the messaging channel
+     * @param tx - The transaction to add the move call to
+     * @param srcEid - Source endpoint ID
+     * @param sender - Sender address as bytes32
+     * @param nonce - Message nonce
+     * @param guid - Message GUID as bytes32
+     * @param message - Message payload
+     */
+    async clearMoveCall(
+        tx: Transaction,
+        srcEid: number | TransactionArgument,
+        sender: Uint8Array | TransactionArgument,
+        nonce: number | bigint | TransactionArgument,
+        guid: Uint8Array | TransactionArgument,
+        message: Uint8Array | TransactionArgument
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        const messagingChannel = await this.moduleManager.getEndpoint().getMessagingChannel(this.oappCallCapId)
+        tx.moveCall({
+            target: this.#target('clear', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asObject(tx, messagingChannel),
+                asU32(tx, srcEid),
+                asBytes32(tx, sender, this.moduleManager.getUtils()),
+                asU64(tx, nonce),
+                asBytes32(tx, guid, this.moduleManager.getUtils()),
+                asBytes(tx, message),
+            ],
+        })
+    }
+
+    /**
+     * Skip a message in the messaging channel
+     * @param tx - The transaction to add the move call to
+     * @param srcEid - Source endpoint ID
+     * @param sender - Sender address as bytes32
+     * @param nonce - Message nonce
+     */
+    async skipMoveCall(
+        tx: Transaction,
+        srcEid: number | TransactionArgument,
+        sender: Uint8Array | TransactionArgument,
+        nonce: number | bigint | TransactionArgument
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        const messagingChannel = await this.moduleManager.getEndpoint().getMessagingChannel(this.oappCallCapId)
+        tx.moveCall({
+            target: this.#target('skip', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asObject(tx, messagingChannel),
+                asU32(tx, srcEid),
+                asBytes32(tx, sender, this.moduleManager.getUtils()),
+                asU64(tx, nonce),
+            ],
+        })
+    }
+
+    /**
+     * Nilify a message in the messaging channel
+     * @param tx - The transaction to add the move call to
+     * @param srcEid - Source endpoint ID
+     * @param sender - Sender address as bytes32
+     * @param nonce - Message nonce
+     * @param payloadHash - Payload hash as bytes32
+     */
+    async nilifyMoveCall(
+        tx: Transaction,
+        srcEid: number | TransactionArgument,
+        sender: Uint8Array | TransactionArgument,
+        nonce: number | bigint | TransactionArgument,
+        payloadHash: Uint8Array | TransactionArgument
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        const messagingChannel = await this.moduleManager.getEndpoint().getMessagingChannel(this.oappCallCapId)
+        tx.moveCall({
+            target: this.#target('nilify', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asObject(tx, messagingChannel),
+                asU32(tx, srcEid),
+                asBytes32(tx, sender, this.moduleManager.getUtils()),
+                asU64(tx, nonce),
+                asBytes32(tx, payloadHash, this.moduleManager.getUtils()),
+            ],
+        })
+    }
+
+    /**
+     * Burn a message in the messaging channel
+     * @param tx - The transaction to add the move call to
+     * @param srcEid - Source endpoint ID
+     * @param sender - Sender address as bytes32
+     * @param nonce - Message nonce
+     * @param payloadHash - Payload hash as bytes32
+     */
+    async burnMoveCall(
+        tx: Transaction,
+        srcEid: number | TransactionArgument,
+        sender: Uint8Array | TransactionArgument,
+        nonce: number | bigint | TransactionArgument,
+        payloadHash: Uint8Array | TransactionArgument
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        const messagingChannel = await this.moduleManager.getEndpoint().getMessagingChannel(this.oappCallCapId)
+        tx.moveCall({
+            target: this.#target('burn', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asObject(tx, messagingChannel),
+                asU32(tx, srcEid),
+                asBytes32(tx, sender, this.moduleManager.getUtils()),
+                asU64(tx, nonce),
+                asBytes32(tx, payloadHash, this.moduleManager.getUtils()),
+            ],
+        })
+    }
+
+    /**
+     * Set send library for a destination chain
+     * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
+     * @param sendLibrary - Send library address
+     */
+    async setSendLibraryMoveCall(
+        tx: Transaction,
+        dstEid: number | TransactionArgument,
+        sendLibrary: string | TransactionArgument
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        tx.moveCall({
+            target: this.#target('set_send_library', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asU32(tx, dstEid),
+                asAddress(tx, sendLibrary),
+            ],
+        })
+    }
+
+    /**
+     * Set receive library for a source chain
+     * @param tx - The transaction to add the move call to
+     * @param srcEid - Source endpoint ID
+     * @param receiveLibrary - Receive library address
+     * @param gracePeriod - Grace period in seconds
+     */
+    async setReceiveLibraryMoveCall(
+        tx: Transaction,
+        srcEid: number | TransactionArgument,
+        receiveLibrary: string | TransactionArgument,
+        gracePeriod: number | bigint | TransactionArgument
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        tx.moveCall({
+            target: this.#target('set_receive_library', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asU32(tx, srcEid),
+                asAddress(tx, receiveLibrary),
+                asU64(tx, gracePeriod),
+                tx.object.clock(),
+            ],
+        })
+    }
+
+    /**
+     * Set receive library timeout for a source chain
+     * @param tx - The transaction to add the move call to
+     * @param srcEid - Source endpoint ID
+     * @param receiveLibrary - Receive library address
+     * @param expiry - Expiry timestamp in seconds
+     */
+    async setReceiveLibraryTimeoutMoveCall(
+        tx: Transaction,
+        srcEid: number | TransactionArgument,
+        receiveLibrary: string | TransactionArgument,
+        expiry: number | bigint | TransactionArgument
+    ): Promise<void> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        tx.moveCall({
+            target: this.#target('set_receive_library_timeout', 'endpoint_calls'),
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asU32(tx, srcEid),
+                asAddress(tx, receiveLibrary),
+                asU64(tx, expiry),
+                tx.object.clock(),
+            ],
+        })
+    }
+
+    /**
+     * Set configuration for a message library
+     * @param tx - The transaction to add the move call to
+     * @param lib - Library address
+     * @param eid - Endpoint ID
+     * @param configType - Configuration type
+     * @param config - Configuration data as bytes
+     * @returns Transaction result containing Call<MessageLibSetConfigParam, Void>
+     */
+    async setConfigMoveCall(
+        tx: Transaction,
+        lib: string | TransactionArgument,
+        eid: number | TransactionArgument,
+        configType: number | TransactionArgument,
+        config: Uint8Array | TransactionArgument
+    ): Promise<TransactionResult> {
+        const oappInfo = await this.#oappInfo()
+        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+        return tx.moveCall({
+            target: this.#target('set_config', 'endpoint_calls'),
+            typeArguments: [],
+            arguments: [
+                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, adminCap),
+                asObject(tx, this.objects.endpointV2),
+                asAddress(tx, lib),
+                asU32(tx, eid),
+                asU32(tx, configType),
+                asBytes(tx, config),
+            ],
+        })
+    }
+
     // === Private Functions ===
 
+    /**
+     * Get OApp info, throwing if not set
+     * @returns The OApp info
+     * @throws Error if OApp info is not set
+     * @private
+     */
+    async #oappInfo(): Promise<OAppInfoV1> {
+        if (!this.oappInfo) {
+            this.oappInfo = await this.getOAppInfoV1()
+        }
+        return this.oappInfo
+    }
+
     /**
      * Generate the full target path for move calls
      * @param name - The function name to call