@layerzerolabs/oft-iota-sdk 0.0.0-stage → 1.2.100

package/dist/LA2Z3PK4.js

@@ -0,0 +1,1296 @@
+import { parseOFTReceipt, parseOFTFeeDetails, parseOFTLimit, parseOFTInfoV1 } from './CDSWWWJ7.js';
+import { __name } from './VUOMXK5T.js';
+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 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 = class {
+  static {
+    __name(this, "OFT");
+  }
+  /** Iota client for blockchain interactions */
+  client;
+  /** The OFTCallCap ID */
+  oftCallCapId;
+  /** The package ID of the OFT */
+  oftPackageId;
+  /** LayerZero protocol object references (endpoint, messaging channels, etc.) */
+  objects;
+  /** The unique object ID of this OFT instance on Iota */
+  oftObjectId;
+  /** Admin capability object ID for privileged operations (retrieved dynamically when needed) */
+  adminCapId;
+  /** The Iota coin type this OFT represents (e.g., "0x123::mycoin::MYCOIN") */
+  coinType;
+  /** The unique object ID of the associated OApp instance on Iota */
+  oappObjectId;
+  /** Reference to the LayerZero protocol SDK for cross-chain operations */
+  protocolSDK;
+  /** The OFTInfoV1 structure */
+  oftInfo;
+  /**
+   * 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) {
+    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 this.#target("lz_receive_info", OFT_PTB_BUILDER_MODULE_NAME),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        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 this.#target("set_pause"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await 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
+   */
+  async setFeeDepositAddressMoveCall(tx, feeDepositAddress) {
+    tx.moveCall({
+      target: await this.#target("set_fee_deposit_address"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#adminCapId()),
+        asAddress(tx, feeDepositAddress)
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("set_default_fee_bps"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#adminCapId()),
+        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 this.#target("set_fee_bps"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#adminCapId()),
+        asU32(tx, dstEid),
+        asU64(tx, feeBps)
+      ]
+    });
+  }
+  /**
+   * Removes the fee rate for a specific destination chain
+   * @param tx - The transaction to add the move call to
+   * @param dstEid - Destination endpoint ID
+   */
+  async unsetFeeBpsMoveCall(tx, dstEid) {
+    tx.moveCall({
+      target: await this.#target("unset_fee_bps"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#adminCapId()),
+        asU32(tx, dstEid)
+      ]
+    });
+  }
+  // ==========================================
+  // 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 this.#target("migrate"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        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 this.#target("set_rate_limit"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await 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
+   */
+  async unsetRateLimitMoveCall(tx, eid, inbound) {
+    tx.moveCall({
+      target: await this.#target("unset_rate_limit"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await 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, owner, amount, limit = 200, pageSize = 50) {
+    return this.protocolSDK.getUtils().splitCoinMoveCall(tx, await 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 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 this.#buildSendParam(tx, sendParam);
+    const txSender = await this.txSenderMoveCall(tx);
+    const addressArg = isTransactionArgument(refundAddress) ? refundAddress : tx.pure.option("address", refundAddress);
+    const transactionResult = tx.moveCall({
+      target: await this.#target("send"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#oappObjectId()),
+        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 this.#target("confirm_send"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#oappObjectId()),
+        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 this.#target("lz_receive"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#oappObjectId()),
+        asObject(tx, call),
+        tx.object.clock()
+      ]
+    });
+  }
+  /**
+   * Process inbound cross-chain token transfers with compose functionality
+   * @param tx - The transaction to add the move call to
+   * @param composeQueue - The composer's message queue for sequencing operations
+   * @param composerManager - Manager managing token deposits for composers
+   * @param call - LayerZero receive call containing the verified cross-chain message
+   * @returns TransactionResult containing the processed transfer
+   */
+  async lzReceiveWithComposeMoveCall(tx, composeQueue, composerManager, call) {
+    return tx.moveCall({
+      target: await this.#target("lz_receive_with_compose"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#oappObjectId()),
+        asObject(tx, composeQueue),
+        asObject(tx, composerManager),
+        asObject(tx, call),
+        tx.object.clock()
+      ]
+    });
+  }
+  /**
+   * Confirms and extracts results from a quote operation
+   * @param tx - The transaction to add the move call to
+   * @param call - Completed Call object from quote_send() execution
+   * @returns TransactionResult containing the messaging fee
+   */
+  async confirmQuoteSendMoveCall(tx, call) {
+    return tx.moveCall({
+      target: await this.#target("confirm_quote_send"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#oappObjectId()),
+        asObject(tx, call)
+      ]
+    });
+  }
+  // ==========================================
+  // 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 this.#buildSendParam(tx, sendParam);
+      tx.moveCall({
+        target: await this.#target("quote_oft"),
+        typeArguments: [
+          await this.#coinType()
+        ],
+        arguments: [
+          tx.object(await 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
+   * @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 this.#buildSendParam(tx, sendParam);
+    const quoteCall = tx.moveCall({
+      target: await this.#target("quote_send"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        tx.object(await this.#oappObjectId()),
+        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 this.#target("upgrade_version"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("oapp_object"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("oft_version"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("oft_cap_id"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * Get the OFT capability ID
+   * @returns Promise<string> - The OFT capability ID
+   */
+  async oftCapId() {
+    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 this.#target("migration_cap"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("coin_metadata"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("admin_cap"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("shared_decimals"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("decimal_conversion_rate"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("is_paused"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("is_adapter"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await 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 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 this.#target("has_oft_fee"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        asU32(tx, dstEid)
+      ]
+    });
+  }
+  /**
+   * Check if the OFT has a fee rate greater than 0 for the specified destination
+   * @param dstEid - Destination endpoint ID
+   * @returns Promise<boolean> - True if fee exists
+   */
+  async hasOftFee(dstEid) {
+    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 this.#target("effective_fee_bps"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        asU32(tx, dstEid)
+      ]
+    });
+  }
+  /**
+   * Get the effective fee rate for a specific destination chain
+   * @param dstEid - Destination endpoint ID
+   * @returns Promise<bigint> - The effective fee in basis points
+   */
+  async effectiveFeeBps(dstEid) {
+    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 this.#target("default_fee_bps"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("fee_bps"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        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 this.#target("fee_deposit_address"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId())
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("rate_limit_config"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await 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, 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 this.#target("rate_limit_in_flight"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await this.#oftObjectId()),
+        asU32(tx, eid),
+        asBool(tx, inbound),
+        tx.object.clock()
+      ]
+    });
+  }
+  /**
+   * 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 this.#target("rate_limit_capacity"),
+      typeArguments: [
+        await this.#coinType()
+      ],
+      arguments: [
+        tx.object(await 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, 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 this.#target("tx_sender", OFT_SENDER_MODULE_NAME)
+    });
+  }
+  // ==========================================
+  // 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
+   */
+  async #buildSendParam(tx, param) {
+    return tx.moveCall({
+      target: await 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
+   */
+  async #target(name, module_name = MODULE_NAME) {
+    return `${await this.#oftPackageId()}::${module_name}::${name}`;
+  }
+  /**
+   * Get the OApp object ID, throwing an error if not available
+   * @returns The OApp object ID
+   * @throws Error if OApp object ID was not set
+   * @private
+   */
+  async #oappObjectId() {
+    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;
+  }
+  /**
+   * Get the OFT object ID, automatically retrieving it from the OFT info if not cached
+   * @returns The OFT object ID
+   * @throws Error if OFT object ID cannot be retrieved
+   * @private
+   */
+  async #oftObjectId() {
+    if (this.oftObjectId === void 0) {
+      const oftInfo = await this.#OftInfo();
+      this.oftObjectId = oftInfo.oftObject;
+    }
+    return this.oftObjectId;
+  }
+  /**
+   * Get the admin capability ID, automatically retrieving it from the OFT instance if not cached
+   * @returns The admin capability ID
+   * @throws Error if admin capability cannot be retrieved from the OFT instance
+   * @private
+   */
+  async #adminCapId() {
+    if (this.adminCapId === void 0) {
+      this.adminCapId = await this.adminCap();
+    }
+    return this.adminCapId;
+  }
+  /**
+   * Get the coin type, automatically extracting it from the OFT object if not cached
+   * @returns The coin type string (e.g., "0x123::mycoin::MYCOIN")
+   * @throws Error if coin type cannot be extracted from the OFT object
+   * @private
+   */
+  async #coinType() {
+    if (this.coinType === void 0) {
+      const oftInfo = await this.client.getObject({
+        id: await this.#oftObjectId(),
+        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;
+  }
+  /**
+   * Get OApp info, throwing if not set
+   * @returns The OApp info
+   * @throws Error if OApp info is not set
+   * @private
+   */
+  async #OftInfo() {
+    if (!this.oftInfo) {
+      const oappSdk = this.protocolSDK.getOApp(this.oftCallCapId);
+      this.oftInfo = await executeSimulate(this.client, (tx) => {
+        const oappInfo = oappSdk.getOAppInfoV1MoveCall(tx);
+        const extraInfo = oappSdk.getOAppInfoV1ExtraInfoMoveCall(tx, oappInfo);
+        this.decodeOftInfoV1MoveCall(tx, extraInfo);
+      }, (result) => parseOFTInfoV1(result[0].value));
+    }
+    return this.oftInfo;
+  }
+  /**
+   * Get the OFT package ID, automatically retrieving it from the OFT info if not cached
+   * @returns The OFT package ID
+   * @throws Error if OFT package ID cannot be retrieved
+   * @private
+   */
+  async #oftPackageId() {
+    if (this.oftPackageId === void 0) {
+      const oftInfo = await this.#OftInfo();
+      this.oftPackageId = oftInfo.oftPackage;
+    }
+    return this.oftPackageId;
+  }
+};
+
+export { OFT, OFTErrorCode };
+//# sourceMappingURL=LA2Z3PK4.js.map
+//# sourceMappingURL=LA2Z3PK4.js.map