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

package/src/modules/oft.ts

@@ -11,9 +11,9 @@ import {
     asBytes,
     asBytes32,
     asObject,
-    asU16,
     asU32,
     asU64,
+    asU8,
     executeSimulate,
     isTransactionArgument,
 } from '@layerzerolabs/lz-sui-sdk-v2'
@@ -24,6 +24,8 @@ import { OFTFeeDetail, OFTLimit, OFTReceipt, SendParam } from '../types'
 
 const MODULE_NAME = 'oft'
 const OFT_SENDER_MODULE_NAME = 'oft_sender'
+const OFT_IMPL_MODULE_NAME = 'oft_impl'
+const OFT_PTB_BUILDER_MODULE_NAME = 'oft_ptb_builder'
 
 // ==========================================
 // ERROR CODES
@@ -32,14 +34,16 @@ const OFT_SENDER_MODULE_NAME = 'oft_sender'
 
 export const OFTErrorCode = {
     // OFT related errors
-    OFT_EComposeMsgNotAllowed: 1,
-    OFT_EComposeMsgRequired: 2,
-    OFT_EInvalidComposeQueue: 3,
-    OFT_EInvalidLocalDecimals: 4,
-    OFT_EPaused: 5,
-    OFT_EPauseUnchanged: 6,
-    OFT_ESlippageExceeded: 7,
-    OFT_EInsufficientBalance: 8,
+    EComposeMsgNotAllowed: 1,
+    EComposeMsgRequired: 2,
+    EInsufficientBalance: 3,
+    EInvalidAdminCap: 4,
+    EInvalidComposeQueue: 5,
+    EInvalidLocalDecimals: 6,
+    EInvalidMigrationCap: 7,
+    EInvalidSendContext: 8,
+    ESlippageExceeded: 9,
+    EWrongPackageVersion: 10,
 } as const
 
 /**
@@ -52,7 +56,7 @@ export const OFTErrorCode = {
  * @example
  * ```typescript
  * // Initialize OFT instance
- * const oft = new OFT(protocolSDK, corePackageId, packageId, oftObjectId, coinType, adminCapId);
+ * const oft = new OFT(protocolSDK, oftPackageId, oftObjectId, coinType, oappObjectId, adminCapId);
  *
  * // Send tokens cross-chain
  * const tx = new Transaction();
@@ -68,7 +72,7 @@ export const OFTErrorCode = {
 export class OFT {
     /** Sui client for blockchain interactions */
     public readonly client: SuiClient
-    /** The package ID of the core OFT framework (shared OFT functionality) */
+    /** The package ID of the OFT */
     public oftPackageId: string
     /** LayerZero protocol object references (endpoint, messaging channels, etc.) */
     private readonly objects: ObjectOptions
