@layerzerolabs/lz-sui-oft-sdk-v2 3.0.136 → 3.0.137

package/src/modules/oft.ts

@@ -19,8 +19,8 @@ import {
 } from '@layerzerolabs/lz-sui-sdk-v2'
 import type { IPTBValidator, MessagingFee, ObjectOptions } from '@layerzerolabs/lz-sui-sdk-v2'
 
-import { parseOFTFeeDetails, parseOFTLimit, parseOFTReceipt } from '../bcs/oft'
-import { OFTFeeDetail, OFTLimit, OFTReceipt, SendParam } from '../types'
+import { parseOFTFeeDetails, parseOFTInfoV1, parseOFTLimit, parseOFTReceipt } from '../bcs/oft'
+import { OFTFeeDetail, OFTInfoV1, OFTLimit, OFTReceipt, SendParam } from '../types'
 
 const MODULE_NAME = 'oft'
 const OFT_SENDER_MODULE_NAME = 'oft_sender'
@@ -56,12 +56,12 @@ export const OFTErrorCode = {
  * @example
  * ```typescript
  * // Initialize OFT instance
- * const oft = new OFT(protocolSDK, oftPackageId, oftObjectId, coinType, oappObjectId, adminCapId);
+ * const oft = new OFT(protocolSDK, oftCallCapId);
  *
  * // Send tokens cross-chain
  * const tx = new Transaction();
  * const coin = await oft.splitCoinMoveCall(tx, sender, amount);
- * await oft.sendMoveCall(tx, sender, coin, sendParam, nativeFee, zroFee, refundAddress, messagingChannel);
+ * await oft.sendMoveCall(tx, sender, sendParam, coin, nativeFee, zroFee, refundAddress);
  * tx.transferObjects([coin], sender);
  * ...
  *
@@ -72,40 +72,45 @@ export const OFTErrorCode = {
 export class OFT {
     /** Sui client for blockchain interactions */
     public readonly client: SuiClient
+    /** The OFTCallCap ID */
+    public readonly oftCallCapId: string
     /** The package ID of the OFT */
-    public oftPackageId: string
+    private oftPackageId?: string
     /** LayerZero protocol object references (endpoint, messaging channels, etc.) */
     private readonly objects: ObjectOptions
     /** The unique object ID of this OFT instance on Sui */
-    private readonly oftObjectId: string
-    /** Admin capability object ID for privileged operations (optional for read-only usage) */
-    private readonly adminCapId?: string
+    private oftObjectId?: string
+    /** Admin capability object ID for privileged operations (retrieved dynamically when needed) */
+    private adminCapId?: string
     /** The Sui coin type this OFT represents (e.g., "0x123::mycoin::MYCOIN") */
-    private readonly coinType: string
+    private coinType?: string
     /** The unique object ID of the associated OApp instance on Sui */
-    private oappObjectId: string
+    private oappObjectId?: string
     /** Reference to the LayerZero protocol SDK for cross-chain operations */
     private readonly protocolSDK: SDK
+    /** The OFTInfoV1 structure */
+    private oftInfo?: OFTInfoV1
 
     /**
      * Creates a new OFT instance for interacting with an Omnichain Fungible Token
      *
      * @param protocolSDK - The LayerZero protocol SDK instance providing core cross-chain functionality
-     * @param oftPackageId - The package ID of the core OFT framework (shared across all OFT implementations)
-     * @param oftObjectId - The unique object ID of this OFT instance
-     * @param coinType - The Sui coin type string (e.g., "0x123::mycoin::MYCOIN")
-     * @param adminCapId - Optional admin capability object ID for privileged operations (required for admin functions)
+     * @param oftCallCapId - The OFT call capability ID used for OFT operations and accessing OFT information
+     * @param oftObjectId - Optional OFT object ID on Sui blockchain for direct OFT instance access
+     * @param coinType - Optional Sui coin type string (e.g., "0x123::mycoin::MYCOIN") that this OFT represents
+     * @param oappObjectId - Optional associated OApp object ID for cross-chain messaging operations
+     * @param adminCapId - Optional admin capability object ID for privileged operations
      */
     constructor(
         protocolSDK: SDK,
-        oftPackageId: string, // the OFT package id
-        oftObjectId: string,
-        coinType: string,
-        oappObjectId: string, // the associated oapp object id
+        oftCallCapId: string,
+        oftObjectId?: string,
+        coinType?: string,
+        oappObjectId?: string, // the associated oapp object id
         adminCapId?: string
     ) {
         this.protocolSDK = protocolSDK
-        this.oftPackageId = oftPackageId
+        this.oftCallCapId = oftCallCapId
         this.client = protocolSDK.client
         this.objects = protocolSDK.objects
         this.oftObjectId = oftObjectId
@@ -131,7 +136,9 @@ export class OFT {
      * Initialize an OFT instance with a treasury capability
      * Creates a new OFT that mints its own tokens
      * @param tx - The transaction to add the move call to
+     * @param coinType - The Sui coin type string (e.g., "0x123::mycoin::MYCOIN")
      * @param ticket - The OFTCreationTicket object ID or TransactionArgument
+     * @param oapp - The OApp object ID or TransactionArgument
      * @param treasury - The TreasuryCap object ID or TransactionArgument for the coin type
      * @param metadata - The CoinMetadata object ID or TransactionArgument for the coin type
      * @param sharedDecimals - Number of decimals to use for cross-chain operations
@@ -139,6 +146,7 @@ export class OFT {
      */
     initOftMoveCall(
         tx: Transaction,
+        coinType: string,
         ticket: string | TransactionArgument,
         oapp: string | TransactionArgument,
         treasury: string | TransactionArgument,
@@ -146,8 +154,8 @@ export class OFT {
         sharedDecimals: number | TransactionArgument
     ): TransactionResult {
         return tx.moveCall({
-            target: this.#target('init_oft', OFT_IMPL_MODULE_NAME),
-            typeArguments: [this.coinType],
+            target: `${this.oftCallCapId}::${OFT_IMPL_MODULE_NAME}::init_oft`,
+            typeArguments: [coinType],
             arguments: [
                 asObject(tx, ticket),
                 asObject(tx, oapp),
@@ -162,21 +170,24 @@ export class OFT {
      * Initialize an OFT adapter instance
      * Creates an OFT adapter that wraps an existing coin type
      * @param tx - The transaction to add the move call to
+     * @param coinType - The Sui coin type string (e.g., "0x123::mycoin::MYCOIN")
      * @param ticket - The OFTCreationTicket object ID or TransactionArgument
+     * @param oapp - The OApp object ID or TransactionArgument
      * @param metadata - The CoinMetadata object ID or TransactionArgument for the coin type
      * @param sharedDecimals - Number of decimals to use for cross-chain operations
      * @returns TransactionResult array containing [AdminCap, MigrationCap] - MigrationCap must be transferred or stored
      */
     initOftAdapterMoveCall(
         tx: Transaction,
+        coinType: string,
         ticket: string | TransactionArgument,
         oapp: string | TransactionArgument,
         metadata: string | TransactionArgument,
         sharedDecimals: number | TransactionArgument
     ): TransactionResult {
         return tx.moveCall({
-            target: this.#target('init_oft_adapter', OFT_IMPL_MODULE_NAME),
-            typeArguments: [this.coinType],
+            target: `${this.oftCallCapId}::${OFT_IMPL_MODULE_NAME}::init_oft_adapter`,
+            typeArguments: [coinType],
             arguments: [asObject(tx, ticket), asObject(tx, oapp), asObject(tx, metadata), asU8(tx, sharedDecimals)],
         })
     }
@@ -185,7 +196,7 @@ export class OFT {
     // ADMIN FUNCTIONS
     // ==========================================
     // These functions require admin privileges and are used for OFT configuration
-    // and management. They require the adminCapId to be provided during construction.
+    // and management. The admin capability is automatically retrieved from the OFT instance.
 
     /**
      * Get LayerZero receive information for OFT registration
@@ -197,12 +208,15 @@ export class OFT {
      * @param composerManager - The composer manager object ID for routing compose transfers
      * @returns TransactionResult containing serialized execution metadata for endpoint registration
      */
-    lzReceiveInfoMoveCall(tx: Transaction, composerManager: string | TransactionArgument): TransactionResult {
+    async lzReceiveInfoMoveCall(
+        tx: Transaction,
+        composerManager: string | TransactionArgument
+    ): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('lz_receive_info', OFT_PTB_BUILDER_MODULE_NAME),
-            typeArguments: [this.coinType],
+            target: await this.#target('lz_receive_info', OFT_PTB_BUILDER_MODULE_NAME),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
+                tx.object(await this.#oftObjectId()),
                 tx.object(this.objects.endpointV2),
                 asObject(tx, composerManager),
                 tx.object.clock(),
@@ -213,17 +227,52 @@ export class OFT {
     /**
      * Register OFT as an OApp with LayerZero endpoint
      * @param tx - The transaction to add the move call to
-     * @param lzReceiveInfo - PTB Builder lzReceiveInfoMoveCall result, used for protocol SDK to dynamically build the PTB
-     * for OFT's lzReceive operation
+     * @param coinType - The Sui coin type string (e.g., "0x123::mycoin::MYCOIN")
+     * @param oftObjectId - The OFT object ID
+     * @param oappObjectId - The OApp object ID
+     * @param composerManager - The composer manager object ID or TransactionArgument
+     * @param lzReceiveInfo - Optional LayerZero receive info as Uint8Array or TransactionArgument
      */
-    registerOAppMoveCall(tx: Transaction, lzReceiveInfo: Uint8Array | TransactionArgument): void {
+    async registerOAppMoveCall(
+        tx: Transaction,
+        coinType: string,
+        oftObjectId: string,
+        oappObjectId: string,
+        composerManager: string | TransactionArgument,
+        lzReceiveInfo?: Uint8Array | TransactionArgument
+    ): Promise<void> {
+        const adminCapId = await executeSimulate(
+            this.client,
+            (tx) => {
+                tx.moveCall({
+                    target: `${this.oftCallCapId}::${MODULE_NAME}::admin_cap`,
+                    typeArguments: [coinType],
+                    arguments: [tx.object(oftObjectId)],
+                })
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+
+        if (lzReceiveInfo === undefined) {
+            lzReceiveInfo = tx.moveCall({
+                target: `${this.oftCallCapId}::${OFT_PTB_BUILDER_MODULE_NAME}::lz_receive_info`,
+                typeArguments: [coinType],
+                arguments: [
+                    tx.object(oftObjectId),
+                    tx.object(this.objects.endpointV2),
+                    asObject(tx, composerManager),
+                    tx.object.clock(),
+                ],
+            })
+        }
+
         tx.moveCall({
-            target: this.#target('register_oapp'),
-            typeArguments: [this.coinType],
+            target: `${this.oftCallCapId}::${MODULE_NAME}::register_oapp`,
+            typeArguments: [coinType],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#oappObjectId()),
-                tx.object(this.#adminCapId()),
+                tx.object(oftObjectId),
+                tx.object(oappObjectId),
+                tx.object(adminCapId),
                 tx.object(this.objects.endpointV2),
                 asBytes(tx, lzReceiveInfo),
             ],
@@ -235,11 +284,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @param pause - Whether to pause or unpause operations
      */
-    setPauseMoveCall(tx: Transaction, pause: boolean | TransactionArgument): void {
+    async setPauseMoveCall(tx: Transaction, pause: boolean | TransactionArgument): Promise<void> {
         tx.moveCall({
-            target: this.#target('set_pause'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), tx.object(this.#adminCapId()), asBool(tx, pause)],
+            target: await this.#target('set_pause'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), tx.object(await this.#adminCapId()), asBool(tx, pause)],
         })
     }
 
@@ -253,19 +302,34 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @param feeDepositAddress - The new fee deposit address
      */
-    setFeeDepositAddressMoveCall(tx: Transaction, feeDepositAddress: string | TransactionArgument): void {
+    async setFeeDepositAddressMoveCall(
+        tx: Transaction,
+        feeDepositAddress: string | TransactionArgument
+    ): Promise<void> {
         tx.moveCall({
-            target: this.#target('set_fee_deposit_address'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), tx.object(this.#adminCapId()), asAddress(tx, feeDepositAddress)],
+            target: await this.#target('set_fee_deposit_address'),
+            typeArguments: [await this.#coinType()],
+            arguments: [
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#adminCapId()),
+                asAddress(tx, feeDepositAddress),
+            ],
         })
     }
 
-    setDefaultFeeBpsMoveCall(tx: Transaction, feeBps: bigint | number | string | TransactionArgument): void {
+    /**
+     * Set default fee basis points for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param feeBps - Default fee rate in basis points (0-10,000, where 10,000 = 100%)
+     */
+    async setDefaultFeeBpsMoveCall(
+        tx: Transaction,
+        feeBps: bigint | number | string | TransactionArgument
+    ): Promise<void> {
         tx.moveCall({
-            target: this.#target('set_default_fee_bps'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), tx.object(this.#adminCapId()), asU64(tx, feeBps)],
+            target: await this.#target('set_default_fee_bps'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), tx.object(await this.#adminCapId()), asU64(tx, feeBps)],
         })
     }
 
@@ -275,17 +339,17 @@ export class OFT {
      * @param dstEid - Destination endpoint ID
      * @param feeBps - Fee rate in basis points (0-10,000, where 10,000 = 100%)
      */
-    setFeeBpsMoveCall(
+    async setFeeBpsMoveCall(
         tx: Transaction,
         dstEid: number | TransactionArgument,
         feeBps: bigint | number | string | TransactionArgument
-    ): void {
+    ): Promise<void> {
         tx.moveCall({
-            target: this.#target('set_fee_bps'),
-            typeArguments: [this.coinType],
+            target: await this.#target('set_fee_bps'),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#adminCapId()),
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#adminCapId()),
                 asU32(tx, dstEid),
                 asU64(tx, feeBps),
             ],
@@ -297,11 +361,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @param dstEid - Destination endpoint ID
      */
-    unsetFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): void {
+    async unsetFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<void> {
         tx.moveCall({
-            target: this.#target('unset_fee_bps'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), tx.object(this.#adminCapId()), asU32(tx, dstEid)],
+            target: await this.#target('unset_fee_bps'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), tx.object(await this.#adminCapId()), asU32(tx, dstEid)],
         })
     }
 
@@ -316,11 +380,11 @@ export class OFT {
      * @param migrationCap - Migration capability object ID or transaction argument
      * @returns TransactionResult containing the migration ticket
      */
-    migrateMoveCall(tx: Transaction, migrationCap: string | TransactionArgument): TransactionResult {
+    async migrateMoveCall(tx: Transaction, migrationCap: string | TransactionArgument): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('migrate'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asObject(tx, migrationCap)],
+            target: await this.#target('migrate'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), asObject(tx, migrationCap)],
         })
     }
 
@@ -337,19 +401,19 @@ export class OFT {
      * @param rateLimit - Rate limit amount
      * @param windowSeconds - Time window in seconds
      */
-    setRateLimitMoveCall(
+    async setRateLimitMoveCall(
         tx: Transaction,
         eid: number | TransactionArgument,
         inbound: boolean | TransactionArgument,
         rateLimit: bigint | number | string | TransactionArgument,
         windowSeconds: bigint | number | string | TransactionArgument
-    ): void {
+    ): Promise<void> {
         tx.moveCall({
-            target: this.#target('set_rate_limit'),
-            typeArguments: [this.coinType],
+            target: await this.#target('set_rate_limit'),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#adminCapId()),
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#adminCapId()),
                 asU32(tx, eid),
                 asBool(tx, inbound),
                 asU64(tx, rateLimit),
@@ -365,17 +429,17 @@ export class OFT {
      * @param eid - Endpoint ID
      * @param inbound - Whether this is for inbound or outbound transfers
      */
-    unsetRateLimitMoveCall(
+    async unsetRateLimitMoveCall(
         tx: Transaction,
         eid: number | TransactionArgument,
         inbound: boolean | TransactionArgument
-    ): void {
+    ): Promise<void> {
         tx.moveCall({
-            target: this.#target('unset_rate_limit'),
-            typeArguments: [this.coinType],
+            target: await this.#target('unset_rate_limit'),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#adminCapId()),
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#adminCapId()),
                 asU32(tx, eid),
                 asBool(tx, inbound),
             ],
@@ -404,7 +468,7 @@ export class OFT {
         limit = 200,
         pageSize = 50
     ): Promise<TransactionResult> {
-        return this.protocolSDK.getUtils().splitCoinMoveCall(tx, this.coinType, owner, amount, limit, pageSize)
+        return this.protocolSDK.getUtils().splitCoinMoveCall(tx, await this.#coinType(), owner, amount, limit, pageSize)
     }
 
     /**
@@ -416,7 +480,9 @@ export class OFT {
      * @param nativeFee - Native token fee amount
      * @param zroFee - ZRO token fee amount
      * @param refundAddress - Address for fee refunds
-     * @returns Promise<TransactionResult> - Transaction result containing send operation and receipt objects
+     * @param validators - Optional PTB validators for transaction validation
+     * @param maxSimulationTimes - Optional maximum number of simulation attempts
+     * @returns Promise<void> - Completes when the send operation is processed
      */
     async sendMoveCall(
         tx: Transaction,
@@ -429,19 +495,19 @@ export class OFT {
         validators?: IPTBValidator[],
         maxSimulationTimes?: number
     ): Promise<void> {
-        const sendParamArg = isTransactionArgument(sendParam) ? sendParam : this.#buildSendParam(tx, sendParam)
-        const txSender = this.txSenderMoveCall(tx)
+        const sendParamArg = isTransactionArgument(sendParam) ? sendParam : await this.#buildSendParam(tx, sendParam)
+        const txSender = await this.txSenderMoveCall(tx)
         const addressArg = isTransactionArgument(refundAddress)
             ? refundAddress
             : tx.pure.option('address', refundAddress)
 
         // The oft::send returns a tuple (Call<EndpointSendParam, MessagingReceipt>, OFTReceipt)
         const transactionResult = tx.moveCall({
-            target: this.#target('send'),
-            typeArguments: [this.coinType],
+            target: await this.#target('send'),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#oappObjectId()),
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#oappObjectId()),
                 txSender,
                 sendParamArg,
                 asObject(tx, coinProvided),
@@ -467,11 +533,11 @@ export class OFT {
             )
 
         const confirmSendResult = tx.moveCall({
-            target: this.#target('confirm_send'),
-            typeArguments: [this.coinType],
+            target: await this.#target('confirm_send'),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#oappObjectId()),
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#oappObjectId()),
                 txSender,
                 endpointCall,
                 oftSendContext,
@@ -498,13 +564,13 @@ export class OFT {
      * @param call - LayerZero receive call containing the verified cross-chain message
      * @returns TransactionResult containing the processed transfer
      */
-    lzReceiveMoveCall(tx: Transaction, call: string | TransactionArgument): TransactionResult {
+    async lzReceiveMoveCall(tx: Transaction, call: string | TransactionArgument): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('lz_receive'),
-            typeArguments: [this.coinType],
+            target: await this.#target('lz_receive'),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#oappObjectId()),
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#oappObjectId()),
                 asObject(tx, call),
                 tx.object.clock(),
             ],
@@ -519,18 +585,18 @@ export class OFT {
      * @param call - LayerZero receive call containing the verified cross-chain message
      * @returns TransactionResult containing the processed transfer
      */
-    lzReceiveWithComposeMoveCall(
+    async lzReceiveWithComposeMoveCall(
         tx: Transaction,
         composeQueue: string | TransactionArgument,
         composerManager: string | TransactionArgument,
         call: string | TransactionArgument
-    ): TransactionResult {
+    ): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('lz_receive_with_compose'),
-            typeArguments: [this.coinType],
+            target: await this.#target('lz_receive_with_compose'),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#oappObjectId()),
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#oappObjectId()),
                 asObject(tx, composeQueue),
                 asObject(tx, composerManager),
                 asObject(tx, call),
@@ -545,11 +611,15 @@ export class OFT {
      * @param call - Completed Call object from quote_send() execution
      * @returns TransactionResult containing the messaging fee
      */
-    confirmQuoteSendMoveCall(tx: Transaction, call: string | TransactionArgument): TransactionResult {
+    async confirmQuoteSendMoveCall(tx: Transaction, call: string | TransactionArgument): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('confirm_quote_send'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), tx.object(this.#oappObjectId()), asObject(tx, call)],
+            target: await this.#target('confirm_quote_send'),
+            typeArguments: [await this.#coinType()],
+            arguments: [
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#oappObjectId()),
+                asObject(tx, call),
+            ],
         })
     }
 
@@ -568,12 +638,14 @@ export class OFT {
     ): Promise<{ limit: OFTLimit; feeDetails: OFTFeeDetail[]; receipt: OFTReceipt }> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                const sendParamArg = isTransactionArgument(sendParam) ? sendParam : this.#buildSendParam(tx, sendParam)
+            async (tx) => {
+                const sendParamArg = isTransactionArgument(sendParam)
+                    ? sendParam
+                    : await this.#buildSendParam(tx, sendParam)
                 tx.moveCall({
-                    target: this.#target('quote_oft'),
-                    typeArguments: [this.coinType],
-                    arguments: [tx.object(this.oftObjectId), sendParamArg, tx.object.clock()],
+                    target: await this.#target('quote_oft'),
+                    typeArguments: [await this.#coinType()],
+                    arguments: [tx.object(await this.#oftObjectId()), sendParamArg, tx.object.clock()],
                 })
             },
             (result) => {
@@ -591,6 +663,8 @@ export class OFT {
      * @param sender - Sender address
      * @param sendParam - Send parameters for the OFT operation
      * @param payInZro - Whether to pay in ZRO tokens
+     * @param validators - Optional PTB validators for transaction validation
+     * @param maxSimulationTimes - Optional maximum number of simulation attempts
      * @returns Promise<MessagingFee> - The calculated messaging fees
      */
     async quoteSend(
@@ -601,14 +675,14 @@ export class OFT {
         maxSimulationTimes?: number
     ): Promise<MessagingFee> {
         const tx = new Transaction()
-        const sendParamArg = isTransactionArgument(sendParam) ? sendParam : this.#buildSendParam(tx, sendParam)
+        const sendParamArg = isTransactionArgument(sendParam) ? sendParam : await this.#buildSendParam(tx, sendParam)
 
         const quoteCall = tx.moveCall({
-            target: this.#target('quote_send'),
-            typeArguments: [this.coinType],
+            target: await this.#target('quote_send'),
+            typeArguments: [await this.#coinType()],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#oappObjectId()),
+                tx.object(await this.#oftObjectId()),
+                tx.object(await this.#oappObjectId()),
                 asAddress(tx, sender),
                 sendParamArg,
                 asBool(tx, payInZro),
@@ -628,11 +702,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the upgrade version
      */
-    upgradeVersionMoveCall(tx: Transaction): TransactionResult {
+    async upgradeVersionMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('upgrade_version'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('upgrade_version'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -643,8 +717,8 @@ export class OFT {
     async upgradeVersion(): Promise<bigint> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.upgradeVersionMoveCall(tx)
+            async (tx) => {
+                await this.upgradeVersionMoveCall(tx)
             },
             (result) => BigInt(bcs.U64.parse(result[0].value))
         )
@@ -655,11 +729,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the OApp object address
      */
-    oappObjectMoveCall(tx: Transaction): TransactionResult {
+    async oappObjectMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('oapp_object'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('oapp_object'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -670,8 +744,8 @@ export class OFT {
     async oappObject(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.oappObjectMoveCall(tx)
+            async (tx) => {
+                await this.oappObjectMoveCall(tx)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -682,11 +756,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing version information
      */
-    oftVersionMoveCall(tx: Transaction): TransactionResult {
+    async oftVersionMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('oft_version'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('oft_version'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -697,8 +771,8 @@ export class OFT {
     async oftVersion(): Promise<{ major: number; minor: number }> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.oftVersionMoveCall(tx)
+            async (tx) => {
+                await this.oftVersionMoveCall(tx)
             },
             (result) => {
                 const major = Number(bcs.U64.parse(result[0].value))
@@ -708,18 +782,29 @@ export class OFT {
         )
     }
 
-    oftCapIdMoveCall(tx: Transaction): TransactionResult {
+    /**
+     * Get the OFT capability ID
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the OFT capability ID
+     */
+    async oftCapIdMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('oft_cap_id'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('oft_cap_id'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
+    /**
+     * Get the OFT capability ID
+     * @returns Promise<string> - The OFT capability ID
+     */
     async oftCapId(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => this.oftCapIdMoveCall(tx),
+            async (tx) => {
+                await this.oftCapIdMoveCall(tx)
+            },
             (result) => bcs.Address.parse(result[0].value)
         )
     }
@@ -729,11 +814,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the migration capability address
      */
-    migrationCapMoveCall(tx: Transaction): TransactionResult {
+    async migrationCapMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('migration_cap'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('migration_cap'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -744,8 +829,8 @@ export class OFT {
     async migrationCap(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.migrationCapMoveCall(tx)
+            async (tx) => {
+                await this.migrationCapMoveCall(tx)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -754,8 +839,8 @@ export class OFT {
     async messagingChannel(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                const oftCapId = this.oftCapIdMoveCall(tx)
+            async (tx) => {
+                const oftCapId = await this.oftCapIdMoveCall(tx)
                 this.protocolSDK.getEndpoint().getMessagingChannelMoveCall(tx, oftCapId)
             },
             (result) => bcs.Address.parse(result[0].value)
@@ -767,11 +852,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing coin metadata address
      */
-    coinMetadataMoveCall(tx: Transaction): TransactionResult {
+    async coinMetadataMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('coin_metadata'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('coin_metadata'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -782,8 +867,8 @@ export class OFT {
     async coinMetadata(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.coinMetadataMoveCall(tx)
+            async (tx) => {
+                await this.coinMetadataMoveCall(tx)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -794,11 +879,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the admin capability address
      */
-    adminCapMoveCall(tx: Transaction): TransactionResult {
+    async adminCapMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('admin_cap'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('admin_cap'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -809,8 +894,8 @@ export class OFT {
     async adminCap(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.adminCapMoveCall(tx)
+            async (tx) => {
+                await this.adminCapMoveCall(tx)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -821,11 +906,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing shared decimals
      */
-    sharedDecimalsMoveCall(tx: Transaction): TransactionResult {
+    async sharedDecimalsMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('shared_decimals'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('shared_decimals'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -836,8 +921,8 @@ export class OFT {
     async sharedDecimals(): Promise<number> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.sharedDecimalsMoveCall(tx)
+            async (tx) => {
+                await this.sharedDecimalsMoveCall(tx)
             },
             (result) => bcs.U8.parse(result[0].value)
         )
@@ -848,11 +933,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the decimal conversion rate
      */
-    decimalConversionRateMoveCall(tx: Transaction): TransactionResult {
+    async decimalConversionRateMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('decimal_conversion_rate'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('decimal_conversion_rate'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -863,8 +948,8 @@ export class OFT {
     async decimalConversionRate(): Promise<bigint> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.decimalConversionRateMoveCall(tx)
+            async (tx) => {
+                await this.decimalConversionRateMoveCall(tx)
             },
             (result) => BigInt(bcs.U64.parse(result[0].value))
         )
@@ -875,11 +960,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the paused status
      */
-    isPausedMoveCall(tx: Transaction): TransactionResult {
+    async isPausedMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('is_paused'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('is_paused'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -890,8 +975,8 @@ export class OFT {
     async isPaused(): Promise<boolean> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.isPausedMoveCall(tx)
+            async (tx) => {
+                await this.isPausedMoveCall(tx)
             },
             (result) => bcs.Bool.parse(result[0].value)
         )
@@ -902,11 +987,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the adapter status
      */
-    isAdapterMoveCall(tx: Transaction): TransactionResult {
+    async isAdapterMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('is_adapter'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('is_adapter'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -917,13 +1002,41 @@ export class OFT {
     async isAdapter(): Promise<boolean> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.isAdapterMoveCall(tx)
+            async (tx) => {
+                await this.isAdapterMoveCall(tx)
             },
             (result) => bcs.Bool.parse(result[0].value)
         )
     }
 
+    /**
+     * Decode OFTInfoV1 from encoded bytes
+     * @param tx - The transaction to add the move call to
+     * @param encodedBytes - The encoded OFTInfoV1 bytes to decode
+     * @returns Transaction result containing the decoded OFTInfoV1
+     */
+    decodeOftInfoV1MoveCall(tx: Transaction, encodedBytes: Uint8Array | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: `${this.oftCallCapId}::oft_info_v1::decode`,
+            arguments: [asBytes(tx, encodedBytes)],
+        })
+    }
+
+    /**
+     * Decode OFTInfoV1 from encoded bytes
+     * @param encodedBytes - The encoded OFTInfoV1 bytes to decode
+     * @returns Promise<OFTInfoV1> - The decoded OFTInfoV1 structure
+     */
+    async decodeOftInfoV1(encodedBytes: Uint8Array): Promise<OFTInfoV1> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.decodeOftInfoV1MoveCall(tx, encodedBytes)
+            },
+            (result) => parseOFTInfoV1(result[0].value)
+        )
+    }
+
     // ==========================================
     // FEE VIEW FUNCTIONS
     // ==========================================
@@ -935,11 +1048,11 @@ export class OFT {
      * @param dstEid - Destination endpoint ID
      * @returns Transaction result containing whether fee exists
      */
-    hasOftFeeMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult {
+    async hasOftFeeMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('has_oft_fee'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, dstEid)],
+            target: await this.#target('has_oft_fee'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), asU32(tx, dstEid)],
         })
     }
 
@@ -951,8 +1064,8 @@ export class OFT {
     async hasOftFee(dstEid: number): Promise<boolean> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.hasOftFeeMoveCall(tx, dstEid)
+            async (tx) => {
+                await this.hasOftFeeMoveCall(tx, dstEid)
             },
             (result) => bcs.Bool.parse(result[0].value)
         )
@@ -964,11 +1077,11 @@ export class OFT {
      * @param dstEid - Destination endpoint ID
      * @returns Transaction result containing the effective fee basis points
      */
-    effectiveFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult {
+    async effectiveFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('effective_fee_bps'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, dstEid)],
+            target: await this.#target('effective_fee_bps'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), asU32(tx, dstEid)],
         })
     }
 
@@ -980,8 +1093,8 @@ export class OFT {
     async effectiveFeeBps(dstEid: number): Promise<bigint> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.effectiveFeeBpsMoveCall(tx, dstEid)
+            async (tx) => {
+                await this.effectiveFeeBpsMoveCall(tx, dstEid)
             },
             (result) => BigInt(bcs.U64.parse(result[0].value))
         )
@@ -992,11 +1105,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the default fee basis points
      */
-    defaultFeeBpsMoveCall(tx: Transaction): TransactionResult {
+    async defaultFeeBpsMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('default_fee_bps'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('default_fee_bps'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -1007,8 +1120,8 @@ export class OFT {
     async defaultFeeBps(): Promise<bigint> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.defaultFeeBpsMoveCall(tx)
+            async (tx) => {
+                await this.defaultFeeBpsMoveCall(tx)
             },
             (result) => BigInt(bcs.U64.parse(result[0].value))
         )
@@ -1020,11 +1133,11 @@ export class OFT {
      * @param dstEid - Destination endpoint ID
      * @returns Transaction result containing the fee basis points
      */
-    feeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult {
+    async feeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('fee_bps'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, dstEid)],
+            target: await this.#target('fee_bps'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), asU32(tx, dstEid)],
         })
     }
 
@@ -1036,8 +1149,8 @@ export class OFT {
     async feeBps(dstEid: number): Promise<bigint> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.feeBpsMoveCall(tx, dstEid)
+            async (tx) => {
+                await this.feeBpsMoveCall(tx, dstEid)
             },
             (result) => BigInt(bcs.U64.parse(result[0].value))
         )
@@ -1048,11 +1161,11 @@ export class OFT {
      * @param tx - The transaction to add the move call to
      * @returns Transaction result containing the fee deposit address
      */
-    feeDepositAddressMoveCall(tx: Transaction): TransactionResult {
+    async feeDepositAddressMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('fee_deposit_address'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            target: await this.#target('fee_deposit_address'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId())],
         })
     }
 
@@ -1063,8 +1176,8 @@ export class OFT {
     async feeDepositAddress(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.feeDepositAddressMoveCall(tx)
+            async (tx) => {
+                await this.feeDepositAddressMoveCall(tx)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -1082,15 +1195,15 @@ export class OFT {
      * @param inbound - Whether this is for inbound or outbound transfers
      * @returns Transaction result containing rate limit configuration
      */
-    rateLimitConfigMoveCall(
+    async rateLimitConfigMoveCall(
         tx: Transaction,
         eid: number | TransactionArgument,
         inbound: boolean | TransactionArgument
-    ): TransactionResult {
+    ): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('rate_limit_config'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, eid), asBool(tx, inbound)],
+            target: await this.#target('rate_limit_config'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), asU32(tx, eid), asBool(tx, inbound)],
         })
     }
 
@@ -1103,8 +1216,8 @@ export class OFT {
     async rateLimitConfig(eid: number, inbound: boolean): Promise<{ limit: bigint; windowSeconds: bigint }> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.rateLimitConfigMoveCall(tx, eid, inbound)
+            async (tx) => {
+                await this.rateLimitConfigMoveCall(tx, eid, inbound)
             },
             (result) => {
                 const limit = BigInt(bcs.U64.parse(result[0].value))
@@ -1121,15 +1234,15 @@ export class OFT {
      * @param inbound - Whether this is for inbound or outbound transfers
      * @returns Transaction result containing in-flight amount
      */
-    rateLimitInFlightMoveCall(
+    async rateLimitInFlightMoveCall(
         tx: Transaction,
         eid: number | TransactionArgument,
         inbound: boolean | TransactionArgument
-    ): TransactionResult {
+    ): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('rate_limit_in_flight'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, eid), asBool(tx, inbound), tx.object.clock()],
+            target: await this.#target('rate_limit_in_flight'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), asU32(tx, eid), asBool(tx, inbound), tx.object.clock()],
         })
     }
 
@@ -1142,8 +1255,8 @@ export class OFT {
     async rateLimitInFlight(eid: number, inbound: boolean): Promise<bigint> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.rateLimitInFlightMoveCall(tx, eid, inbound)
+            async (tx) => {
+                await this.rateLimitInFlightMoveCall(tx, eid, inbound)
             },
             (result) => BigInt(bcs.U64.parse(result[0].value))
         )
@@ -1156,15 +1269,15 @@ export class OFT {
      * @param inbound - Whether this is for inbound or outbound transfers
      * @returns Transaction result containing rate limit capacity
      */
-    rateLimitCapacityMoveCall(
+    async rateLimitCapacityMoveCall(
         tx: Transaction,
         eid: number | TransactionArgument,
         inbound: boolean | TransactionArgument
-    ): TransactionResult {
+    ): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('rate_limit_capacity'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, eid), asBool(tx, inbound), tx.object.clock()],
+            target: await this.#target('rate_limit_capacity'),
+            typeArguments: [await this.#coinType()],
+            arguments: [tx.object(await this.#oftObjectId()), asU32(tx, eid), asBool(tx, inbound), tx.object.clock()],
         })
     }
 
@@ -1177,8 +1290,8 @@ export class OFT {
     async rateLimitCapacity(eid: number, inbound: boolean): Promise<bigint> {
         return executeSimulate(
             this.client,
-            (tx) => {
-                this.rateLimitCapacityMoveCall(tx, eid, inbound)
+            async (tx) => {
+                await this.rateLimitCapacityMoveCall(tx, eid, inbound)
             },
             (result) => BigInt(bcs.U64.parse(result[0].value))
         )
@@ -1188,9 +1301,14 @@ export class OFT {
     // OFT SENDER
     // ==========================================
 
-    txSenderMoveCall(tx: Transaction): TransactionResult {
+    /**
+     * Create a transaction sender object for OFT operations
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the transaction sender object
+     */
+    async txSenderMoveCall(tx: Transaction): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('tx_sender', OFT_SENDER_MODULE_NAME),
+            target: await this.#target('tx_sender', OFT_SENDER_MODULE_NAME),
         })
     }
 
@@ -1206,9 +1324,9 @@ export class OFT {
      * @returns Transaction result containing the SendParam struct
      * @private
      */
-    #buildSendParam(tx: Transaction, param: SendParam): TransactionResult {
+    async #buildSendParam(tx: Transaction, param: SendParam): Promise<TransactionResult> {
         return tx.moveCall({
-            target: this.#target('create', 'send_param'),
+            target: await this.#target('create', 'send_param'),
             arguments: [
                 asU32(tx, param.dstEid),
                 asBytes32(tx, param.to, this.protocolSDK.getUtils()),
@@ -1228,8 +1346,8 @@ export class OFT {
      * @returns The full module path for the move call
      * @private
      */
-    #target(name: string, module_name = MODULE_NAME): string {
-        return `${this.oftPackageId}::${module_name}::${name}`
+    async #target(name: string, module_name = MODULE_NAME): Promise<string> {
+        return `${await this.#oftPackageId()}::${module_name}::${name}`
     }
 
     /**
@@ -1238,23 +1356,109 @@ export class OFT {
      * @throws Error if OApp object ID was not set
      * @private
      */
-    #oappObjectId(): string {
-        if (this.oappObjectId === '') {
-            throw new Error('OApp object ID not found')
+    async #oappObjectId(): Promise<string> {
+        if (this.oappObjectId === undefined) {
+            const oappSdk = this.protocolSDK.getOApp(this.oftCallCapId)
+            const oappInfo = await oappSdk.getOAppInfoV1()
+            this.oappObjectId = oappInfo.oapp_object
         }
         return this.oappObjectId
     }
 
     /**
-     * Get the admin capability ID, throwing an error if not available
+     * Get the OFT object ID, automatically retrieving it from the OFT info if not cached
+     * @returns The OFT object ID
+     * @throws Error if OFT object ID cannot be retrieved
+     * @private
+     */
+    async #oftObjectId(): Promise<string> {
+        if (this.oftObjectId === undefined) {
+            const oftInfo = await this.#OftInfo()
+            this.oftObjectId = oftInfo.oftObject
+        }
+        return this.oftObjectId
+    }
+
+    /**
+     * Get the admin capability ID, automatically retrieving it from the OFT instance if not cached
      * @returns The admin capability ID
-     * @throws Error if admin capability ID was not provided during construction
+     * @throws Error if admin capability cannot be retrieved from the OFT instance
      * @private
      */
