@layerzerolabs/lz-iotal1-oft-sdk-v2 3.0.143

package/dist/index.mjs

@@ -0,0 +1,1312 @@
+import { bcs } from '@iota/iota-sdk/bcs';
+import { Transaction } from '@iota/iota-sdk/transactions';
+import { asObject, asU8, executeSimulate, asBytes, asBool, asAddress, asU64, asU32, isTransactionArgument, asArgWithTx, asArgWithTxAsync, asBytes32 } from '@layerzerolabs/lz-iotal1-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.struct("OFTLimit", {
+  min_amount_ld: bcs.U64,
+  max_amount_ld: bcs.U64
+});
+var OFTFeeDetailBcs = bcs.struct("OFTFeeDetail", {
+  fee_amount_ld: bcs.U64,
+  is_reward: bcs.Bool,
+  description: bcs.String
+});
+var OFTReceiptBcs = bcs.struct("OFTReceipt", {
+  amount_sent_ld: bcs.U64,
+  amount_received_ld: bcs.U64
+});
+var OFTInfoV1Bcs = bcs.struct("OFTInfoV1", {
+  oft_package: bcs.Address,
+  oft_object: bcs.Address
+});
+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.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)
+  };
+}
+function parseOFTInfoV1(data) {
+  const parsed = OFTInfoV1Bcs.parse(data);
+  return {
+    oftPackage: parsed.oft_package,
+    oftObject: parsed.oft_object
+  };
+}
+
+// src/modules/oft.ts
+var MODULE_NAME = "oft";
+var OFT_SENDER_MODULE_NAME = "oft_sender";
+var OFT_IMPL_MODULE_NAME = "oft_impl";
+var OFT_PTB_BUILDER_MODULE_NAME = "oft_ptb_builder";
+var OFTErrorCode = {
+  // OFT related errors
+  EComposeMsgNotAllowed: 1,
+  EComposeMsgRequired: 2,
+  EInsufficientBalance: 3,
+  EInvalidAdminCap: 4,
+  EInvalidComposeQueue: 5,
+  EInvalidLocalDecimals: 6,
+  EInvalidMigrationCap: 7,
+  EInvalidSendContext: 8,
+  ESlippageExceeded: 9,
+  EWrongPackageVersion: 10
+};
+var _OFT_instances, buildSendParam_fn, target_fn, oappObjectId_fn, oftObjectId_fn, adminCapId_fn, coinType_fn, OftInfo_fn, oftPackageId_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 oftCallCapId - The OFT call capability ID used for OFT operations and accessing OFT information
+   * @param oftObjectId - Optional OFT object ID on Iota blockchain for direct OFT instance access
+   * @param coinType - Optional Iota coin type string (e.g., "0x123::mycoin::MYCOIN") that this OFT represents
+   * @param oappObjectId - Optional associated OApp object ID for cross-chain messaging operations
+   * @param adminCapId - Optional admin capability object ID for privileged operations
+   */
+  constructor(protocolSDK, oftCallCapId, oftObjectId, coinType, oappObjectId, adminCapId) {
+    __privateAdd(this, _OFT_instances);
+    this.protocolSDK = protocolSDK;
+    this.oftCallCapId = oftCallCapId;
+    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) {
+    this.oappObjectId = oappObjectId;
+  }
+  // ==========================================
+  // INITIALIZATION FUNCTIONS
+  // ==========================================
+  // These functions are used to initialize OFT instances from OFTCreationTicket
+  /**
+   * Initialize an OFT instance with a treasury capability
+   * Creates a new OFT that mints its own tokens
+   * @param tx - The transaction to add the move call to
+   * @param coinType - The Iota coin type string (e.g., "0x123::mycoin::MYCOIN")
+   * @param ticket - The OFTCreationTicket object ID or TransactionArgument
+   * @param oapp - The OApp object ID or TransactionArgument
+   * @param treasury - The TreasuryCap object ID or TransactionArgument for the coin type
+   * @param metadata - The CoinMetadata object ID or TransactionArgument for the coin type
+   * @param sharedDecimals - Number of decimals to use for cross-chain operations
+   * @returns TransactionResult array containing [AdminCap, MigrationCap] - MigrationCap must be transferred or stored
+   */
+  initOftMoveCall(tx, coinType, ticket, oapp, treasury, metadata, sharedDecimals) {
+    return tx.moveCall({
+      target: `${this.oftCallCapId}::${OFT_IMPL_MODULE_NAME}::init_oft`,
+      typeArguments: [coinType],
+      arguments: [
+        asObject(tx, ticket),
+        asObject(tx, oapp),
+        asObject(tx, treasury),
+        asObject(tx, metadata),
+        asU8(tx, sharedDecimals)
+      ]
+    });
+  }
+  /**
+   * Initialize an OFT adapter instance
+   * Creates an OFT adapter that wraps an existing coin type
+   * @param tx - The transaction to add the move call to
+   * @param coinType - The Iota coin type string (e.g., "0x123::mycoin::MYCOIN")
+   * @param ticket - The OFTCreationTicket object ID or TransactionArgument
+   * @param oapp - The OApp object ID or TransactionArgument
+   * @param metadata - The CoinMetadata object ID or TransactionArgument for the coin type
+   * @param sharedDecimals - Number of decimals to use for cross-chain operations
+   * @returns TransactionResult array containing [AdminCap, MigrationCap] - MigrationCap must be transferred or stored
+   */
+  initOftAdapterMoveCall(tx, coinType, ticket, oapp, metadata, sharedDecimals) {
+    return tx.moveCall({
+      target: `${this.oftCallCapId}::${OFT_IMPL_MODULE_NAME}::init_oft_adapter`,
+      typeArguments: [coinType],
+      arguments: [asObject(tx, ticket), asObject(tx, oapp), asObject(tx, metadata), asU8(tx, sharedDecimals)]
+    });
+  }
+  // ==========================================
+  // ADMIN FUNCTIONS
+  // ==========================================
+  // These functions require admin privileges and are used for OFT configuration
+  // and management. The admin capability is automatically retrieved from the OFT instance.
+  /**
+   * 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 composerManager - The composer manager object ID for routing compose transfers
+   * @returns TransactionResult containing serialized execution metadata for endpoint registration
+   */
+  async lzReceiveInfoMoveCall(tx, composerManager) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "lz_receive_info", OFT_PTB_BUILDER_MODULE_NAME),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(this.objects.endpointV2),
+        asObject(tx, composerManager),
+        tx.object.clock()
+      ]
+    });
+  }
+  /**
+   * Register OFT as an OApp with LayerZero endpoint
+   * @param tx - The transaction to add the move call to
+   * @param coinType - The Iota coin type string (e.g., "0x123::mycoin::MYCOIN")
+   * @param oftObjectId - The OFT object ID
+   * @param oappObjectId - The OApp object ID
+   * @param composerManager - The composer manager object ID or TransactionArgument
+   * @param lzReceiveInfo - Optional LayerZero receive info as Uint8Array or TransactionArgument
+   */
+  async registerOAppMoveCall(tx, coinType, oftObjectId, oappObjectId, composerManager, lzReceiveInfo) {
+    const adminCapId = await executeSimulate(
+      this.client,
+      (tx2) => {
+        tx2.moveCall({
+          target: `${this.oftCallCapId}::${MODULE_NAME}::admin_cap`,
+          typeArguments: [coinType],
+          arguments: [tx2.object(oftObjectId)]
+        });
+      },
+      (result) => bcs.Address.parse(result[0].value)
+    );
+    if (lzReceiveInfo === void 0) {
+      lzReceiveInfo = tx.moveCall({
+        target: `${this.oftCallCapId}::${OFT_PTB_BUILDER_MODULE_NAME}::lz_receive_info`,
+        typeArguments: [coinType],
+        arguments: [
+          tx.object(oftObjectId),
+          tx.object(this.objects.endpointV2),
+          asObject(tx, composerManager),
+          tx.object.clock()
+        ]
+      });
+    }
+    tx.moveCall({
+      target: `${this.oftCallCapId}::${MODULE_NAME}::register_oapp`,
+      typeArguments: [coinType],
+      arguments: [
+        tx.object(oftObjectId),
+        tx.object(oappObjectId),
+        tx.object(adminCapId),
+        tx.object(this.objects.endpointV2),
+        asBytes(tx, lzReceiveInfo)
+      ]
+    });
+  }
+  /**
+   * Set pause state for OFT operations
+   * @param tx - The transaction to add the move call to
+   * @param pause - Whether to pause or unpause operations
+   */
+  async setPauseMoveCall(tx, pause) {
+    tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "set_pause"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), tx.object(await __privateMethod(this, _OFT_instances, adminCapId_fn).call(this)), 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
+   */
+  async setFeeDepositAddressMoveCall(tx, feeDepositAddress) {
+    tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "set_fee_deposit_address"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        asAddress(tx, feeDepositAddress)
+      ]
+    });
+  }
+  /**
+   * Set default fee basis points for OFT transfers
+   * @param tx - The transaction to add the move call to
+   * @param feeBps - Default fee rate in basis points (0-10,000, where 10,000 = 100%)
+   */
+  async setDefaultFeeBpsMoveCall(tx, feeBps) {
+    tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "set_default_fee_bps"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), tx.object(await __privateMethod(this, _OFT_instances, adminCapId_fn).call(this)), asU64(tx, feeBps)]
+    });
+  }
+  /**
+   * Set fee basis points for a specific destination chain
+   * @param tx - The transaction to add the move call to
+   * @param dstEid - Destination endpoint ID
+   * @param feeBps - Fee rate in basis points (0-10,000, where 10,000 = 100%)
+   */
+  async setFeeBpsMoveCall(tx, dstEid, feeBps) {
+    tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "set_fee_bps"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        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
+   */
+  async unsetFeeBpsMoveCall(tx, dstEid) {
+    tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "unset_fee_bps"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), tx.object(await __privateMethod(this, _OFT_instances, adminCapId_fn).call(this)), 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
+   */
+  async migrateMoveCall(tx, migrationCap) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "migrate"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), asObject(tx, migrationCap)]
+    });
+  }
+  // ==========================================
+  // 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
+   */
+  async setRateLimitMoveCall(tx, eid, inbound, rateLimit, windowSeconds) {
+    tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "set_rate_limit"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        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
+   */
+  async unsetRateLimitMoveCall(tx, eid, inbound) {
+    tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "unset_rate_limit"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, adminCapId_fn).call(this)),
+        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, owner, amount, limit = 200, pageSize = 50) {
+    return this.protocolSDK.getUtils().splitCoinMoveCall(tx, await __privateMethod(this, _OFT_instances, coinType_fn).call(this), 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 sendParam - Send parameters including destination and amounts
+   * @param coinProvided - Coin object ID or transaction result to send
+   * @param nativeFee - Native token fee amount
+   * @param zroFee - ZRO token fee amount
+   * @param refundAddress - Address for fee refunds
+   * @param validators - Optional PTB validators for transaction validation
+   * @param maxSimulationTimes - Optional maximum number of simulation attempts
+   * @returns Promise<void> - Completes when the send operation is processed
+   */
+  async sendMoveCall(tx, sender, sendParam, coinProvided, nativeFee, zroFee, refundAddress, validators, maxSimulationTimes) {
+    const sendParamArg = isTransactionArgument(sendParam) ? sendParam : await __privateMethod(this, _OFT_instances, buildSendParam_fn).call(this, tx, sendParam);
+    const txSender = await this.txSenderMoveCall(tx);
+    const addressArg = isTransactionArgument(refundAddress) ? refundAddress : tx.pure.option("address", refundAddress);
+    const transactionResult = tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "send"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, oappObjectId_fn).call(this)),
+        txSender,
+        sendParamArg,
+        asObject(tx, coinProvided),
+        asArgWithTx(tx, nativeFee, (tx2, val) => tx2.splitCoins(tx2.gas, [asU64(tx2, val)])[0]),
+        await asArgWithTxAsync(
+          tx,
+          zroFee,
+          async (tx2, val) => this.protocolSDK.getZro().splitOptionZroTokenMoveCall(tx2, sender, val)
+        ),
+        addressArg,
+        tx.object.clock()
+      ]
+    });
+    const endpointCall = transactionResult[0];
+    const oftSendContext = transactionResult[1];
+    await this.protocolSDK.getEndpoint().populateSendTransaction(
+      tx,
+      endpointCall,
+      sender,
+      validators,
+      maxSimulationTimes
+    );
+    const confirmSendResult = tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "confirm_send"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, oappObjectId_fn).call(this)),
+        txSender,
+        endpointCall,
+        oftSendContext
+      ]
+    });
+    const nativeCoin = confirmSendResult[2];
+    const zroCoin = confirmSendResult[3];
+    tx.moveCall({
+      target: "0x1::option::destroy_none",
+      arguments: [nativeCoin],
+      typeArguments: [`0x2::coin::Coin<0x2::iota::IOTA>`]
+    });
+    tx.moveCall({
+      target: "0x1::option::destroy_none",
+      arguments: [zroCoin],
+      typeArguments: [`0x2::coin::Coin<${this.protocolSDK.getZro().zroType}>`]
+    });
+  }
+  /**
+   * 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
+   */
+  async lzReceiveMoveCall(tx, call) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "lz_receive"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, oappObjectId_fn).call(this)),
+        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
+   */
+  async lzReceiveWithComposeMoveCall(tx, composeQueue, composerManager, call) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "lz_receive_with_compose"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, oappObjectId_fn).call(this)),
+        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
+   */
+  async confirmQuoteSendMoveCall(tx, call) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "confirm_quote_send"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, oappObjectId_fn).call(this)),
+        asObject(tx, call)
+      ]
+    });
+  }
+  // ==========================================
+  // 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 executeSimulate(
+      this.client,
+      async (tx) => {
+        const sendParamArg = isTransactionArgument(sendParam) ? sendParam : await __privateMethod(this, _OFT_instances, buildSendParam_fn).call(this, tx, sendParam);
+        tx.moveCall({
+          target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "quote_oft"),
+          typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+          arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), 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
+   * @param validators - Optional PTB validators for transaction validation
+   * @param maxSimulationTimes - Optional maximum number of simulation attempts
+   * @returns Promise<MessagingFee> - The calculated messaging fees
+   */
+  async quoteSend(sender, sendParam, payInZro, validators, maxSimulationTimes) {
+    const tx = new Transaction();
+    const sendParamArg = isTransactionArgument(sendParam) ? sendParam : await __privateMethod(this, _OFT_instances, buildSendParam_fn).call(this, tx, sendParam);
+    const quoteCall = tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "quote_send"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [
+        tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)),
+        tx.object(await __privateMethod(this, _OFT_instances, oappObjectId_fn).call(this)),
+        asAddress(tx, sender),
+        sendParamArg,
+        asBool(tx, payInZro)
+      ]
+    });
+    return this.protocolSDK.getEndpoint().quote(tx, quoteCall, sender, validators, maxSimulationTimes);
+  }
+  // ==========================================
+  // VIEW FUNCTIONS
+  // ==========================================
+  // 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
+   */
+  async upgradeVersionMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "upgrade_version"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get the upgrade version of this OFT instance
+   * @returns Promise<bigint> - The upgrade version
+   */
+  async upgradeVersion() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async oappObjectMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "oapp_object"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get the associated OApp object address
+   * @returns Promise<string> - The OApp object address
+   */
+  async oappObject() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await this.oappObjectMoveCall(tx);
+      },
+      (result) => bcs.Address.parse(result[0].value)
+    );
+  }
+  /**
+   * Get OFT version information
+   * @param tx - The transaction to add the move call to
+   * @returns Transaction result containing version information
+   */
+  async oftVersionMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "oft_version"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get OFT version information
+   * @returns Promise<{ major: number; minor: number }> - The OFT version
+   */
+  async oftVersion() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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 the OFT capability ID
+   * @param tx - The transaction to add the move call to
+   * @returns Transaction result containing the OFT capability ID
+   */
+  async oftCapIdMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "oft_cap_id"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get the OFT capability ID
+   * @returns Promise<string> - The OFT capability ID
+   */
+  async oftCapId() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async migrationCapMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "migration_cap"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get the migration capability address for this OFT
+   * @returns Promise<string> - The migration capability address
+   */
+  async migrationCap() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await this.migrationCapMoveCall(tx);
+      },
+      (result) => bcs.Address.parse(result[0].value)
+    );
+  }
+  async messagingChannel() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        const oftCapId = await this.oftCapIdMoveCall(tx);
+        this.protocolSDK.getEndpoint().getMessagingChannelMoveCall(tx, oftCapId);
+      },
+      (result) => bcs.Address.parse(result[0].value)
+    );
+  }
+  /**
+   * Get coin metadata address
+   * @param tx - The transaction to add the move call to
+   * @returns Transaction result containing coin metadata address
+   */
+  async coinMetadataMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "coin_metadata"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get coin metadata address
+   * @returns Promise<string> - The coin metadata address
+   */
+  async coinMetadata() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await this.coinMetadataMoveCall(tx);
+      },
+      (result) => bcs.Address.parse(result[0].value)
+    );
+  }
+  /**
+   * Get OFT admin capability address
+   * @param tx - The transaction to add the move call to
+   * @returns Transaction result containing the admin capability address
+   */
+  async adminCapMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "admin_cap"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get OFT admin capability address
+   * @returns Promise<string> - The admin capability address
+   */
+  async adminCap() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await this.adminCapMoveCall(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
+   */
+  async sharedDecimalsMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "shared_decimals"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get shared decimals for cross-chain compatibility
+   * @returns Promise<number> - The shared decimal precision
+   */
+  async sharedDecimals() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await this.sharedDecimalsMoveCall(tx);
+      },
+      (result) => bcs.U8.parse(result[0].value)
+    );
+  }
+  /**
+   * 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
+   */
+  async decimalConversionRateMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "decimal_conversion_rate"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get the decimal conversion rate for this OFT
+   * @returns Promise<bigint> - The decimal conversion rate multiplier
+   */
+  async decimalConversionRate() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   * @returns Transaction result containing the paused status
+   */
+  async isPausedMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "is_paused"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Check if OFT is paused
+   * @returns Promise<boolean> - True if OFT is paused
+   */
+  async isPaused() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async isAdapterMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "is_adapter"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Check if this OFT is an adapter (wraps existing token)
+   * @returns Promise<boolean> - True if this is an OFT adapter
+   */
+  async isAdapter() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await this.isAdapterMoveCall(tx);
+      },
+      (result) => bcs.Bool.parse(result[0].value)
+    );
+  }
+  /**
+   * Decode OFTInfoV1 from encoded bytes
+   * @param tx - The transaction to add the move call to
+   * @param encodedBytes - The encoded OFTInfoV1 bytes to decode
+   * @returns Transaction result containing the decoded OFTInfoV1
+   */
+  decodeOftInfoV1MoveCall(tx, encodedBytes) {
+    return tx.moveCall({
+      target: `${this.oftCallCapId}::oft_info_v1::decode`,
+      arguments: [asBytes(tx, encodedBytes)]
+    });
+  }
+  /**
+   * Decode OFTInfoV1 from encoded bytes
+   * @param encodedBytes - The encoded OFTInfoV1 bytes to decode
+   * @returns Promise<OFTInfoV1> - The decoded OFTInfoV1 structure
+   */
+  async decodeOftInfoV1(encodedBytes) {
+    return executeSimulate(
+      this.client,
+      (tx) => {
+        this.decodeOftInfoV1MoveCall(tx, encodedBytes);
+      },
+      (result) => parseOFTInfoV1(result[0].value)
+    );
+  }
+  // ==========================================
+  // FEE VIEW FUNCTIONS
+  // ==========================================
+  // Query current fee configuration and settings
+  /**
+   * 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
+   */
+  async hasOftFeeMoveCall(tx, dstEid) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "has_oft_fee"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), 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) {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async effectiveFeeBpsMoveCall(tx, dstEid) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "effective_fee_bps"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), 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) {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async defaultFeeBpsMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "default_fee_bps"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get the default fee rate
+   * @returns Promise<bigint> - The default fee in basis points
+   */
+  async defaultFeeBps() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async feeBpsMoveCall(tx, dstEid) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "fee_bps"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), asU32(tx, dstEid)]
+    });
+  }
+  /**
+   * Get fee basis points for a specific destination chain
+   * @param dstEid - Destination endpoint ID
+   * @returns Promise<bigint> - The fee in basis points
+   */
+  async feeBps(dstEid) {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await this.feeBpsMoveCall(tx, dstEid);
+      },
+      (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
+   */
+  async feeDepositAddressMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "fee_deposit_address"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this))]
+    });
+  }
+  /**
+   * Get fee deposit address for OFT
+   * @returns Promise<string> - The fee deposit address
+   */
+  async feeDepositAddress() {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async rateLimitConfigMoveCall(tx, eid, inbound) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "rate_limit_config"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), 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, inbound) {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async rateLimitInFlightMoveCall(tx, eid, inbound) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "rate_limit_in_flight"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), 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, inbound) {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await 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
+   */
+  async rateLimitCapacityMoveCall(tx, eid, inbound) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "rate_limit_capacity"),
+      typeArguments: [await __privateMethod(this, _OFT_instances, coinType_fn).call(this)],
+      arguments: [tx.object(await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this)), 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, inbound) {
+    return executeSimulate(
+      this.client,
+      async (tx) => {
+        await this.rateLimitCapacityMoveCall(tx, eid, inbound);
+      },
+      (result) => BigInt(bcs.U64.parse(result[0].value))
+    );
+  }
+  // ==========================================
+  // OFT SENDER
+  // ==========================================
+  /**
+   * Create a transaction sender object for OFT operations
+   * @param tx - The transaction to add the move call to
+   * @returns Transaction result containing the transaction sender object
+   */
+  async txSenderMoveCall(tx) {
+    return tx.moveCall({
+      target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "tx_sender", OFT_SENDER_MODULE_NAME)
+    });
+  }
+};
+_OFT_instances = new WeakSet();
+buildSendParam_fn = async function(tx, param) {
+  return tx.moveCall({
+    target: await __privateMethod(this, _OFT_instances, target_fn).call(this, "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)
+    ]
+  });
+};
+target_fn = async function(name, module_name = MODULE_NAME) {
+  return `${await __privateMethod(this, _OFT_instances, oftPackageId_fn).call(this)}::${module_name}::${name}`;
+};
+oappObjectId_fn = async function() {
+  if (this.oappObjectId === void 0) {
+    const oappSdk = this.protocolSDK.getOApp(this.oftCallCapId);
+    const oappInfo = await oappSdk.getOAppInfoV1();
+    this.oappObjectId = oappInfo.oapp_object;
+  }
+  return this.oappObjectId;
+};
+oftObjectId_fn = async function() {
+  if (this.oftObjectId === void 0) {
+    const oftInfo = await __privateMethod(this, _OFT_instances, OftInfo_fn).call(this);
+    this.oftObjectId = oftInfo.oftObject;
+  }
+  return this.oftObjectId;
+};
+adminCapId_fn = async function() {
+  if (this.adminCapId === void 0) {
+    this.adminCapId = await this.adminCap();
+  }
+  return this.adminCapId;
+};
+coinType_fn = async function() {
+  if (this.coinType === void 0) {
+    const oftInfo = await this.client.getObject({
+      id: await __privateMethod(this, _OFT_instances, oftObjectId_fn).call(this),
+      options: {
+        showContent: true
+      }
+    });
+    const content = oftInfo.data?.content;
+    if (content?.dataType !== "moveObject" || content.type == null || content.type.length === 0) {
+      throw new Error("Invalid OFT object data or missing type field");
+    }
+    const typeStr = content.type;
+    const angleBracketMatch = typeStr.match(/<([^>]+)>/);
+    const coinType = angleBracketMatch?.[1];
+    if (coinType === void 0 || coinType === "") {
+      throw new Error("Failed to extract coinType from object type");
+    }
+    this.coinType = coinType;
+  }
+  return this.coinType;
+};
+OftInfo_fn = async function() {
+  if (!this.oftInfo) {
+    const oappSdk = this.protocolSDK.getOApp(this.oftCallCapId);
+    this.oftInfo = await executeSimulate(
+      this.client,
+      (tx) => {
+        const oappInfo = oappSdk.getOAppInfoV1MoveCall(tx);
+        const extraInfo = oappSdk.getOAppInfoV1ExtraInfoMoveCall(tx, oappInfo);
+        this.decodeOftInfoV1MoveCall(tx, extraInfo);
+      },
+      (result) => parseOFTInfoV1(result[0].value)
+    );
+  }
+  return this.oftInfo;
+};
+oftPackageId_fn = async function() {
+  if (this.oftPackageId === void 0) {
+    const oftInfo = await __privateMethod(this, _OFT_instances, OftInfo_fn).call(this);
+    this.oftPackageId = oftInfo.oftPackage;
+  }
+  return this.oftPackageId;
+};
+var OFTComposerManagerErrorCode = {
+  // OFT Composer Manager related errors
+  EComposeTransferNotFound: 1,
+  EDepositAddressNotFound: 2
+};
+var _OFTComposerManager_instances, target_fn2;
+var OFTComposerManager = class {
+  constructor(protocolSDK, packageId, registryObjectId) {
+    __privateAdd(this, _OFTComposerManager_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, _OFTComposerManager_instances, target_fn2).call(this, "set_deposit_address"),
+      arguments: [tx.object(this.registryObjectId), asObject(tx, composerCallCap), 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, _OFTComposerManager_instances, target_fn2).call(this, "get_deposit_address"),
+      arguments: [tx.object(this.registryObjectId), 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, _OFTComposerManager_instances, target_fn2).call(this, "get_compose_transfer"),
+      arguments: [
+        tx.object(this.registryObjectId),
+        asAddress(tx, from),
+        asBytes32(tx, guid, this.protocolSDK.getUtils()),
+        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 executeSimulate(
+      this.client,
+      (tx) => {
+        return this.getComposeTransferMoveCall(
+          tx,
+          from,
+          asBytes32(tx, guid, this.protocolSDK.getUtils()),
+          composer
+        );
+      },
+      (result) => {
+        const parsed = bcs.Address.parse(result[0].value);
+        return parsed;
+      }
+    );
+  }
+};
+_OFTComposerManager_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_manager::${func}`;
+};
+
+// src/types.ts
+var OFTMsgType = {
+  SEND: 1,
+  SEND_AND_CALL: 2
+};
+
+export { OFT, OFTComposerManager, OFTComposerManagerErrorCode, OFTErrorCode, OFTFeeDetailBcs, OFTInfoV1Bcs, OFTLimitBcs, OFTMsgType, OFTReceiptBcs, parseOFTFeeDetails, parseOFTInfoV1, parseOFTLimit, parseOFTReceipt };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map