@@ -78,6 +82,8 @@ export class OFT {
     private readonly adminCapId?: string
     /** The Sui coin type this OFT represents (e.g., "0x123::mycoin::MYCOIN") */
     private readonly coinType: string
+    /** The unique object ID of the associated OApp instance on Sui */
+    private oappObjectId: string
     /** Reference to the LayerZero protocol SDK for cross-chain operations */
     private readonly protocolSDK: SDK
 
@@ -95,6 +101,7 @@ export class OFT {
         oftPackageId: string, // the OFT package id
         oftObjectId: string,
         coinType: string,
+        oappObjectId: string, // the associated oapp object id
         adminCapId?: string
     ) {
         this.protocolSDK = protocolSDK
@@ -102,102 +109,123 @@ export class OFT {
         this.client = protocolSDK.client
         this.objects = protocolSDK.objects
         this.oftObjectId = oftObjectId
+        this.oappObjectId = oappObjectId
         this.adminCapId = adminCapId
         this.coinType = coinType
     }
 
+    /**
+     * Updates the associated OApp object ID
+     * @param oappObjectId - The new OApp object ID
+     */
+    setOappObjectId(oappObjectId: string): void {
+        this.oappObjectId = oappObjectId
+    }
+
     // ==========================================
-    // ADMIN FUNCTIONS
+    // INITIALIZATION FUNCTIONS
     // ==========================================
-    // These functions require admin privileges and are used for OFT configuration
-    // and management. They require the adminCapId to be provided during construction.
+    // These functions are used to initialize OFT instances from OFTCreationTicket
 
     /**
-     * Register OFT as an OApp with LayerZero endpoint
+     * 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 lzReceiveInfo - PTB Builder lzReceiveInfoMoveCall result, used for protocol SDK to dynamically build the PTB
-     * for OFT's lzReceive operation
+     * @param ticket - The OFTCreationTicket 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
+     * @returns TransactionResult array containing [AdminCap, MigrationCap] - MigrationCap must be transferred or stored
      */
-    registerOAppMoveCall(tx: Transaction, lzReceiveInfo: Uint8Array | TransactionArgument): void {
-        tx.moveCall({
-            target: this.#target('register_oapp'),
+    initOftMoveCall(
+        tx: Transaction,
+        ticket: string | TransactionArgument,
+        oapp: string | TransactionArgument,
+        treasury: string | TransactionArgument,
+        metadata: string | TransactionArgument,
+        sharedDecimals: number | TransactionArgument
+    ): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('init_oft', OFT_IMPL_MODULE_NAME),
             typeArguments: [this.coinType],
             arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#adminCapId()),
-                tx.object(this.objects.endpointV2),
-                asBytes(tx, lzReceiveInfo),
+                asObject(tx, ticket),
+                asObject(tx, oapp),
+                asObject(tx, treasury),
+                asObject(tx, metadata),
+                asU8(tx, sharedDecimals),
             ],
         })
     }
 
     /**
-     * Set enforced options for OFT messaging to a destination
+     * 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 eid - Endpoint ID
-     * @param msgType - Message type (SEND or SEND_AND_CALL)
-     * @param options - Enforced options as bytes
+     * @param ticket - The OFTCreationTicket 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
      */
-    setEnforcedOptionsMoveCall(
+    initOftAdapterMoveCall(
         tx: Transaction,
-        eid: number | TransactionArgument,
-        msgType: number | TransactionArgument,
-        options: Uint8Array | TransactionArgument
-    ): void {
-        tx.moveCall({
-            target: this.#target('set_enforced_options'),
+        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],
-            arguments: [
-                tx.object(this.oftObjectId),
-                tx.object(this.#adminCapId()),
-                asU32(tx, eid),
-                asU16(tx, msgType),
-                asBytes(tx, options),
-            ],
+            arguments: [asObject(tx, ticket), asObject(tx, oapp), asObject(tx, metadata), asU8(tx, sharedDecimals)],
         })
     }
 
+    // ==========================================
+    // ADMIN FUNCTIONS
+    // ==========================================
+    // These functions require admin privileges and are used for OFT configuration
+    // and management. They require the adminCapId to be provided during construction.
+
     /**
-     * Set peer OFT on another chain
+     * Get LayerZero receive information for OFT registration
+     *
+     * This function prepares the necessary metadata for registering an OFT
+     * with the LayerZero endpoint, enabling it to receive cross-chain messages.
+     *
      * @param tx - The transaction to add the move call to
-     * @param messagingChannel - The messaging channel object ID
-     * @param eid - Peer endpoint ID
-     * @param peer - Peer OFT address as bytes
+     * @param composerManager - The composer manager object ID for routing compose transfers
+     * @returns TransactionResult containing serialized execution metadata for endpoint registration
      */
-    setPeerMoveCall(
-        tx: Transaction,
-        messagingChannel: string | TransactionArgument,
-        eid: number | TransactionArgument,
-        peer: Uint8Array | TransactionArgument
-    ): void {
-        tx.moveCall({
-            target: this.#target('set_peer'),
+    lzReceiveInfoMoveCall(tx: Transaction, composerManager: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('lz_receive_info', OFT_PTB_BUILDER_MODULE_NAME),
             typeArguments: [this.coinType],
             arguments: [
                 tx.object(this.oftObjectId),
-                tx.object(this.#adminCapId()),
                 tx.object(this.objects.endpointV2),
-                asObject(tx, messagingChannel),
-                asU32(tx, eid),
-                asBytes32(tx, peer, this.protocolSDK.getUtils()),
+                asObject(tx, composerManager),
+                tx.object.clock(),
             ],
         })
     }
 
     /**
-     * Set delegate for OFT
+     * Register OFT as an OApp with LayerZero endpoint
      * @param tx - The transaction to add the move call to
-     * @param newDelegate - The new delegate address
+     * @param lzReceiveInfo - PTB Builder lzReceiveInfoMoveCall result, used for protocol SDK to dynamically build the PTB
+     * for OFT's lzReceive operation
      */
-    setDelegateMoveCall(tx: Transaction, newDelegate: string | TransactionArgument): void {
+    registerOAppMoveCall(tx: Transaction, lzReceiveInfo: Uint8Array | TransactionArgument): void {
         tx.moveCall({
-            target: this.#target('set_delegate'),
+            target: this.#target('register_oapp'),
             typeArguments: [this.coinType],
             arguments: [
                 tx.object(this.oftObjectId),
+                tx.object(this.#oappObjectId()),
                 tx.object(this.#adminCapId()),
                 tx.object(this.objects.endpointV2),
-                asAddress(tx, newDelegate),
+                asBytes(tx, lzReceiveInfo),
             ],
         })
     }
@@ -233,16 +261,66 @@ export class OFT {
         })
     }
 
+    setDefaultFeeBpsMoveCall(tx: Transaction, feeBps: bigint | number | string | TransactionArgument): 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)],
+        })
+    }
+
     /**
-     * Set fee basis points for OFT transfers
+     * Set fee basis points for a specific destination chain
      * @param tx - The transaction to add the move call to
-     * @param feeBps - The fee in basis points
+     * @param dstEid - Destination endpoint ID
+     * @param feeBps - Fee rate in basis points (0-10,000, where 10,000 = 100%)
      */