-    #adminCapId(): string {
+    async #adminCapId(): Promise<string> {
         if (this.adminCapId === undefined) {
-            throw new Error('Admin cap ID not found')
+            this.adminCapId = await this.adminCap()
         }
         return this.adminCapId
     }
+
+    /**
+     * Get the coin type, automatically extracting it from the OFT object if not cached
+     * @returns The coin type string (e.g., "0x123::mycoin::MYCOIN")
+     * @throws Error if coin type cannot be extracted from the OFT object
+     * @private
+     */
+    async #coinType(): Promise<string> {
+        if (this.coinType === undefined) {
+            const oftInfo = await this.client.getObject({
+                id: await this.#oftObjectId(),
+                options: {
+                    showContent: true,
+                },
+            })
+
+            const content = oftInfo.data?.content as { type?: string; dataType?: string } | undefined
+            if (content?.dataType !== 'moveObject' || content.type == null || content.type.length === 0) {
+                throw new Error('Invalid OFT object data or missing type field')
+            }
+
+            // Extract the coin type from the first pair of angle brackets, e.g.:
+            // "0xdd39db3a038c70a71fbffedf6b32a50383ace0b5f219a617238bd2fbee1995b0::oft::OFT<0x428907130f475ef50f76c8944d5960772e135e4d64bcb019e181030377049215::test_coin::TEST_COIN>"
+            const typeStr = content.type
+            // Match the first angle-bracketed substring
+            const angleBracketMatch = typeStr.match(/<([^>]+)>/)
+            const coinType = angleBracketMatch?.[1]
+            if (coinType === undefined || coinType === '') {
+                throw new Error('Failed to extract coinType from object type')
+            }
+            this.coinType = coinType
+        }
+        return this.coinType
+    }
+
+    /**
+     * Get OApp info, throwing if not set
+     * @returns The OApp info
+     * @throws Error if OApp info is not set
+     * @private
+     */
+    async #OftInfo(): Promise<OFTInfoV1> {
+        if (!this.oftInfo) {
+            const oappSdk = this.protocolSDK.getOApp(this.oftCallCapId)
+            this.oftInfo = await executeSimulate(
+                this.client,
+                (tx) => {
+                    const oappInfo = oappSdk.getOAppInfoV1MoveCall(tx)
+                    const extraInfo = oappSdk.getOAppInfoV1ExtraInfoMoveCall(tx, oappInfo)
+                    this.decodeOftInfoV1MoveCall(tx, extraInfo)
+                },
+                (result) => parseOFTInfoV1(result[0].value)
+            )
+        }
+        return this.oftInfo
+    }
+
+    /**
+     * Get the OFT package ID, automatically retrieving it from the OFT info if not cached
+     * @returns The OFT package ID
+     * @throws Error if OFT package ID cannot be retrieved
+     * @private
+     */
+    async #oftPackageId(): Promise<string> {
+        if (this.oftPackageId === undefined) {
+            const oftInfo = await this.#OftInfo()
+            this.oftPackageId = oftInfo.oftPackage
+        }
+        return this.oftPackageId
+    }
 }