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

package/dist/index.cjs

@@ -0,0 +1,980 @@
+'use strict';
+
+var bcs = require('@mysten/sui/bcs');
+var transactions = require('@mysten/sui/transactions');
+var lzSuiSdkV2 = require('@layerzerolabs/lz-sui-sdk-v2');
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var OFTLimitBcs = bcs.bcs.struct("OFTLimit", {
+  min_amount_ld: bcs.bcs.U64,
+  max_amount_ld: bcs.bcs.U64
+});
+var OFTFeeDetailBcs = bcs.bcs.struct("OFTFeeDetail", {
+  fee_amount_ld: bcs.bcs.U64,
+  is_reward: bcs.bcs.Bool,
+  description: bcs.bcs.String
+});
+var OFTReceiptBcs = bcs.bcs.struct("OFTReceipt", {
+  amount_sent_ld: bcs.bcs.U64,
+  amount_received_ld: bcs.bcs.U64
+});
+function parseOFTLimit(data) {
+  const parsed = OFTLimitBcs.parse(data);
+  return {
+    minAmountLd: BigInt(parsed.min_amount_ld),
+    maxAmountLd: BigInt(parsed.max_amount_ld)
+  };
+}
+function parseOFTFeeDetails(data) {
+  const vectorBcs = bcs.bcs.vector(OFTFeeDetailBcs);
+  const parsed = vectorBcs.parse(data);
+  return parsed.map(
+    (detail) => ({
+      feeAmountLd: BigInt(detail.fee_amount_ld),
+      isReward: detail.is_reward,
+      description: detail.description
+    })
+  );
+}
+function parseOFTReceipt(data) {
+  const parsed = OFTReceiptBcs.parse(data);
+  return {
+    amountSentLd: BigInt(parsed.amount_sent_ld),
+    amountReceivedLd: BigInt(parsed.amount_received_ld)
+  };
+}
+
+// src/modules/oft.ts
+var MODULE_NAME = "oft";
+var 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
+};
+var _OFT_instances, buildSendParam_fn, target_fn, adminCapId_fn;
+var OFT = class {
+  /**
+   * 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, corePackageId, packageId, oftObjectId, coinType, adminCapId) {
+    __privateAdd(this, _OFT_instances);
+    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, lzReceiveInfo) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "register_oapp"),
+      typeArguments: [this.coinType],
+      arguments: [
+        tx.object(this.oftObjectId),
+        tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        tx.object(this.objects.endpointV2),
+        lzSuiSdkV2.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, eid, msgType, options) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "set_enforced_options"),
+      typeArguments: [this.coinType],
+      arguments: [
+        tx.object(this.oftObjectId),
+        tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        lzSuiSdkV2.asU32(tx, eid),
+        lzSuiSdkV2.asU16(tx, msgType),
+        lzSuiSdkV2.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, messagingChannel, eid, peer) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "set_peer"),
+      typeArguments: [this.coinType],
+      arguments: [
+        tx.object(this.oftObjectId),
+        tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        tx.object(this.objects.endpointV2),
+        lzSuiSdkV2.asObject(tx, messagingChannel),
+        lzSuiSdkV2.asU32(tx, eid),
+        lzSuiSdkV2.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, newDelegate) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "set_delegate"),
+      typeArguments: [this.coinType],
+      arguments: [
+        tx.object(this.oftObjectId),
+        tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        tx.object(this.objects.endpointV2),
+        lzSuiSdkV2.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, pause) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "set_pause"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)), lzSuiSdkV2.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, feeDepositAddress) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "set_fee_deposit_address"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)), lzSuiSdkV2.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, feeBps) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "set_fee_bps"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)), lzSuiSdkV2.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, eid, inbound, rateLimit, windowSeconds) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "set_rate_limit"),
+      typeArguments: [this.coinType],
+      arguments: [
+        tx.object(this.oftObjectId),
+        tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        lzSuiSdkV2.asU32(tx, eid),
+        lzSuiSdkV2.asBool(tx, inbound),
+        lzSuiSdkV2.asU64(tx, rateLimit),
+        lzSuiSdkV2.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, eid, inbound) {
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "unset_rate_limit"),
+      typeArguments: [this.coinType],
+      arguments: [
+        tx.object(this.oftObjectId),
+        tx.object(__privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        lzSuiSdkV2.asU32(tx, eid),
+        lzSuiSdkV2.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, owner, amount, limit = 200, pageSize = 50) {
+    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, sender, coinProvided, sendParam, nativeFee, zroFee, refundAddress, messagingChannel) {
+    const sendParamArg = lzSuiSdkV2.isTransactionArgument(sendParam) ? sendParam : __privateMethod(this, _OFT_instances, buildSendParam_fn).call(this, tx, sendParam);
+    const messagingChannelArg = messagingChannel ?? await this.protocolSDK.getEndpoint().getMessagingChannel(this.packageId);
+    const transactionResult = tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "send"),
+      typeArguments: [this.coinType],
+      arguments: [
+        tx.object(this.oftObjectId),
+        lzSuiSdkV2.asObject(tx, coinProvided),
+        tx.object(this.objects.endpointV2),
+        tx.object(messagingChannelArg),
+        sendParamArg,
+        lzSuiSdkV2.asArgWithTx(tx, nativeFee, (tx2, val) => tx2.splitCoins(tx2.gas, [lzSuiSdkV2.asU64(tx2, val)])[0]),
+        await lzSuiSdkV2.asArgWithTxAsync(
+          tx,
+          zroFee,
+          async (tx2, val) => this.protocolSDK.getZro().splitOptionZroTokenMoveCall(tx2, sender, val)
+        ),
+        lzSuiSdkV2.asAddress(tx, refundAddress),
+        tx.object.clock()
+      ]
+    });
+    const endpointCall = transactionResult[0];
+    await this.protocolSDK.getEndpoint().populateSendTransaction(tx, endpointCall, sender);
+    tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "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) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        const sendParamArg = lzSuiSdkV2.isTransactionArgument(sendParam) ? sendParam : __privateMethod(this, _OFT_instances, buildSendParam_fn).call(this, tx, sendParam);
+        tx.moveCall({
+          target: __privateMethod(this, _OFT_instances, target_fn).call(this, "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, sendParam, payInZro) {
+    const tx = new transactions.Transaction();
+    const sendParamArg = lzSuiSdkV2.isTransactionArgument(sendParam) ? sendParam : __privateMethod(this, _OFT_instances, buildSendParam_fn).call(this, tx, sendParam);
+    const quoteCall = tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "quote_send"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), lzSuiSdkV2.asAddress(tx, sender), sendParamArg, lzSuiSdkV2.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) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "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() {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.oftVersionMoveCall(tx);
+      },
+      (result) => {
+        const major = Number(bcs.bcs.U64.parse(result[0].value));
+        const minor = Number(bcs.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) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "coin_metadata"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId)]
+    });
+  }
+  /**
+   * Get coin metadata address
+   * @returns Promise<string> - The coin metadata address
+   */
+  async coinMetadata() {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.coinMetadataMoveCall(tx);
+      },
+      (result) => bcs.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) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "admin"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId)]
+    });
+  }
+  /**
+   * Get OFT admin address
+   * @returns Promise<string> - The admin address
+   */
+  async admin() {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.adminMoveCall(tx);
+      },
+      (result) => bcs.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) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "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() {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.sharedDecimalsMoveCall(tx);
+      },
+      (result) => bcs.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) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "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() {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.isPausedMoveCall(tx);
+      },
+      (result) => bcs.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) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "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() {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.isAdapterMoveCall(tx);
+      },
+      (result) => bcs.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) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "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() {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.feeBpsMoveCall(tx);
+      },
+      (result) => BigInt(bcs.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) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "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() {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.feeDepositAddressMoveCall(tx);
+      },
+      (result) => bcs.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, eid, inbound) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "rate_limit_config"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), lzSuiSdkV2.asU32(tx, eid), lzSuiSdkV2.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, inbound) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.rateLimitConfigMoveCall(tx, eid, inbound);
+      },
+      (result) => {
+        const limit = BigInt(bcs.bcs.U64.parse(result[0].value));
+        const windowSeconds = BigInt(bcs.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, eid, inbound) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "rate_limit_in_flight"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), lzSuiSdkV2.asU32(tx, eid), lzSuiSdkV2.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, inbound) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.rateLimitInFlightMoveCall(tx, eid, inbound);
+      },
+      (result) => BigInt(bcs.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, eid, inbound) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "rate_limit_capacity"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), lzSuiSdkV2.asU32(tx, eid), lzSuiSdkV2.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, inbound) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.rateLimitCapacityMoveCall(tx, eid, inbound);
+      },
+      (result) => BigInt(bcs.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, eid, msgType, extraOptions) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "combine_options"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), lzSuiSdkV2.asU32(tx, eid), lzSuiSdkV2.asU16(tx, msgType), lzSuiSdkV2.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, msgType, extraOptions) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.combineOptionsMoveCall(tx, eid, msgType, extraOptions);
+      },
+      (result) => new Uint8Array(bcs.bcs.vector(bcs.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, eid, msgType) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "get_enforced_options"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), lzSuiSdkV2.asU32(tx, eid), lzSuiSdkV2.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, msgType) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.getEnforcedOptionsMoveCall(tx, eid, msgType);
+      },
+      (result) => new Uint8Array(bcs.bcs.vector(bcs.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, eid) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "has_peer"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), lzSuiSdkV2.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) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.hasPeerMoveCall(tx, eid);
+      },
+      (result) => bcs.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, eid) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFT_instances, target_fn).call(this, "get_peer"),
+      typeArguments: [this.coinType],
+      arguments: [tx.object(this.oftObjectId), lzSuiSdkV2.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) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        this.getPeerMoveCall(tx, eid);
+      },
+      (result) => {
+        return new Uint8Array(bcs.bcs.vector(bcs.bcs.u8()).parse(result[0].value));
+      }
+    );
+  }
+};
+_OFT_instances = new WeakSet();
+// ==========================================
+// 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_fn = function(tx, param) {
+  return tx.moveCall({
+    target: __privateMethod(this, _OFT_instances, target_fn).call(this, "create", "send_param"),
+    arguments: [
+      lzSuiSdkV2.asU32(tx, param.dstEid),
+      lzSuiSdkV2.asBytes32(tx, param.to, this.protocolSDK.getUtils()),
+      lzSuiSdkV2.asU64(tx, param.amountLd),
+      lzSuiSdkV2.asU64(tx, param.minAmountLd),
+      lzSuiSdkV2.asBytes(tx, param.extraOptions),
+      lzSuiSdkV2.asBytes(tx, param.composeMsg),
+      lzSuiSdkV2.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_fn = function(name, module_name = MODULE_NAME) {
+  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_fn = function() {
+  if (this.adminCapId === void 0) {
+    throw new Error("Admin cap ID not found");
+  }
+  return this.adminCapId;
+};
+var OFTComposerRegistryErrorCode = {
+  // OFT Composer Registry related errors
+  EComposeTransferNotFound: 1,
+  EDepositAddressNotFound: 2
+};
+var _OFTComposerRegistry_instances, target_fn2;
+var OFTComposerRegistry = class {
+  constructor(protocolSDK, packageId, registryObjectId) {
+    __privateAdd(this, _OFTComposerRegistry_instances);
+    this.client = protocolSDK.client;
+    this.protocolSDK = protocolSDK;
+    this.packageId = packageId;
+    this.registryObjectId = registryObjectId;
+  }
+  // === Set Functions ===
+  /**
+   * Set deposit address for OFT composer
+   * @param tx - The transaction to add the move call to
+   * @param composerCallCap - The composer call capability transaction result
+   * @param depositAddress - The new deposit address
+   * @returns Transaction result containing the set operation
+   */
+  setDepositAddressMoveCall(tx, composerCallCap, depositAddress) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFTComposerRegistry_instances, target_fn2).call(this, "set_deposit_address"),
+      arguments: [tx.object(this.registryObjectId), lzSuiSdkV2.asObject(tx, composerCallCap), lzSuiSdkV2.asAddress(tx, depositAddress)]
+    });
+  }
+  // === View Functions ===
+  /**
+   * Get deposit address for a composer
+   * @param tx - The transaction to add the move call to
+   * @param composer - The composer address
+   * @returns Transaction result containing the deposit address
+   */
+  getDepositAddressMoveCall(tx, composer) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFTComposerRegistry_instances, target_fn2).call(this, "get_deposit_address"),
+      arguments: [tx.object(this.registryObjectId), lzSuiSdkV2.asAddress(tx, composer)]
+    });
+  }
+  /**
+   * Get compose transfer object for composition operations
+   * @param tx - The transaction to add the move call to
+   * @param from - The sender address
+   * @param guid - The GUID transaction result
+   * @param composer - The composer address
+   * @returns Transaction result containing the compose transfer object
+   */
+  getComposeTransferMoveCall(tx, from, guid, composer) {
+    return tx.moveCall({
+      target: __privateMethod(this, _OFTComposerRegistry_instances, target_fn2).call(this, "get_compose_transfer"),
+      arguments: [
+        tx.object(this.registryObjectId),
+        lzSuiSdkV2.asAddress(tx, from),
+        lzSuiSdkV2.asBytes32(tx, guid, this.protocolSDK.getUtils()),
+        lzSuiSdkV2.asAddress(tx, composer)
+      ]
+    });
+  }
+  /**
+   * Get compose transfer object address
+   * @param from - The sender address
+   * @param guid - The GUID as number array
+   * @param composer - The composer address
+   * @returns Promise<string> - The compose transfer object address
+   */
+  async getComposeTransfer(from, guid, composer) {
+    return lzSuiSdkV2.executeSimulate(
+      this.client,
+      (tx) => {
+        return this.getComposeTransferMoveCall(
+          tx,
+          from,
+          lzSuiSdkV2.asBytes32(tx, guid, this.protocolSDK.getUtils()),
+          composer
+        );
+      },
+      (result) => {
+        const parsed = bcs.bcs.Address.parse(result[0].value);
+        return parsed;
+      }
+    );
+  }
+};
+_OFTComposerRegistry_instances = new WeakSet();
+// === Private Functions ===
+/**
+ * Generate the full target path for move calls
+ * @param func - The function name to call
+ * @returns The full module path for the move call
+ * @private
+ */
+target_fn2 = function(func) {
+  return `${this.packageId}::oft_composer_registry::${func}`;
+};
+var OFTPtbBuilder = class {
+  constructor(protocolSDK, packageId, objectId, client, coinType, oftObjectId) {
+    this.objects = protocolSDK.objects;
+    this.packageId = packageId;
+    this.objectId = objectId;
+    this.client = client;
+    this.coinType = coinType;
+    this.oftObjectId = oftObjectId;
+  }
+  /**
+   * 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 composerRegistry - The composer registry object ID for routing compose transfers
+   * @returns TransactionResult containing serialized execution metadata for endpoint registration
+   */
+  lzReceiveInfoMoveCall(tx, composerRegistry) {
+    return tx.moveCall({
+      target: `${this.packageId}::oft_ptb_builder::lz_receive_info`,
+      typeArguments: [this.coinType],
+      arguments: [
+        tx.object(this.objectId),
+        tx.object(this.oftObjectId),
+        tx.object(this.objects.endpointV2),
+        lzSuiSdkV2.asObject(tx, composerRegistry),
+        tx.object.clock()
+      ]
+    });
+  }
+};
+
+// src/types.ts
+var OFTMsgType = {
+  SEND: 1,
+  SEND_AND_CALL: 2
+};
+
+exports.OFT = OFT;
+exports.OFTComposerRegistry = OFTComposerRegistry;
+exports.OFTComposerRegistryErrorCode = OFTComposerRegistryErrorCode;
+exports.OFTErrorCode = OFTErrorCode;
+exports.OFTFeeDetailBcs = OFTFeeDetailBcs;
+exports.OFTLimitBcs = OFTLimitBcs;
+exports.OFTMsgType = OFTMsgType;
+exports.OFTPtbBuilder = OFTPtbBuilder;
+exports.OFTReceiptBcs = OFTReceiptBcs;
+exports.parseOFTFeeDetails = parseOFTFeeDetails;
+exports.parseOFTLimit = parseOFTLimit;
+exports.parseOFTReceipt = parseOFTReceipt;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map