-    setFeeBpsMoveCall(tx: Transaction, feeBps: bigint | number | string | TransactionArgument): void {
+    setFeeBpsMoveCall(
+        tx: Transaction,
+        dstEid: number | TransactionArgument,
+        feeBps: bigint | number | string | TransactionArgument
+    ): void {
         tx.moveCall({
             target: this.#target('set_fee_bps'),
             typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), tx.object(this.#adminCapId()), asU64(tx, feeBps)],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#adminCapId()),
+                asU32(tx, dstEid),
+                asU64(tx, feeBps),
+            ],
+        })
+    }
+
+    /**
+     * Removes the fee rate for a specific destination chain
+     * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
+     */
+    unsetFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('unset_fee_bps'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId), tx.object(this.#adminCapId()), asU32(tx, dstEid)],
+        })
+    }
+
+    // ==========================================
+    // MIGRATION ADMIN FUNCTIONS
+    // ==========================================
+    // Handle OFT migration to new contracts
+
+    /**
+     * Migrate OFT instance to a new contract
+     * @param tx - The transaction to add the move call to
+     * @param migrationCap - Migration capability object ID or transaction argument
+     * @returns TransactionResult containing the migration ticket
+     */
+    migrateMoveCall(tx: Transaction, migrationCap: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('migrate'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId), asObject(tx, migrationCap)],
         })
     }
 
@@ -363,6 +441,7 @@ export class OFT {
             typeArguments: [this.coinType],
             arguments: [
                 tx.object(this.oftObjectId),
+                tx.object(this.#oappObjectId()),
                 txSender,
                 sendParamArg,
                 asObject(tx, coinProvided),
@@ -390,7 +469,13 @@ export class OFT {
         const confirmSendResult = tx.moveCall({
             target: this.#target('confirm_send'),
             typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), txSender, endpointCall, oftSendContext],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#oappObjectId()),
+                txSender,
+                endpointCall,
+                oftSendContext,
+            ],
         })
         // destroy the empty coins
         const nativeCoin = confirmSendResult[2]
@@ -407,6 +492,67 @@ export class OFT {
         })
     }
 
+    /**
+     * Process inbound cross-chain token transfers
+     * @param tx - The transaction to add the move call to
+     * @param call - LayerZero receive call containing the verified cross-chain message
+     * @returns TransactionResult containing the processed transfer
+     */
+    lzReceiveMoveCall(tx: Transaction, call: string | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('lz_receive'),
+            typeArguments: [this.coinType],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#oappObjectId()),
+                asObject(tx, call),
+                tx.object.clock(),
+            ],
+        })
+    }
+
+    /**
+     * Process inbound cross-chain token transfers with compose functionality
+     * @param tx - The transaction to add the move call to
+     * @param composeQueue - The composer's message queue for sequencing operations
+     * @param composerManager - Manager managing token deposits for composers
+     * @param call - LayerZero receive call containing the verified cross-chain message
+     * @returns TransactionResult containing the processed transfer
+     */
+    lzReceiveWithComposeMoveCall(
+        tx: Transaction,
+        composeQueue: string | TransactionArgument,
+        composerManager: string | TransactionArgument,
+        call: string | TransactionArgument
+    ): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('lz_receive_with_compose'),
+            typeArguments: [this.coinType],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#oappObjectId()),
+                asObject(tx, composeQueue),
+                asObject(tx, composerManager),
+                asObject(tx, call),
+                tx.object.clock(),
+            ],
+        })
+    }
+
+    /**
+     * Confirms and extracts results from a quote operation
+     * @param tx - The transaction to add the move call to
+     * @param call - Completed Call object from quote_send() execution
+     * @returns TransactionResult containing the messaging fee
+     */
+    confirmQuoteSendMoveCall(tx: Transaction, call: string | TransactionArgument): 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)],
+        })
+    }
+
     // ==========================================
     // QUOTE FUNCTIONS
     // ==========================================
