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

package/dist/index.d.mts

@@ -0,0 +1,506 @@
+import { SuiClient } from '@mysten/sui/client';
+import { Transaction, TransactionArgument, TransactionResult } from '@mysten/sui/transactions';
+import { SDK, MessagingFee, ObjectOptions } from '@layerzerolabs/lz-sui-sdk-v2';
+import { Transaction as Transaction$1, TransactionArgument as TransactionArgument$1, TransactionResult as TransactionResult$1 } from '@mysten/sui/dist/cjs/transactions';
+import * as _mysten_sui_dist_cjs_bcs from '@mysten/sui/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;
+}
+
+declare const OFTErrorCode: {
+    readonly OFT_EComposeMsgNotAllowed: 1;
+    readonly OFT_EComposeMsgRequired: 2;
+    readonly OFT_EInvalidComposeQueue: 3;
+    readonly OFT_EInvalidLocalDecimals: 4;
+    readonly OFT_EPaused: 5;
+    readonly OFT_EPauseUnchanged: 6;
+    readonly OFT_ESlippageExceeded: 7;
+    readonly OFT_EInsufficientBalance: 8;
+};
+/**
+ * OFT (Omnichain Fungible Token) Class
+ *
+ * The OFT class provides a comprehensive interface for interacting with LayerZero's
+ * Omnichain Fungible Token standard on the Sui blockchain. OFTs enable seamless
+ * cross-chain token transfers while maintaining fungibility across multiple networks.
+ *
+ * @example
+ * ```typescript
+ * // Initialize OFT instance
+ * const oft = new OFT(protocolSDK, corePackageId, packageId, oftObjectId, coinType, adminCapId);
+ *
+ * // Send tokens cross-chain
+ * const tx = new Transaction();
+ * const coin = await oft.splitCoinMoveCall(tx, sender, amount);
+ * await oft.sendMoveCall(tx, sender, coin, sendParam, nativeFee, zroFee, refundAddress, messagingChannel);
+ * tx.transferObjects([coin], sender);
+ * ...
+ *
+ * // Quote transfer fees
+ * const fees = await oft.quoteSend(sender, sendParam, payInZro);
+ * ```
+ */
+declare class OFT {
+    #private;
+    /** Sui client for blockchain interactions */
+    readonly client: SuiClient;
+    /** The package ID of the OFT implementation (specific token contract) */
+    packageId: string;
+    /** The package ID of the core OFT framework (shared OFT functionality) */
+    corePackageId: string;
+    /** LayerZero protocol object references (endpoint, messaging channels, etc.) */
+    private readonly objects;
+    /** The unique object ID of this OFT instance on Sui */
+    private readonly oftObjectId;
+    /** Admin capability object ID for privileged operations (optional for read-only usage) */
+    private readonly adminCapId?;
+    /** The Sui coin type this OFT represents (e.g., "0x123::mycoin::MYCOIN") */
+    private readonly coinType;
+    /** Reference to the LayerZero protocol SDK for cross-chain operations */
+    private readonly protocolSDK;
+    /**
+     * Creates a new OFT instance for interacting with an Omnichain Fungible Token
+     *
+     * @param protocolSDK - The LayerZero protocol SDK instance providing core cross-chain functionality
+     * @param corePackageId - The package ID of the core OFT framework (shared across all OFT implementations)
+     * @param packageId - The package ID of the specific OFT token implementation
+     * @param oftObjectId - The unique object ID of this OFT instance
+     * @param coinType - The Sui coin type string (e.g., "0x123::mycoin::MYCOIN")
+     * @param adminCapId - Optional admin capability object ID for privileged operations (required for admin functions)
+     */
+    constructor(protocolSDK: SDK, corePackageId: string, // the OFT package id
+    packageId: string, // the Implementation's package id
+    oftObjectId: string, coinType: string, adminCapId?: string);
+    /**
+     * Register OFT as an OApp with LayerZero endpoint
+     * @param tx - The transaction to add the move call to
+     * @param lzReceiveInfo - PTB Builder lzReceiveInfoMoveCall result, used for protocol SDK to dynamically build the PTB
+     * for OFT's lzReceive operation
+     */
+    registerOAppMoveCall(tx: Transaction, lzReceiveInfo: Uint8Array | TransactionArgument): void;
+    /**
+     * Set enforced options for OFT messaging to a destination
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param msgType - Message type (SEND or SEND_AND_CALL)
+     * @param options - Enforced options as bytes
+     */
+    setEnforcedOptionsMoveCall(tx: Transaction, eid: number | TransactionArgument, msgType: number | TransactionArgument, options: Uint8Array | TransactionArgument): void;
+    /**
+     * Set peer OFT on another chain
+     * @param tx - The transaction to add the move call to
+     * @param messagingChannel - The messaging channel object ID
+     * @param eid - Peer endpoint ID
+     * @param peer - Peer OFT address as bytes
+     */
+    setPeerMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, eid: number | TransactionArgument, peer: Uint8Array | TransactionArgument): void;
+    /**
+     * Set delegate for OFT
+     * @param tx - The transaction to add the move call to
+     * @param newDelegate - The new delegate address
+     */
+    setDelegateMoveCall(tx: Transaction, newDelegate: string | TransactionArgument): void;
+    /**
+     * Set pause state for OFT operations
+     * @param tx - The transaction to add the move call to
+     * @param pause - Whether to pause or unpause operations
+     */
+    setPauseMoveCall(tx: Transaction, pause: boolean | TransactionArgument): void;
+    /**
+     * Set fee deposit address for OFT fees
+     * @param tx - The transaction to add the move call to
+     * @param feeDepositAddress - The new fee deposit address
+     */
+    setFeeDepositAddressMoveCall(tx: Transaction, feeDepositAddress: string | TransactionArgument): void;
+    /**
+     * Set fee basis points for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param feeBps - The fee in basis points
+     */
+    setFeeBpsMoveCall(tx: Transaction, feeBps: bigint | number | string | TransactionArgument): void;
+    /**
+     * Set rate limit for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     * @param rateLimit - Rate limit amount
+     * @param windowSeconds - Time window in seconds
+     */
+    setRateLimitMoveCall(tx: Transaction, eid: number | TransactionArgument, inbound: boolean | TransactionArgument, rateLimit: bigint | number | string | TransactionArgument, windowSeconds: bigint | number | string | TransactionArgument): void;
+    /**
+     * Remove rate limit for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param inbound - Whether this is for inbound or outbound transfers
+     */
+    unsetRateLimitMoveCall(tx: Transaction, eid: number | TransactionArgument, inbound: boolean | TransactionArgument): void;
+    /**
+     * 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 coinProvided - Coin object ID or transaction result to send
+     * @param messagingChannel - The messaging channel object ID
+     * @param sendParam - Send parameters including destination and amounts
+     * @param nativeFee - Native token fee amount
+     * @param zroFee - ZRO token fee amount
+     * @param refundAddress - Address for fee refunds
+     * @returns Promise<TransactionResult> - Transaction result containing send operation and receipt objects
+     */
+    sendMoveCall(tx: Transaction, sender: string, coinProvided: string | TransactionArgument, sendParam: SendParam | TransactionArgument, nativeFee: bigint | TransactionArgument, zroFee: bigint | TransactionArgument, refundAddress: string | TransactionArgument, messagingChannel?: string | undefined): Promise<void>;
+    /**
+     * 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
+     * @returns Promise<MessagingFee> - The calculated messaging fees
+     */
+    quoteSend(sender: string | TransactionArgument, sendParam: SendParam | TransactionArgument, payInZro: boolean | TransactionArgument): Promise<MessagingFee>;
+    /**
+     * Get OFT version information
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing version information
+     */
+    oftVersionMoveCall(tx: Transaction): TransactionResult;
+    /**
+     * Get OFT version information
+     * @returns Promise<{ major: number; minor: number }> - The OFT version
+     */
+    oftVersion(): Promise<{
+        major: number;
+        minor: number;
+    }>;
+    /**
+     * Get coin metadata address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing coin metadata address
+     */
+    coinMetadataMoveCall(tx: Transaction): TransactionResult;
+    /**
+     * Get coin metadata address
+     * @returns Promise<string> - The coin metadata address
+     */
+    coinMetadata(): Promise<string>;
+    /**
+     * Get OFT admin address
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the admin address
+     */
+    adminMoveCall(tx: Transaction): TransactionResult;
+    /**
+     * Get OFT admin address
+     * @returns Promise<string> - The admin address
+     */
+    admin(): 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): TransactionResult;
+    /**
+     * Get shared decimals for cross-chain compatibility
+     * @returns Promise<number> - The shared decimal precision
+     */
+    sharedDecimals(): Promise<number>;
+    /**
+     * Check if OFT is paused
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the paused status
+     */
+    isPausedMoveCall(tx: Transaction): TransactionResult;
+    /**
+     * 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): TransactionResult;
+    /**
+     * Check if this OFT is an adapter (wraps existing token)
+     * @returns Promise<boolean> - True if this is an OFT adapter
+     */
+    isAdapter(): Promise<boolean>;
+    /**
+     * Get fee basis points for OFT transfers
+     * @param tx - The transaction to add the move call to
+     * @returns Transaction result containing the fee basis points
+     */
+    feeBpsMoveCall(tx: Transaction): TransactionResult;
+    /**
+     * Get fee basis points for OFT transfers
+     * @returns Promise<bigint> - The fee in basis points
+     */
+    feeBps(): 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): 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): 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): 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): 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>;
+    /**
+     * Combine enforced options with extra options
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param msgType - Message type
+     * @param extraOptions - Extra options to combine with enforced options
+     * @returns Transaction result containing the combined options
+     */
+    combineOptionsMoveCall(tx: Transaction, eid: number | TransactionArgument, msgType: number | TransactionArgument, extraOptions: Uint8Array | TransactionArgument): TransactionResult;
+    /**
+     * Combine enforced options with extra options
+     * @param eid - Endpoint ID
+     * @param msgType - Message type
+     * @param extraOptions - Extra options to combine with enforced options
+     * @returns Promise<Uint8Array> - The combined options as bytes
+     */
+    combineOptions(eid: number, msgType: number, extraOptions: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get enforced options for OFT messaging
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @param msgType - Message type
+     * @returns Transaction result containing the enforced options
+     */
+    getEnforcedOptionsMoveCall(tx: Transaction, eid: number | TransactionArgument, msgType: number | TransactionArgument): TransactionResult;
+    /**
+     * Get enforced options for OFT messaging
+     * @param eid - Endpoint ID
+     * @param msgType - Message type
+     * @returns Promise<Uint8Array> - The enforced options as bytes
+     */
+    getEnforcedOptions(eid: number, msgType: number): Promise<Uint8Array>;
+    /**
+     * Check if OFT has a peer on specific endpoint
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @returns Transaction result containing the peer existence status
+     */
+    hasPeerMoveCall(tx: Transaction, eid: number | TransactionArgument): TransactionResult;
+    /**
+     * Check if OFT has a peer on specific endpoint
+     * @param eid - Endpoint ID
+     * @returns Promise<boolean> - True if peer exists on the endpoint
+     */
+    hasPeer(eid: number): Promise<boolean>;
+    /**
+     * Get peer OFT address on specific endpoint
+     * @param tx - The transaction to add the move call to
+     * @param eid - Endpoint ID
+     * @returns Transaction result containing the peer address
+     */
+    getPeerMoveCall(tx: Transaction, eid: number | TransactionArgument): TransactionResult;
+    /**
+     * Get peer OFT address on specific endpoint
+     * @param eid - Endpoint ID
+     * @returns Promise<Uint8Array> - The peer address as bytes32
+     */
+    getPeer(eid: number): Promise<Uint8Array>;
+}
+
+declare const OFTComposerRegistryErrorCode: {
+    readonly EComposeTransferNotFound: 1;
+    readonly EDepositAddressNotFound: 2;
+};
+/**
+ * OFT Composer Registry
+ *
+ * This class manages the registry for OFT Composer operations, including
+ * deposit addresses and compose transfer routing for cross-chain composition.
+ */
+declare class OFTComposerRegistry {
+    #private;
+    packageId: string;
+    readonly client: SuiClient;
+    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>;
+}
+
+/**
+ * OFT PTB (Programmable Transaction Block) Builder
+ *
+ * This class provides utility functions for building programmable transactions
+ * for OFT operations, particularly for LayerZero receive operations.
+ */
+declare class OFTPtbBuilder {
+    packageId: string;
+    objectId: string;
+    readonly client: SuiClient;
+    readonly coinType: string;
+    readonly oftObjectId: string;
+    readonly objects: ObjectOptions;
+    constructor(protocolSDK: SDK, packageId: string, objectId: string, client: SuiClient, coinType: string, oftObjectId: string);
+    /**
+     * Get LayerZero receive information for OFT registration
+     *
+     * This function prepares the necessary metadata for registering an OFT
+     * with the LayerZero endpoint, enabling it to receive cross-chain messages.
+     *
+     * @param tx - The transaction to add the move call to
+     * @param composerRegistry - The composer registry object ID for routing compose transfers
+     * @returns TransactionResult containing serialized execution metadata for endpoint registration
+     */
+    lzReceiveInfoMoveCall(tx: Transaction$1, composerRegistry: string | TransactionArgument$1): TransactionResult$1;
+}
+
+declare const OFTLimitBcs: _mysten_sui_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: _mysten_sui_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: _mysten_sui_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 function parseOFTLimit(data: Uint8Array): OFTLimit;
+declare function parseOFTFeeDetails(data: Uint8Array): OFTFeeDetail[];
+declare function parseOFTReceipt(data: Uint8Array): OFTReceipt;
+
+export { OFT, OFTComposerRegistry, OFTComposerRegistryErrorCode, OFTErrorCode, type OFTFeeDetail, OFTFeeDetailBcs, type OFTLimit, OFTLimitBcs, OFTMsgType, OFTPtbBuilder, type OFTReceipt, OFTReceiptBcs, type SendParam, parseOFTFeeDetails, parseOFTLimit, parseOFTReceipt };