@layerzerolabs/lz-sui-oft-sdk-v2 3.0.127-sui.1

package/src/modules/oft.ts

@@ -0,0 +1,978 @@
+import { bcs } from '@mysten/sui/bcs'
+import { SuiClient } from '@mysten/sui/client'
+import { Transaction, TransactionArgument, TransactionResult } from '@mysten/sui/transactions'
+
+import {
+    SDK,
+    asAddress,
+    asArgWithTx,
+    asArgWithTxAsync,
+    asBool,
+    asBytes,
+    asBytes32,
+    asObject,
+    asU16,
+    asU32,
+    asU64,
+    executeSimulate,
+    isTransactionArgument,
+} from '@layerzerolabs/lz-sui-sdk-v2'
+import type { MessagingFee, ObjectOptions } from '@layerzerolabs/lz-sui-sdk-v2'
+
+import { parseOFTFeeDetails, parseOFTLimit, parseOFTReceipt } from '../bcs/oft'
+import { OFTFeeDetail, OFTLimit, OFTReceipt, SendParam } from '../types'
+
+const MODULE_NAME = 'oft'
+
+// ==========================================
+// ERROR CODES
+// ==========================================
+// Standard error codes that may be returned by OFT operations
+
+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,
+} as const
+
+/**
+ * OFT (Omnichain Fungible Token) Class
+ *
+ * The OFT class provides a comprehensive interface for interacting with LayerZero's
+ * Omnichain Fungible Token standard on the Sui blockchain. OFTs enable seamless
+ * cross-chain token transfers while maintaining fungibility across multiple networks.
+ *
+ * @example
+ * ```typescript
+ * // Initialize OFT instance
+ * const oft = new OFT(protocolSDK, corePackageId, packageId, oftObjectId, coinType, adminCapId);
+ *
+ * // 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);
+ * tx.transferObjects([coin], sender);
+ * ...
+ *
+ * // Quote transfer fees
+ * const fees = await oft.quoteSend(sender, sendParam, payInZro);
+ * ```
+ */
+export class OFT {
+    /** Sui client for blockchain interactions */
+    public readonly client: SuiClient
+    /** The package ID of the OFT implementation (specific token contract) */
+    public packageId: string
+    /** The package ID of the core OFT framework (shared OFT functionality) */
+    public corePackageId: 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
+    /** The Sui coin type this OFT represents (e.g., "0x123::mycoin::MYCOIN") */
+    private readonly coinType: string
+    /** Reference to the LayerZero protocol SDK for cross-chain operations */
+    private readonly protocolSDK: SDK
+
+    /**
+     * 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 corePackageId - The package ID of the core OFT framework (shared across all OFT implementations)
+     * @param packageId - The package ID of the specific OFT token implementation
+     * @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)
+     */
+    constructor(
+        protocolSDK: SDK,
+        corePackageId: string, // the OFT package id
+        packageId: string, // the Implementation's package id
+        oftObjectId: string,
+        coinType: string,
+        adminCapId?: string
+    ) {
+        this.protocolSDK = protocolSDK
+        this.packageId = packageId
+        this.corePackageId = corePackageId
+        this.client = protocolSDK.client
+        this.objects = protocolSDK.objects
+        this.oftObjectId = oftObjectId
+        this.adminCapId = adminCapId
+        this.coinType = coinType
+    }
+
+    // ==========================================
+    // ADMIN FUNCTIONS
+    // ==========================================
+    // These functions require admin privileges and are used for OFT configuration
+    // and management. They require the adminCapId to be provided during construction.
+
+    /**
+     * 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
+     */
+    registerOAppMoveCall(tx: Transaction, lzReceiveInfo: Uint8Array | TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('register_oapp'),
+            typeArguments: [this.coinType],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#adminCapId()),
+                tx.object(this.objects.endpointV2),
+                asBytes(tx, lzReceiveInfo),
+            ],
+        })
+    }
+
+    /**
+     * Set enforced options for OFT messaging to a destination
+     * @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
+     */
+    setEnforcedOptionsMoveCall(
+        tx: Transaction,
+        eid: number | TransactionArgument,
+        msgType: number | TransactionArgument,
+        options: Uint8Array | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('set_enforced_options'),
+            typeArguments: [this.coinType],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#adminCapId()),
+                asU32(tx, eid),
+                asU16(tx, msgType),
+                asBytes(tx, options),
+            ],
+        })
+    }
+
+    /**
+     * Set peer OFT on another chain
+     * @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
+     */
+    setPeerMoveCall(
+        tx: Transaction,
+        messagingChannel: string | TransactionArgument,
+        eid: number | TransactionArgument,
+        peer: Uint8Array | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('set_peer'),
+            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()),
+            ],
+        })
+    }
+
+    /**
+     * Set delegate for OFT
+     * @param tx - The transaction to add the move call to
+     * @param newDelegate - The new delegate address
+     */
+    setDelegateMoveCall(tx: Transaction, newDelegate: string | TransactionArgument): void {
+        tx.moveCall({
+            target: this.#target('set_delegate'),
+            typeArguments: [this.coinType],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#adminCapId()),
+                tx.object(this.objects.endpointV2),
+                asAddress(tx, newDelegate),
+            ],
+        })
+    }
+
+    /**
+     * Set pause state for OFT operations
+     * @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 {
+        tx.moveCall({
+            target: this.#target('set_pause'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId), tx.object(this.#adminCapId()), asBool(tx, pause)],
+        })
+    }
+
+    // ==========================================
+    // FEE MANAGEMENT ADMIN FUNCTIONS
+    // ==========================================
+    // Configure fee collection and distribution for OFT transfers
+
+    /**
+     * Set fee deposit address for OFT fees
+     * @param tx - The transaction to add the move call to
+     * @param feeDepositAddress - The new fee deposit address
+     */
+    setFeeDepositAddressMoveCall(tx: Transaction, feeDepositAddress: string | TransactionArgument): 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)],
+        })
+    }
+
+    /**
+     * Set fee basis points for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param feeBps - The fee in basis points
+     */
+    setFeeBpsMoveCall(tx: Transaction, 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)],
+        })
+    }
+
+    // ==========================================
+    // RATE LIMITER ADMIN FUNCTIONS
+    // ==========================================
+    // Configure transfer rate limits for security and compliance
+
+    /**
+     * Set rate limit for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @param rateLimit - Rate limit amount
+     * @param windowSeconds - Time window in seconds
+     */
+    setRateLimitMoveCall(
+        tx: Transaction,
+        eid: number | TransactionArgument,
+        inbound: boolean | TransactionArgument,
+        rateLimit: bigint | number | string | TransactionArgument,
+        windowSeconds: bigint | number | string | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('set_rate_limit'),
+            typeArguments: [this.coinType],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#adminCapId()),
+                asU32(tx, eid),
+                asBool(tx, inbound),
+                asU64(tx, rateLimit),
+                asU64(tx, windowSeconds),
+                tx.object.clock(),
+            ],
+        })
+    }
+
+    /**
+     * Remove rate limit for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     */
+    unsetRateLimitMoveCall(
+        tx: Transaction,
+        eid: number | TransactionArgument,
+        inbound: boolean | TransactionArgument
+    ): void {
+        tx.moveCall({
+            target: this.#target('unset_rate_limit'),
+            typeArguments: [this.coinType],
+            arguments: [
+                tx.object(this.oftObjectId),
+                tx.object(this.#adminCapId()),
+                asU32(tx, eid),
+                asBool(tx, inbound),
+            ],
+        })
+    }
+
+    // ==========================================
+    // CORE FUNCTIONS
+    // ==========================================
+    // Primary OFT operations for token transfers and coin management
+
+    /**
+     * Splits specified amount of coins from user's wallet
+     * @param tx - The transaction to add the move call to
+     * @param owner - Address of the user whose coins to split
+     * @param amount - Amount of coins to split (in smallest units)
+     * @param limit - Maximum total number of coins to collect across all pages (default: 200)
+     * @param pageSize - Maximum number of coins to fetch per page (default: 50)
+     * @returns Promise resolving to split coin as TransactionResult
+     * @throws Error if insufficient coins balance or no coins found
+     */
+    async splitCoinMoveCall(
+        tx: Transaction,
+        owner: string,
+        amount: bigint,
+        limit = 200,
+        pageSize = 50
+    ): Promise<TransactionResult> {
+        return this.protocolSDK.getUtils().splitCoinMoveCall(tx, this.coinType, owner, amount, limit, pageSize)
+    }
+
+    /**
+     * Send OFT tokens to destination chain
+     * @param tx - The transaction to add the move call to
+     * @param sender - Sender address for ZRO token operations
+     * @param coinProvided - Coin object ID or transaction result to send
+     * @param messagingChannel - The messaging channel object ID
+     * @param sendParam - Send parameters including destination and amounts
+     * @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
+     */
+    async sendMoveCall(
+        tx: Transaction,
+        sender: string,
+        coinProvided: string | TransactionArgument,
+        sendParam: SendParam | TransactionArgument,
+        nativeFee: bigint | TransactionArgument,
+        zroFee: bigint | TransactionArgument,
+        refundAddress: string | TransactionArgument,
+        messagingChannel?: string | undefined
+    ): Promise<void> {
+        const sendParamArg = isTransactionArgument(sendParam) ? sendParam : this.#buildSendParam(tx, sendParam)
+        const messagingChannelArg =
+            messagingChannel ?? (await this.protocolSDK.getEndpoint().getMessagingChannel(this.packageId))
+
+        // The oft::send returns a tuple (Call<EndpointSendParam, MessagingReceipt>, OFTReceipt)
+        const transactionResult = tx.moveCall({
+            target: this.#target('send'),
+            typeArguments: [this.coinType],
+            arguments: [
+                tx.object(this.oftObjectId),
+                asObject(tx, coinProvided),
+                tx.object(this.objects.endpointV2),
+                tx.object(messagingChannelArg),
+                sendParamArg,
+                asArgWithTx(tx, nativeFee, (tx, val) => tx.splitCoins(tx.gas, [asU64(tx, val)])[0]),
+                await asArgWithTxAsync(tx, zroFee, async (tx, val) =>
+                    this.protocolSDK.getZro().splitOptionZroTokenMoveCall(tx, sender, val)
+                ),
+                asAddress(tx, refundAddress),
+                tx.object.clock(),
+            ],
+        })
+        const endpointCall = transactionResult[0]
+
+        await this.protocolSDK
+            .getEndpoint()
+            .populateSendTransaction(tx, endpointCall as unknown as TransactionResult, sender)
+
+        tx.moveCall({
+            target: this.#target('confirm_send'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId), endpointCall],
+        })
+    }
+
+    // ==========================================
+    // QUOTE FUNCTIONS
+    // ==========================================
+    // Calculate fees, limits, and receipts before executing operations
+
+    /**
+     * Quote OFT sending operation with detailed fee breakdown
+     * @param sendParam - Send parameters for the OFT operation
+     * @returns Promise with limit, fee details, and receipt information
+     */
+    async quoteOft(
+        sendParam: SendParam | TransactionArgument
+    ): Promise<{ limit: OFTLimit; feeDetails: OFTFeeDetail[]; receipt: OFTReceipt }> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                const sendParamArg = isTransactionArgument(sendParam) ? sendParam : this.#buildSendParam(tx, sendParam)
+                tx.moveCall({
+                    target: this.#target('quote_oft'),
+                    typeArguments: [this.coinType],
+                    arguments: [tx.object(this.oftObjectId), sendParamArg, tx.object.clock()],
+                })
+            },
+            (result) => {
+                return {
+                    limit: parseOFTLimit(result[0].value),
+                    feeDetails: parseOFTFeeDetails(result[1].value),
+                    receipt: parseOFTReceipt(result[2].value),
+                }
+            }
+        )
+    }
+
+    /**
+     * Quote messaging fees for OFT sending
+     * @param sender - Sender address
+     * @param sendParam - Send parameters for the OFT operation
+     * @param payInZro - Whether to pay in ZRO tokens
+     * @returns Promise<MessagingFee> - The calculated messaging fees
+     */
+    async quoteSend(
+        sender: string | TransactionArgument,
+        sendParam: SendParam | TransactionArgument,
+        payInZro: boolean | TransactionArgument
+    ): Promise<MessagingFee> {
+        const tx = new Transaction()
+        const sendParamArg = isTransactionArgument(sendParam) ? sendParam : this.#buildSendParam(tx, sendParam)
+
+        const quoteCall = tx.moveCall({
+            target: this.#target('quote_send'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId), asAddress(tx, sender), sendParamArg, asBool(tx, payInZro)],
+        })
+
+        return this.protocolSDK.getEndpoint().quote(tx, quoteCall)
+    }
+
+    // ==========================================
+    // VIEW FUNCTIONS
+    // ==========================================
+    // Read-only functions to query OFT state and configuration
+
+    /**
+     * Get OFT version information
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing version information
+     */
+    oftVersionMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('oft_version'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get OFT version information
+     * @returns Promise<{ major: number; minor: number }> - The OFT version
+     */
+    async oftVersion(): Promise<{ major: number; minor: number }> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.oftVersionMoveCall(tx)
+            },
+            (result) => {
+                const major = Number(bcs.U64.parse(result[0].value))
+                const minor = Number(bcs.U64.parse(result[1].value))
+                return { major, minor }
+            }
+        )
+    }
+
+    /**
+     * Get coin metadata address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing coin metadata address
+     */
+    coinMetadataMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('coin_metadata'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get coin metadata address
+     * @returns Promise<string> - The coin metadata address
+     */
+    async coinMetadata(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.coinMetadataMoveCall(tx)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get OFT admin address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the admin address
+     */
+    adminMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('admin'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get OFT admin address
+     * @returns Promise<string> - The admin address
+     */
+    async admin(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.adminMoveCall(tx)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Get shared decimals for cross-chain compatibility
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing shared decimals
+     */
+    sharedDecimalsMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('shared_decimals'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get shared decimals for cross-chain compatibility
+     * @returns Promise<number> - The shared decimal precision
+     */
+    async sharedDecimals(): Promise<number> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.sharedDecimalsMoveCall(tx)
+            },
+            (result) => bcs.U8.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Check if OFT is paused
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the paused status
+     */
+    isPausedMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_paused'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Check if OFT is paused
+     * @returns Promise<boolean> - True if OFT is paused
+     */
+    async isPaused(): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isPausedMoveCall(tx)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    /**
+     * Check if this OFT is an adapter (wraps existing token)
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the adapter status
+     */
+    isAdapterMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('is_adapter'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Check if this OFT is an adapter (wraps existing token)
+     * @returns Promise<boolean> - True if this is an OFT adapter
+     */
+    async isAdapter(): Promise<boolean> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.isAdapterMoveCall(tx)
+            },
+            (result) => bcs.Bool.parse(result[0].value)
+        )
+    }
+
+    // ==========================================
+    // FEE VIEW FUNCTIONS
+    // ==========================================
+    // Query current fee configuration and settings
+
+    /**
+     * Get fee basis points for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the fee basis points
+     */
+    feeBpsMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('fee_bps'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get fee basis points for OFT transfers
+     * @returns Promise<bigint> - The fee in basis points
+     */
+    async feeBps(): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.feeBpsMoveCall(tx)
+            },
+            (result) => BigInt(bcs.U64.parse(result[0].value))
+        )
+    }
+
+    /**
+     * Get fee deposit address for OFT
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the fee deposit address
+     */
+    feeDepositAddressMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('fee_deposit_address'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    /**
+     * Get fee deposit address for OFT
+     * @returns Promise<string> - The fee deposit address
+     */
+    async feeDepositAddress(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.feeDepositAddressMoveCall(tx)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
+    // ==========================================
+    // RATE LIMITER VIEW FUNCTIONS
+    // ==========================================
+    // Query current rate limiting configuration and status
+
+    /**
+     * Get rate limit configuration for an endpoint
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Transaction result containing rate limit configuration
+     */
+    rateLimitConfigMoveCall(
+        tx: Transaction,
+        eid: number | TransactionArgument,
+        inbound: boolean | TransactionArgument
+    ): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('rate_limit_config'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId), asU32(tx, eid), asBool(tx, inbound)],
+        })
+    }
+
+    /**
+     * Get rate limit configuration for an endpoint
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Promise<{ limit: bigint; windowSeconds: bigint }> - Rate limit configuration
+     */
+    async rateLimitConfig(eid: number, inbound: boolean): Promise<{ limit: bigint; windowSeconds: bigint }> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.rateLimitConfigMoveCall(tx, eid, inbound)
+            },
+            (result) => {
+                const limit = BigInt(bcs.U64.parse(result[0].value))
+                const windowSeconds = BigInt(bcs.U64.parse(result[1].value))
+                return { limit, windowSeconds }
+            }
+        )
+    }
+
+    /**
+     * Get current in-flight amount for rate limiting
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Transaction result containing in-flight amount
+     */
+    rateLimitInFlightMoveCall(
+        tx: Transaction,
+        eid: number | TransactionArgument,
+        inbound: boolean | TransactionArgument
+    ): 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()],
+        })
+    }
+
+    /**
+     * Get current in-flight amount for rate limiting
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Promise<bigint> - Current in-flight amount
+     */
+    async rateLimitInFlight(eid: number, inbound: boolean): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.rateLimitInFlightMoveCall(tx, eid, inbound)
+            },
+            (result) => BigInt(bcs.U64.parse(result[0].value))
+        )
+    }
+
+    /**
+     * Get rate limit capacity (remaining available amount)
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Transaction result containing rate limit capacity
+     */
+    rateLimitCapacityMoveCall(
+        tx: Transaction,
+        eid: number | TransactionArgument,
+        inbound: boolean | TransactionArgument
+    ): 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()],
+        })
+    }
+
+    /**
+     * Get rate limit capacity (remaining available amount)
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Promise<bigint> - Remaining rate limit capacity
+     */
+    async rateLimitCapacity(eid: number, inbound: boolean): Promise<bigint> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                this.rateLimitCapacityMoveCall(tx, eid, inbound)
+            },
+            (result) => BigInt(bcs.U64.parse(result[0].value))
+        )
+    }
+
+    /**
+     * 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))
+            }
+        )
+    }
+
+    // ==========================================
+    // PRIVATE HELPER FUNCTIONS
+    // ==========================================
+    // Internal utility functions for OFT operations
+
+    /**
+     * Build SendParam struct for OFT operations
+     * @param tx - The transaction to add the move call to
+     * @param param - Send parameters to build
+     * @returns Transaction result containing the SendParam struct
+     * @private
+     */
+    #buildSendParam(tx: Transaction, param: SendParam): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('create', 'send_param'),
+            arguments: [
+                asU32(tx, param.dstEid),
+                asBytes32(tx, param.to, this.protocolSDK.getUtils()),
+                asU64(tx, param.amountLd),
+                asU64(tx, param.minAmountLd),
+                asBytes(tx, param.extraOptions),
+                asBytes(tx, param.composeMsg),
+                asBytes(tx, param.oftCmd),
+            ],
+        })
+    }
+
+    /**
+     * Generate the full target path for move calls
+     * @param name - The function name to call
+     * @param module_name - The module name (defaults to 'oft')
+     * @returns The full module path for the move call
+     * @private
+     */
+    #target(name: string, module_name = MODULE_NAME): string {
+        return `${this.corePackageId}::${module_name}::${name}`
+    }
+
+    /**
+     * Get the admin capability ID, throwing an error if not available
+     * @returns The admin capability ID
+     * @throws Error if admin capability ID was not provided during construction
+     * @private
+     */
+    #adminCapId(): string {
+        if (this.adminCapId === undefined) {
+            throw new Error('Admin cap ID not found')
+        }
+        return this.adminCapId
+    }
+}