@@ -460,7 +606,13 @@ export class OFT {
         const quoteCall = tx.moveCall({
             target: this.#target('quote_send'),
             typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asAddress(tx, sender), sendParamArg, asBool(tx, payInZro)],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#oappObjectId()),
+                asAddress(tx, sender),
+                sendParamArg,
+                asBool(tx, payInZro),
+            ],
         })
 
         return this.protocolSDK.getEndpoint().quote(tx, quoteCall, sender, validators, maxSimulationTimes)
@@ -471,6 +623,60 @@ export class OFT {
     // ==========================================
     // Read-only functions to query OFT state and configuration
 
+    /**
+     * Get the upgrade version of this OFT instance
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the upgrade version
+     */
+    upgradeVersionMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('upgrade_version'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get the upgrade version of this OFT instance
+     * @returns Promise<bigint> - The upgrade version
+     */
+    async upgradeVersion(): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.upgradeVersionMoveCall(tx)
+            },
+            (result) => BigInt(bcs.U64.parse(result[0].value))
+        )
+    }
+
+    /**
+     * Get the associated OApp object address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the OApp object address
+     */
+    oappObjectMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('oapp_object'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get the associated OApp object address
+     * @returns Promise<string> - The OApp object address
+     */
+    async oappObject(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.oappObjectMoveCall(tx)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
     /**
      * Get OFT version information
      * @param tx - The transaction to add the move call to
@@ -502,18 +708,45 @@ export class OFT {
         )
     }
 
-    oftAddressMoveCall(tx: Transaction): TransactionResult {
+    oftCapIdMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('oft_cap_id'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    async oftCapId(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => this.oftCapIdMoveCall(tx),
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get the migration capability address for this OFT
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the migration capability address
+     */
+    migrationCapMoveCall(tx: Transaction): TransactionResult {
         return tx.moveCall({
-            target: this.#target('oft_address'),
+            target: this.#target('migration_cap'),
             typeArguments: [this.coinType],
             arguments: [tx.object(this.oftObjectId)],
         })
     }
 
-    async oftAddress(): Promise<string> {
+    /**
+     * Get the migration capability address for this OFT
+     * @returns Promise<string> - The migration capability address
+     */
+    async migrationCap(): Promise<string> {
         return executeSimulate(
             this.client,
-            (tx) => this.oftAddressMoveCall(tx),
+            (tx) => {
+                this.migrationCapMoveCall(tx)
+            },
             (result) => bcs.Address.parse(result[0].value)
         )
     }
@@ -522,8 +755,8 @@ export class OFT {
         return executeSimulate(
             this.client,
             (tx) => {
-                const oftAddress = this.oftAddressMoveCall(tx)
-                this.protocolSDK.getEndpoint().getMessagingChannelMoveCall(tx, oftAddress)
+                const oftCapId = this.oftCapIdMoveCall(tx)
+                this.protocolSDK.getEndpoint().getMessagingChannelMoveCall(tx, oftCapId)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -557,27 +790,27 @@ export class OFT {
     }
 
     /**
-     * Get OFT admin address
+     * Get OFT admin capability address
      * @param tx - The transaction to add the move call to
-     * @returns Transaction result containing the admin address
+     * @returns Transaction result containing the admin capability address
      */
-    adminMoveCall(tx: Transaction): TransactionResult {
+    adminCapMoveCall(tx: Transaction): TransactionResult {
         return tx.moveCall({
-            target: this.#target('admin'),
+            target: this.#target('admin_cap'),
             typeArguments: [this.coinType],
             arguments: [tx.object(this.oftObjectId)],
         })
     }
 
     /**
-     * Get OFT admin address
-     * @returns Promise<string> - The admin address
+     * Get OFT admin capability address
+     * @returns Promise<string> - The admin capability address
      */
-    async admin(): Promise<string> {
+    async adminCap(): Promise<string> {
         return executeSimulate(
             this.client,
             (tx) => {
-                this.adminMoveCall(tx)
+                this.adminCapMoveCall(tx)
             },
             (result) => bcs.Address.parse(result[0].value)
         )
@@ -610,6 +843,33 @@ export class OFT {
         )
     }
 
+    /**
+     * Get the decimal conversion rate for this OFT
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the decimal conversion rate
+     */
+    decimalConversionRateMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('decimal_conversion_rate'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get the decimal conversion rate for this OFT
+     * @returns Promise<bigint> - The decimal conversion rate multiplier
+     */
+    async decimalConversionRate(): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.decimalConversionRateMoveCall(tx)
+            },
+            (result) => BigInt(bcs.U64.parse(result[0].value))
+        )
+    }
+
     /**
      * Check if OFT is paused
      * @param tx - The transaction to add the move call to
@@ -670,27 +930,114 @@ export class OFT {
     // Query current fee configuration and settings
 
     /**
-     * Get fee basis points for OFT transfers
+     * Check if the OFT has a fee rate greater than 0 for the specified destination
+     * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
+     * @returns Transaction result containing whether fee exists
+     */
+    hasOftFeeMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('has_oft_fee'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId), asU32(tx, dstEid)],
+        })
+    }
+
+    /**
+     * Check if the OFT has a fee rate greater than 0 for the specified destination
+     * @param dstEid - Destination endpoint ID
+     * @returns Promise<boolean> - True if fee exists
+     */
+    async hasOftFee(dstEid: number): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.hasOftFeeMoveCall(tx, dstEid)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get the effective fee rate for a specific destination chain
+     * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
+     * @returns Transaction result containing the effective fee basis points
+     */
+    effectiveFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('effective_fee_bps'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId), asU32(tx, dstEid)],
+        })
+    }
+
+    /**
+     * Get the effective fee rate for a specific destination chain
+     * @param dstEid - Destination endpoint ID
+     * @returns Promise<bigint> - The effective fee in basis points
+     */
+    async effectiveFeeBps(dstEid: number): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.effectiveFeeBpsMoveCall(tx, dstEid)
+            },
+            (result) => BigInt(bcs.U64.parse(result[0].value))
+        )
+    }
+
+    /**
+     * Get the default fee rate
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the default fee basis points
+     */
+    defaultFeeBpsMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('default_fee_bps'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get the default fee rate
+     * @returns Promise<bigint> - The default fee in basis points
+     */
+    async defaultFeeBps(): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.defaultFeeBpsMoveCall(tx)
+            },
+            (result) => BigInt(bcs.U64.parse(result[0].value))
+        )
+    }
+
+    /**
+     * Get fee basis points for a specific destination chain
      * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
      * @returns Transaction result containing the fee basis points
      */
