@layerzerolabs/lz-sui-sdk-v2 3.0.134-sui.3 → 3.0.134

package/src/modules/oapps/oapp.ts

@@ -2,72 +2,43 @@ 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 { OAppInfoV1 } from '../../types/oapp'
-import {
-    asAddress,
-    asBytes,
-    asBytes32,
-    asObject,
-    asU16,
-    asU32,
-    asU64,
-    executeSimulate,
-    isTransactionArgument,
-} from '../../utils'
+import { asBytes, asBytes32, asObject, asU16, asU32, executeSimulate } from '../../utils'
 
 const MODULE_NAME = 'oapp'
 
 export const OAppErrorCode = {
-    // 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,
+    // 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,
 } 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 ===
 
     /**
@@ -79,18 +50,18 @@ export class OApp {
      * @param msgType - Message type or transaction argument
      * @param options - Enforced options as bytes or transaction argument
      */
-    async setEnforcedOptionsMoveCall(
+    setEnforcedOptionsMoveCall(
         tx: Transaction,
+        oapp: string | TransactionArgument,
+        adminCap: string | TransactionArgument,
         eid: number | TransactionArgument,
         msgType: number | TransactionArgument,
         options: Uint8Array | TransactionArgument
-    ): Promise<void> {
-        const oappInfo = await this.#oappInfo()
-        const adminCap = await this.getAdminCap(oappInfo.oapp_object)
+    ): void {
         tx.moveCall({
             target: this.#target('set_enforced_options'),
             arguments: [
-                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, oapp),
                 asObject(tx, adminCap),
                 asU32(tx, eid),
                 asU16(tx, msgType),
@@ -107,21 +78,18 @@ export class OApp {
      * @param eid - Peer endpoint ID or transaction argument
      * @param peer - Peer OApp address as bytes or transaction argument
      */
-    async setPeerMoveCall(
+    setPeerMoveCall(
         tx: Transaction,
+        oapp: string | TransactionArgument,
+        adminCap: string | TransactionArgument,
         eid: number | TransactionArgument,
         peer: 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)
+    ): void {
         tx.moveCall({
             target: this.#target('set_peer'),
             arguments: [
-                asObject(tx, oappInfo.oapp_object),
+                asObject(tx, oapp),
                 asObject(tx, adminCap),
-                asObject(tx, this.objects.endpointV2),
-                asObject(tx, messagingChannel),
                 asU32(tx, eid),
                 asBytes32(tx, peer, this.moduleManager.getUtils()),
             ],
@@ -131,57 +99,56 @@ export class OApp {
     // === View Functions ===
 
     /**
-     * Get admin capability address for OApp
+     * Get admin 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 capability address
+     * @returns Transaction result containing the admin address
      */
-    getAdminCapMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult {
+    getAdminMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult {
         return tx.moveCall({
-            target: this.#target('admin_cap'),
+            target: this.#target('admin'),
             arguments: [asObject(tx, oapp)],
         })
     }
 
     /**
-     * Get admin capability address for OApp
+     * Get admin address for OApp
      * @param oapp - The OApp object ID
-     * @returns Promise<string> - The admin capability address
+     * @returns Promise<string> - The admin address
      */
-    async getAdminCap(oapp: string): Promise<string> {
+    async getAdmin(oapp: string): Promise<string> {
         return executeSimulate(
             this.client,
             (tx) => {
-                this.getAdminCapMoveCall(tx, oapp)
+                this.getAdminMoveCall(tx, oapp)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
     }
 
     /**
-     * Get OApp CallCap identifier
+     * Get OApp address (call capability ID)
      * @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 CallCap identifier
+     * @returns Transaction result containing the OApp address
      */
-    async getOAppCapIdMoveCall(tx: Transaction): Promise<TransactionResult> {
-        const oappInfo = await this.#oappInfo()
+    getOAppAddressMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult {
         return tx.moveCall({
-            target: this.#target('oapp_cap_id'),
-            arguments: [asObject(tx, oappInfo.oapp_object)],
+            target: this.#target('oapp_address'),
+            arguments: [asObject(tx, oapp)],
         })
     }
 
     /**
-     * Get OApp CallCap identifier
-     * @param oapp - The OApp object ID (optional, uses configured oapp if not provided)
-     * @returns Promise<string> - The OApp CallCap identifier
+     * Get OApp address (call capability ID)
+     * @param oapp - The OApp object ID
+     * @returns Promise<string> - The OApp address
      */
-    async getOAppCapId(): Promise<string> {
+    async getOAppAddress(oapp: string): Promise<string> {
         return executeSimulate(
             this.client,
-            async (tx) => {
-                await this.getOAppCapIdMoveCall(tx)
+            (tx) => {
+                this.getOAppAddressMoveCall(tx, oapp)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -196,21 +163,16 @@ export class OApp {
      * @param extraOptions - Extra options to combine with enforced options or transaction argument
      * @returns Transaction result containing combined options
      */
-    async combineOptionsMoveCall(
+    combineOptionsMoveCall(
         tx: Transaction,
+        oapp: string | TransactionArgument,
         eid: number | TransactionArgument,
         msgType: number | TransactionArgument,
         extraOptions: Uint8Array | TransactionArgument
-    ): Promise<TransactionResult> {
-        const oappInfo = await this.#oappInfo()
+    ): TransactionResult {
         return tx.moveCall({
             target: this.#target('combine_options'),
-            arguments: [
-                asObject(tx, oappInfo.oapp_object),
-                asU32(tx, eid),
-                asU16(tx, msgType),
-                asBytes(tx, extraOptions),
-            ],
+            arguments: [asObject(tx, oapp), asU32(tx, eid), asU16(tx, msgType), asBytes(tx, extraOptions)],
         })
     }
 
@@ -222,11 +184,11 @@ export class OApp {
      * @param extraOptions - Extra options to combine with enforced options
      * @returns Promise<Uint8Array> - Combined options as bytes
      */
-    async combineOptions(eid: number, msgType: number, extraOptions: Uint8Array): Promise<Uint8Array> {
+    async combineOptions(oapp: string, eid: number, msgType: number, extraOptions: Uint8Array): Promise<Uint8Array> {
         return executeSimulate(
             this.client,
-            async (tx) => {
-                await this.combineOptionsMoveCall(tx, eid, msgType, extraOptions)
+            (tx) => {
+                this.combineOptionsMoveCall(tx, oapp, eid, msgType, extraOptions)
             },
             (result) => new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
         )
@@ -240,15 +202,15 @@ export class OApp {
      * @param msgType - Message type or transaction argument
      * @returns Transaction result containing enforced options
      */
-    async getEnforcedOptionsMoveCall(
+    getEnforcedOptionsMoveCall(
         tx: Transaction,
+        oapp: string | TransactionArgument,
         eid: number | TransactionArgument,
         msgType: number | TransactionArgument
-    ): Promise<TransactionResult> {
-        const oappInfo = await this.#oappInfo()
+    ): TransactionResult {
         return tx.moveCall({
             target: this.#target('get_enforced_options'),
-            arguments: [asObject(tx, oappInfo.oapp_object), asU32(tx, eid), asU16(tx, msgType)],
+            arguments: [asObject(tx, oapp), asU32(tx, eid), asU16(tx, msgType)],
         })
     }
 
@@ -259,11 +221,11 @@ export class OApp {
      * @param msgType - Message type
      * @returns Promise<Uint8Array> - Enforced options as bytes
      */
-    async getEnforcedOptions(eid: number, msgType: number): Promise<Uint8Array> {
+    async getEnforcedOptions(oapp: string, eid: number, msgType: number): Promise<Uint8Array> {
         return executeSimulate(
             this.client,
-            async (tx) => {
-                await this.getEnforcedOptionsMoveCall(tx, eid, msgType)
+            (tx) => {
+                this.getEnforcedOptionsMoveCall(tx, oapp, eid, msgType)
             },
             (result) => new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
         )
@@ -276,11 +238,14 @@ export class OApp {
      * @param dstEid - Destination endpoint ID or transaction argument
      * @returns Transaction result containing boolean result
      */
-    async hasPeerMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult> {
-        const oappInfo = await this.#oappInfo()
+    hasPeerMoveCall(
+        tx: Transaction,
+        oapp: string | TransactionArgument,
+        dstEid: number | TransactionArgument
+    ): TransactionResult {
         return tx.moveCall({
             target: this.#target('has_peer'),
-            arguments: [asObject(tx, oappInfo.oapp_object), asU32(tx, dstEid)],
+            arguments: [asObject(tx, oapp), asU32(tx, dstEid)],
         })
     }
 
@@ -290,11 +255,11 @@ export class OApp {
      * @param dstEid - Destination endpoint ID
      * @returns Promise<boolean> - True if peer is configured, false otherwise
      */
-    async hasPeer(dstEid: number): Promise<boolean> {
+    async hasPeer(oapp: string, dstEid: number): Promise<boolean> {
         return executeSimulate(
             this.client,
-            async (tx) => {
-                await this.hasPeerMoveCall(tx, dstEid)
+            (tx) => {
+                this.hasPeerMoveCall(tx, oapp, dstEid)
             },
             (result) => bcs.Bool.parse(result[0].value)
         )
@@ -307,11 +272,14 @@ export class OApp {
      * @param dstEid - Destination endpoint ID or transaction argument
      * @returns Transaction result containing peer address
      */
-    async getPeerMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult> {
-        const oappInfo = await this.#oappInfo()
+    getPeerMoveCall(
+        tx: Transaction,
+        oapp: string | TransactionArgument,
+        dstEid: number | TransactionArgument
+    ): TransactionResult {
         return tx.moveCall({
             target: this.#target('get_peer'),
-            arguments: [asObject(tx, oappInfo.oapp_object), asU32(tx, dstEid)],
+            arguments: [asObject(tx, oapp), asU32(tx, dstEid)],
         })
     }
 
@@ -321,403 +289,20 @@ export class OApp {
      * @param dstEid - Destination endpoint ID
      * @returns Promise<Uint8Array> - Peer address as bytes32
      */
-    async getPeer(dstEid: number): Promise<Uint8Array> {
-        return executeSimulate(
-            this.client,
-            async (tx) => {
-                await this.getPeerMoveCall(tx, dstEid)
-            },
-            (result) => {
-                return new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
-            }
-        )
-    }
-
-    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> {
+    async getPeer(oapp: string, dstEid: number): Promise<Uint8Array> {
         return executeSimulate(
             this.client,
             (tx) => {
-                this.getOAppInfoV1MoveCall(tx)
+                this.getPeerMoveCall(tx, oapp, dstEid)
             },
             (result) => {
-                return OAppInfoV1Bcs.parse(result[0].value)
+                return new Uint8Array(bcs.vector(bcs.u8()).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