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

package/dist/index.d.mts

@@ -0,0 +1,619 @@
+import { IotaClient } from '@iota/iota-sdk/client';
+import { Transaction, TransactionArgument, TransactionResult } from '@iota/iota-sdk/transactions';
+import { SDK, IPTBValidator, MessagingFee } from '@layerzerolabs/lz-iotal1-sdk-v2';
+import * as _iota_iota_sdk_dist_cjs_bcs from '@iota/iota-sdk/dist/cjs/bcs';
+
+declare const OFTMsgType: {
+    readonly SEND: 1;
+    readonly SEND_AND_CALL: 2;
+};
+interface SendParam {
+    dstEid: number;
+    to: Uint8Array;
+    amountLd: bigint;
+    minAmountLd: bigint;
+    extraOptions: Uint8Array;
+    composeMsg: Uint8Array;
+    oftCmd: Uint8Array;
+}
+interface OFTLimit {
+    minAmountLd: bigint;
+    maxAmountLd: bigint;
+}
+interface OFTFeeDetail {
+    feeAmountLd: bigint;
+    description: string;
+}
+interface OFTReceipt {
+    amountSentLd: bigint;
+    amountReceivedLd: bigint;
+}
+interface OFTInfoV1 {
+    oftPackage: string;
+    oftObject: string;
+}
+
+declare const OFTErrorCode: {
+    readonly EComposeMsgNotAllowed: 1;
+    readonly EComposeMsgRequired: 2;
+    readonly EInsufficientBalance: 3;
+    readonly EInvalidAdminCap: 4;
+    readonly EInvalidComposeQueue: 5;
+    readonly EInvalidLocalDecimals: 6;
+    readonly EInvalidMigrationCap: 7;
+    readonly EInvalidSendContext: 8;
+    readonly ESlippageExceeded: 9;
+    readonly EWrongPackageVersion: 10;
+};
+/**
+ * OFT (Omnichain Fungible Token) Class
+ *
+ * The OFT class provides a comprehensive interface for interacting with LayerZero's
+ * Omnichain Fungible Token standard on the Iota blockchain. OFTs enable seamless
+ * cross-chain token transfers while maintaining fungibility across multiple networks.
+ *
+ * @example
+ * ```typescript
+ * // Initialize OFT instance
+ * const oft = new OFT(protocolSDK, oftCallCapId);
+ *
+ * // Send tokens cross-chain
+ * const tx = new Transaction();
+ * const coin = await oft.splitCoinMoveCall(tx, sender, amount);
+ * await oft.sendMoveCall(tx, sender, sendParam, coin, nativeFee, zroFee, refundAddress);
+ * tx.transferObjects([coin], sender);
+ * ...
+ *
+ * // Quote transfer fees
+ * const fees = await oft.quoteSend(sender, sendParam, payInZro);
+ * ```
+ */
+declare class OFT {
+    #private;
+    /** Iota client for blockchain interactions */
+    readonly client: IotaClient;
+    /** The OFTCallCap ID */
+    readonly oftCallCapId: string;
+    /** The package ID of the OFT */
+    private oftPackageId?;
+    /** LayerZero protocol object references (endpoint, messaging channels, etc.) */
+    private readonly objects;
+    /** The unique object ID of this OFT instance on Iota */
+    private oftObjectId?;
+    /** Admin capability object ID for privileged operations (retrieved dynamically when needed) */
+    private adminCapId?;
+    /** The Iota coin type this OFT represents (e.g., "0x123::mycoin::MYCOIN") */
+    private coinType?;
+    /** The unique object ID of the associated OApp instance on Iota */
+    private oappObjectId?;
+    /** Reference to the LayerZero protocol SDK for cross-chain operations */
+    private readonly protocolSDK;
+    /** The OFTInfoV1 structure */
+    private 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: SDK, oftCallCapId: string, oftObjectId?: string, coinType?: string, oappObjectId?: string, // the associated oapp object id
+    adminCapId?: string);
+    /**
+     * Updates the associated OApp object ID
+     * @param oappObjectId - The new OApp object ID
+     */
+    setOappObjectId(oappObjectId: string): void;
+    /**
+     * 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: Transaction, coinType: string, ticket: string | TransactionArgument, oapp: string | TransactionArgument, treasury: string | TransactionArgument, metadata: string | TransactionArgument, sharedDecimals: number | TransactionArgument): TransactionResult;
+    /**
+     * 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: Transaction, coinType: string, ticket: string | TransactionArgument, oapp: string | TransactionArgument, metadata: string | TransactionArgument, sharedDecimals: number | TransactionArgument): TransactionResult;
+    /**
+     * 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
+     */
+    lzReceiveInfoMoveCall(tx: Transaction, composerManager: string | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * 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
+     */
+    registerOAppMoveCall(tx: Transaction, coinType: string, oftObjectId: string, oappObjectId: string, composerManager: string | TransactionArgument, lzReceiveInfo?: Uint8Array | TransactionArgument): Promise<void>;
+    /**
+     * Set pause state for OFT operations
+     * @param tx - The transaction to add the move call to
+     * @param pause - Whether to pause or unpause operations
+     */
+    setPauseMoveCall(tx: Transaction, pause: boolean | TransactionArgument): Promise<void>;
+    /**
+     * Set fee deposit address for OFT fees
+     * @param tx - The transaction to add the move call to
+     * @param feeDepositAddress - The new fee deposit address
+     */
+    setFeeDepositAddressMoveCall(tx: Transaction, feeDepositAddress: string | TransactionArgument): Promise<void>;
+    /**
+     * 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%)
+     */
+    setDefaultFeeBpsMoveCall(tx: Transaction, feeBps: bigint | number | string | TransactionArgument): Promise<void>;
+    /**
+     * 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%)
+     */
+    setFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument, feeBps: bigint | number | string | TransactionArgument): Promise<void>;
+    /**
+     * Removes the fee rate for a specific destination chain
+     * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
+     */
+    unsetFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<void>;
+    /**
+     * Migrate OFT instance to a new contract
+     * @param tx - The transaction to add the move call to
+     * @param migrationCap - Migration capability object ID or transaction argument
+     * @returns TransactionResult containing the migration ticket
+     */
+    migrateMoveCall(tx: Transaction, migrationCap: string | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * Set rate limit for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @param rateLimit - Rate limit amount
+     * @param windowSeconds - Time window in seconds
+     */
+    setRateLimitMoveCall(tx: Transaction, eid: number | TransactionArgument, inbound: boolean | TransactionArgument, rateLimit: bigint | number | string | TransactionArgument, windowSeconds: bigint | number | string | TransactionArgument): Promise<void>;
+    /**
+     * Remove rate limit for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     */
+    unsetRateLimitMoveCall(tx: Transaction, eid: number | TransactionArgument, inbound: boolean | TransactionArgument): Promise<void>;
+    /**
+     * 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
+     */
+    splitCoinMoveCall(tx: Transaction, owner: string, amount: bigint, limit?: number, pageSize?: number): Promise<TransactionResult>;
+    /**
+     * 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
+     */
+    sendMoveCall(tx: Transaction, sender: string, sendParam: SendParam | TransactionArgument, coinProvided: string | TransactionArgument, nativeFee: bigint | TransactionArgument, zroFee: bigint | TransactionArgument, refundAddress: string | TransactionArgument, validators?: IPTBValidator[], maxSimulationTimes?: number): Promise<void>;
+    /**
+     * Process inbound cross-chain token transfers
+     * @param tx - The transaction to add the move call to
+     * @param call - LayerZero receive call containing the verified cross-chain message
+     * @returns TransactionResult containing the processed transfer
+     */
+    lzReceiveMoveCall(tx: Transaction, call: string | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * Process inbound cross-chain token transfers with compose functionality
+     * @param tx - The transaction to add the move call to
+     * @param composeQueue - The composer's message queue for sequencing operations
+     * @param composerManager - Manager managing token deposits for composers
+     * @param call - LayerZero receive call containing the verified cross-chain message
+     * @returns TransactionResult containing the processed transfer
+     */
+    lzReceiveWithComposeMoveCall(tx: Transaction, composeQueue: string | TransactionArgument, composerManager: string | TransactionArgument, call: string | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * Confirms and extracts results from a quote operation
+     * @param tx - The transaction to add the move call to
+     * @param call - Completed Call object from quote_send() execution
+     * @returns TransactionResult containing the messaging fee
+     */
+    confirmQuoteSendMoveCall(tx: Transaction, call: string | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * 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
+     */
+    quoteOft(sendParam: SendParam | TransactionArgument): Promise<{
+        limit: OFTLimit;
+        feeDetails: OFTFeeDetail[];
+        receipt: OFTReceipt;
+    }>;
+    /**
+     * 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
+     */
+    quoteSend(sender: string, sendParam: SendParam | TransactionArgument, payInZro: boolean | TransactionArgument, validators?: IPTBValidator[], maxSimulationTimes?: number): Promise<MessagingFee>;
+    /**
+     * Get the upgrade version of this OFT instance
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the upgrade version
+     */
+    upgradeVersionMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get the upgrade version of this OFT instance
+     * @returns Promise<bigint> - The upgrade version
+     */
+    upgradeVersion(): Promise<bigint>;
+    /**
+     * Get the associated OApp object address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the OApp object address
+     */
+    oappObjectMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get the associated OApp object address
+     * @returns Promise<string> - The OApp object address
+     */
+    oappObject(): Promise<string>;
+    /**
+     * Get OFT version information
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing version information
+     */
+    oftVersionMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get OFT version information
+     * @returns Promise<{ major: number; minor: number }> - The OFT version
+     */
+    oftVersion(): Promise<{
+        major: number;
+        minor: number;
+    }>;
+    /**
+     * Get the OFT capability ID
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the OFT capability ID
+     */
+    oftCapIdMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get the OFT capability ID
+     * @returns Promise<string> - The OFT capability ID
+     */
+    oftCapId(): Promise<string>;
+    /**
+     * Get the migration capability address for this OFT
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the migration capability address
+     */
+    migrationCapMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get the migration capability address for this OFT
+     * @returns Promise<string> - The migration capability address
+     */
+    migrationCap(): Promise<string>;
+    messagingChannel(): Promise<string>;
+    /**
+     * Get coin metadata address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing coin metadata address
+     */
+    coinMetadataMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get coin metadata address
+     * @returns Promise<string> - The coin metadata address
+     */
+    coinMetadata(): Promise<string>;
+    /**
+     * Get OFT admin capability address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the admin capability address
+     */
+    adminCapMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get OFT admin capability address
+     * @returns Promise<string> - The admin capability address
+     */
+    adminCap(): Promise<string>;
+    /**
+     * Get shared decimals for cross-chain compatibility
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing shared decimals
+     */
+    sharedDecimalsMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get shared decimals for cross-chain compatibility
+     * @returns Promise<number> - The shared decimal precision
+     */
+    sharedDecimals(): Promise<number>;
+    /**
+     * Get the decimal conversion rate for this OFT
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the decimal conversion rate
+     */
+    decimalConversionRateMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get the decimal conversion rate for this OFT
+     * @returns Promise<bigint> - The decimal conversion rate multiplier
+     */
+    decimalConversionRate(): Promise<bigint>;
+    /**
+     * Check if OFT is paused
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the paused status
+     */
+    isPausedMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Check if OFT is paused
+     * @returns Promise<boolean> - True if OFT is paused
+     */
+    isPaused(): Promise<boolean>;
+    /**
+     * Check if this OFT is an adapter (wraps existing token)
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the adapter status
+     */
+    isAdapterMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Check if this OFT is an adapter (wraps existing token)
+     * @returns Promise<boolean> - True if this is an OFT adapter
+     */
+    isAdapter(): Promise<boolean>;
+    /**
+     * 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: Transaction, encodedBytes: Uint8Array | TransactionArgument): TransactionResult;
+    /**
+     * Decode OFTInfoV1 from encoded bytes
+     * @param encodedBytes - The encoded OFTInfoV1 bytes to decode
+     * @returns Promise<OFTInfoV1> - The decoded OFTInfoV1 structure
+     */
+    decodeOftInfoV1(encodedBytes: Uint8Array): Promise<OFTInfoV1>;
+    /**
+     * Check if the OFT has a fee rate greater than 0 for the specified destination
+     * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
+     * @returns Transaction result containing whether fee exists
+     */
+    hasOftFeeMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * 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
+     */
+    hasOftFee(dstEid: number): Promise<boolean>;
+    /**
+     * Get the effective fee rate for a specific destination chain
+     * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
+     * @returns Transaction result containing the effective fee basis points
+     */
+    effectiveFeeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * Get the effective fee rate for a specific destination chain
+     * @param dstEid - Destination endpoint ID
+     * @returns Promise<bigint> - The effective fee in basis points
+     */
+    effectiveFeeBps(dstEid: number): Promise<bigint>;
+    /**
+     * Get the default fee rate
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the default fee basis points
+     */
+    defaultFeeBpsMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get the default fee rate
+     * @returns Promise<bigint> - The default fee in basis points
+     */
+    defaultFeeBps(): Promise<bigint>;
+    /**
+     * Get fee basis points for a specific destination chain
+     * @param tx - The transaction to add the move call to
+     * @param dstEid - Destination endpoint ID
+     * @returns Transaction result containing the fee basis points
+     */
+    feeBpsMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * Get fee basis points for a specific destination chain
+     * @param dstEid - Destination endpoint ID
+     * @returns Promise<bigint> - The fee in basis points
+     */
+    feeBps(dstEid: number): Promise<bigint>;
+    /**
+     * Get fee deposit address for OFT
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the fee deposit address
+     */
+    feeDepositAddressMoveCall(tx: Transaction): Promise<TransactionResult>;
+    /**
+     * Get fee deposit address for OFT
+     * @returns Promise<string> - The fee deposit address
+     */
+    feeDepositAddress(): Promise<string>;
+    /**
+     * Get rate limit configuration for an endpoint
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Transaction result containing rate limit configuration
+     */
+    rateLimitConfigMoveCall(tx: Transaction, eid: number | TransactionArgument, inbound: boolean | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * 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
+     */
+    rateLimitConfig(eid: number, inbound: boolean): Promise<{
+        limit: bigint;
+        windowSeconds: bigint;
+    }>;
+    /**
+     * Get current in-flight amount for rate limiting
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Transaction result containing in-flight amount
+     */
+    rateLimitInFlightMoveCall(tx: Transaction, eid: number | TransactionArgument, inbound: boolean | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * 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
+     */
+    rateLimitInFlight(eid: number, inbound: boolean): Promise<bigint>;
+    /**
+     * Get rate limit capacity (remaining available amount)
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @returns Transaction result containing rate limit capacity
+     */
+    rateLimitCapacityMoveCall(tx: Transaction, eid: number | TransactionArgument, inbound: boolean | TransactionArgument): Promise<TransactionResult>;
+    /**
+     * 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
+     */
+    rateLimitCapacity(eid: number, inbound: boolean): Promise<bigint>;
+    /**
+     * 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
+     */
+    txSenderMoveCall(tx: Transaction): Promise<TransactionResult>;
+}
+
+declare const OFTComposerManagerErrorCode: {
+    readonly EComposeTransferNotFound: 1;
+    readonly EDepositAddressNotFound: 2;
+};
+/**
+ * OFT Composer Manager
+ *
+ * This class manages the registry for OFT Composer operations, including
+ * deposit addresses and compose transfer routing for cross-chain composition.
+ */
+declare class OFTComposerManager {
+    #private;
+    packageId: string;
+    readonly client: IotaClient;
+    readonly registryObjectId: string;
+    private readonly protocolSDK;
+    constructor(protocolSDK: SDK, packageId: string, registryObjectId: string);
+    /**
+     * 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: Transaction, composerCallCap: string | TransactionArgument, depositAddress: string | TransactionArgument): TransactionResult;
+    /**
+     * 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: Transaction, composer: string | TransactionArgument): TransactionResult;
+    /**
+     * 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: Transaction, from: string | TransactionArgument, guid: Uint8Array | TransactionArgument, composer: string | TransactionArgument): TransactionResult;
+    /**
+     * 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
+     */
+    getComposeTransfer(from: string, guid: Uint8Array, composer: string): Promise<string>;
+}
+
+declare const OFTLimitBcs: _iota_iota_sdk_dist_cjs_bcs.BcsType<{
+    min_amount_ld: string;
+    max_amount_ld: string;
+}, {
+    min_amount_ld: string | number | bigint;
+    max_amount_ld: string | number | bigint;
+}>;
+declare const OFTFeeDetailBcs: _iota_iota_sdk_dist_cjs_bcs.BcsType<{
+    fee_amount_ld: string;
+    is_reward: boolean;
+    description: string;
+}, {
+    fee_amount_ld: string | number | bigint;
+    is_reward: boolean;
+    description: string;
+}>;
+declare const OFTReceiptBcs: _iota_iota_sdk_dist_cjs_bcs.BcsType<{
+    amount_sent_ld: string;
+    amount_received_ld: string;
+}, {
+    amount_sent_ld: string | number | bigint;
+    amount_received_ld: string | number | bigint;
+}>;
+declare const OFTInfoV1Bcs: _iota_iota_sdk_dist_cjs_bcs.BcsType<{
+    oft_package: string;
+    oft_object: string;
+}, {
+    oft_package: string | Uint8Array;
+    oft_object: string | Uint8Array;
+}>;
+declare function parseOFTLimit(data: Uint8Array): OFTLimit;
+declare function parseOFTFeeDetails(data: Uint8Array): OFTFeeDetail[];
+declare function parseOFTReceipt(data: Uint8Array): OFTReceipt;
+declare function parseOFTInfoV1(data: Uint8Array): OFTInfoV1;
+
+export { OFT, OFTComposerManager, OFTComposerManagerErrorCode, OFTErrorCode, type OFTFeeDetail, OFTFeeDetailBcs, type OFTInfoV1, OFTInfoV1Bcs, type OFTLimit, OFTLimitBcs, OFTMsgType, type OFTReceipt, OFTReceiptBcs, type SendParam, parseOFTFeeDetails, parseOFTInfoV1, parseOFTLimit, parseOFTReceipt };