-    feeBpsMoveCall(tx: Transaction): TransactionResult {
+    feeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult {
         return tx.moveCall({
             target: this.#target('fee_bps'),
             typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId)],
+            arguments: [tx.object(this.oftObjectId), asU32(tx, dstEid)],
         })
     }
 
     /**
-     * Get fee basis points for OFT transfers
+     * Get fee basis points for a specific destination chain
+     * @param dstEid - Destination endpoint ID
      * @returns Promise<bigint> - The fee in basis points
      */
-    async feeBps(): Promise<bigint> {
+    async feeBps(dstEid: number): Promise<bigint> {
         return executeSimulate(
             this.client,
             (tx) => {
-                this.feeBpsMoveCall(tx)
+                this.feeBpsMoveCall(tx, dstEid)
             },
             (result) => BigInt(bcs.U64.parse(result[0].value))
         )
@@ -837,140 +1184,6 @@ export class OFT {
         )
     }
 
-    /**
-     * Combine enforced options with extra options
-     * @param tx - The transaction to add the move call to
-     * @param eid - Endpoint ID
-     * @param msgType - Message type
-     * @param extraOptions - Extra options to combine with enforced options
-     * @returns Transaction result containing the combined options
-     */
-    combineOptionsMoveCall(
-        tx: Transaction,
-        eid: number | TransactionArgument,
-        msgType: number | TransactionArgument,
-        extraOptions: Uint8Array | TransactionArgument
-    ): TransactionResult {
-        return tx.moveCall({
-            target: this.#target('combine_options'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, eid), asU16(tx, msgType), asBytes(tx, extraOptions)],
-        })
-    }
-
-    /**
-     * Combine enforced options with extra options
-     * @param eid - Endpoint ID
-     * @param msgType - Message type
-     * @param extraOptions - Extra options to combine with enforced options
-     * @returns Promise<Uint8Array> - The combined options as bytes
-     */
-    async combineOptions(eid: number, msgType: number, extraOptions: Uint8Array): Promise<Uint8Array> {
-        return executeSimulate(
-            this.client,
-            (tx) => {
-                this.combineOptionsMoveCall(tx, eid, msgType, extraOptions)
-            },
-            (result) => new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
-        )
-    }
-
-    /**
-     * Get enforced options for OFT messaging
-     * @param tx - The transaction to add the move call to
-     * @param eid - Endpoint ID
-     * @param msgType - Message type
-     * @returns Transaction result containing the enforced options
-     */
-    getEnforcedOptionsMoveCall(
-        tx: Transaction,
-        eid: number | TransactionArgument,
-        msgType: number | TransactionArgument
-    ): TransactionResult {
-        return tx.moveCall({
-            target: this.#target('get_enforced_options'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, eid), asU16(tx, msgType)],
-        })
-    }
-
-    /**
-     * Get enforced options for OFT messaging
-     * @param eid - Endpoint ID
-     * @param msgType - Message type
-     * @returns Promise<Uint8Array> - The enforced options as bytes
-     */
-    async getEnforcedOptions(eid: number, msgType: number): Promise<Uint8Array> {
-        return executeSimulate(
-            this.client,
-            (tx) => {
-                this.getEnforcedOptionsMoveCall(tx, eid, msgType)
-            },
-            (result) => new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
-        )
-    }
-
-    /**
-     * Check if OFT has a peer on specific endpoint
-     * @param tx - The transaction to add the move call to
-     * @param eid - Endpoint ID
-     * @returns Transaction result containing the peer existence status
-     */
-    hasPeerMoveCall(tx: Transaction, eid: number | TransactionArgument): TransactionResult {
-        return tx.moveCall({
-            target: this.#target('has_peer'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, eid)],
-        })
-    }
-
-    /**
-     * Check if OFT has a peer on specific endpoint
-     * @param eid - Endpoint ID
-     * @returns Promise<boolean> - True if peer exists on the endpoint
-     */
-    async hasPeer(eid: number): Promise<boolean> {
-        return executeSimulate(
-            this.client,
-            (tx) => {
-                this.hasPeerMoveCall(tx, eid)
-            },
-            (result) => bcs.Bool.parse(result[0].value)
-        )
-    }
-
-    /**
-     * Get peer OFT address on specific endpoint
-     * @param tx - The transaction to add the move call to
-     * @param eid - Endpoint ID
-     * @returns Transaction result containing the peer address
-     */
-    getPeerMoveCall(tx: Transaction, eid: number | TransactionArgument): TransactionResult {
-        return tx.moveCall({
-            target: this.#target('get_peer'),
-            typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), asU32(tx, eid)],
-        })
-    }
-
-    /**
-     * Get peer OFT address on specific endpoint
-     * @param eid - Endpoint ID
-     * @returns Promise<Uint8Array> - The peer address as bytes32
-     */
-    async getPeer(eid: number): Promise<Uint8Array> {
-        return executeSimulate(
-            this.client,
-            (tx) => {
-                this.getPeerMoveCall(tx, eid)
-            },
-            (result) => {
-                // Assuming Bytes32 is returned as vector<u8>
-                return new Uint8Array(bcs.vector(bcs.u8()).parse(result[0].value))
-            }
-        )
-    }
-
     // ==========================================
     // OFT SENDER
     // ==========================================
@@ -1019,6 +1232,19 @@ export class OFT {
         return `${this.oftPackageId}::${module_name}::${name}`
     }
 
+    /**
+     * Get the OApp object ID, throwing an error if not available
+     * @returns The OApp object ID
+     * @throws Error if OApp object ID was not set
+     * @private
+     */
+    #oappObjectId(): string {
+        if (this.oappObjectId === '') {
+            throw new Error('OApp object ID not found')
+        }
+        return this.oappObjectId
+    }
+
     /**
      * Get the admin capability ID, throwing an error if not available
      * @returns The admin capability ID