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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/lz-sui-oft-sdk-v2",
-  "version": "3.0.127",
+  "version": "3.0.128-sui.1",
   "license": "BUSL-1.1",
   "exports": {
     ".": {
@@ -28,16 +28,16 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@layerzerolabs/lz-definitions": "^3.0.128",
-    "@layerzerolabs/lz-sui-sdk-v2": "^3.0.128",
+    "@layerzerolabs/lz-definitions": "^3.0.128-sui.1",
+    "@layerzerolabs/lz-sui-sdk-v2": "^3.0.128-sui.1",
     "@mysten/sui": "^1.33.0"
   },
   "devDependencies": {
-    "@layerzerolabs/lz-foundation": "^3.0.128",
-    "@layerzerolabs/lz-utilities": "^3.0.128",
-    "@layerzerolabs/lz-v2-utilities": "^3.0.128",
-    "@layerzerolabs/tsup-config-next": "^3.0.128",
-    "@layerzerolabs/typescript-config-next": "^3.0.128",
+    "@layerzerolabs/lz-foundation": "^3.0.128-sui.1",
+    "@layerzerolabs/lz-utilities": "^3.0.128-sui.1",
+    "@layerzerolabs/lz-v2-utilities": "^3.0.128-sui.1",
+    "@layerzerolabs/tsup-config-next": "^3.0.128-sui.1",
+    "@layerzerolabs/typescript-config-next": "^3.0.128-sui.1",
     "@types/chai": "^4.3.11",
     "@types/chai-as-promised": "^7.1.0",
     "@types/mocha": "^10.0.6",

package/src/modules/oft.ts

@@ -17,12 +17,13 @@ import {
     executeSimulate,
     isTransactionArgument,
 } from '@layerzerolabs/lz-sui-sdk-v2'
-import type { MessagingFee, ObjectOptions } from '@layerzerolabs/lz-sui-sdk-v2'
+import type { MessagingFee, ObjectOptions, IPTBValidator } from '@layerzerolabs/lz-sui-sdk-v2'
 
 import { parseOFTFeeDetails, parseOFTLimit, parseOFTReceipt } from '../bcs/oft'
 import { OFTFeeDetail, OFTLimit, OFTReceipt, SendParam } from '../types'
 
 const MODULE_NAME = 'oft'
+const OFT_SENDER_MODULE_NAME = 'oft_sender'
 
 // ==========================================
 // ERROR CODES
@@ -67,10 +68,8 @@ export const OFTErrorCode = {
 export class OFT {
     /** Sui client for blockchain interactions */
     public readonly client: SuiClient
-    /** The package ID of the OFT implementation (specific token contract) */
-    public packageId: string
     /** The package ID of the core OFT framework (shared OFT functionality) */
-    public corePackageId: string
+    public oftPackageId: string
     /** LayerZero protocol object references (endpoint, messaging channels, etc.) */
     private readonly objects: ObjectOptions
     /** The unique object ID of this OFT instance on Sui */
@@ -86,23 +85,20 @@ export class OFT {
      * 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 oftPackageId - The package ID of the core OFT framework (shared across all OFT implementations)
      * @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
+        oftPackageId: string, // the OFT package id
         oftObjectId: string,
         coinType: string,
         adminCapId?: string
     ) {
         this.protocolSDK = protocolSDK
-        this.packageId = packageId
-        this.corePackageId = corePackageId
+        this.oftPackageId = oftPackageId
         this.client = protocolSDK.client
         this.objects = protocolSDK.objects
         this.oftObjectId = oftObjectId
@@ -337,9 +333,8 @@ export class OFT {
      * 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 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
@@ -348,16 +343,19 @@ export class OFT {
     async sendMoveCall(
         tx: Transaction,
         sender: string,
-        coinProvided: string | TransactionArgument,
         sendParam: SendParam | TransactionArgument,
+        coinProvided: string | TransactionArgument,
         nativeFee: bigint | TransactionArgument,
         zroFee: bigint | TransactionArgument,
         refundAddress: string | TransactionArgument,
-        messagingChannel?: string | undefined
+        validators?: IPTBValidator[],
+        maxSimulationTimes?: number
     ): Promise<void> {
         const sendParamArg = isTransactionArgument(sendParam) ? sendParam : this.#buildSendParam(tx, sendParam)
-        const messagingChannelArg =
-            messagingChannel ?? (await this.protocolSDK.getEndpoint().getMessagingChannel(this.packageId))
+        const txSender = this.txSenderMoveCall(tx)
+        const addressArg = isTransactionArgument(refundAddress)
+            ? refundAddress
+            : tx.pure.option('address', refundAddress)
 
         // The oft::send returns a tuple (Call<EndpointSendParam, MessagingReceipt>, OFTReceipt)
         const transactionResult = tx.moveCall({
@@ -365,28 +363,47 @@ export class OFT {
             typeArguments: [this.coinType],
             arguments: [
                 tx.object(this.oftObjectId),
-                asObject(tx, coinProvided),
-                tx.object(this.objects.endpointV2),
-                tx.object(messagingChannelArg),
+                txSender,
                 sendParamArg,
+                asObject(tx, coinProvided),
                 asArgWithTx(tx, nativeFee, (tx, val) => tx.splitCoins(tx.gas, [asU64(tx, val)])[0]),
                 await asArgWithTxAsync(tx, zroFee, async (tx, val) =>
                     this.protocolSDK.getZro().splitOptionZroTokenMoveCall(tx, sender, val)
                 ),
-                asAddress(tx, refundAddress),
+                addressArg,
                 tx.object.clock(),
             ],
         })
         const endpointCall = transactionResult[0]
+        const oftSendContext = transactionResult[1]
 
         await this.protocolSDK
             .getEndpoint()
-            .populateSendTransaction(tx, endpointCall as unknown as TransactionResult, sender)
-
-        tx.moveCall({
+            .populateSendTransaction(
+                tx,
+                endpointCall as unknown as TransactionResult,
+                sender,
+                validators,
+                maxSimulationTimes
+            )
+
+        const confirmSendResult = tx.moveCall({
             target: this.#target('confirm_send'),
             typeArguments: [this.coinType],
-            arguments: [tx.object(this.oftObjectId), endpointCall],
+            arguments: [tx.object(this.oftObjectId), txSender, endpointCall, oftSendContext],
+        })
+        // destroy the empty coins
+        const nativeCoin = confirmSendResult[2]
+        const zroCoin = confirmSendResult[3]
+        tx.moveCall({
+            target: '0x1::option::destroy_none',
+            arguments: [nativeCoin],
+            typeArguments: [`0x2::coin::Coin<0x2::sui::SUI>`],
+        })
+        tx.moveCall({
+            target: '0x1::option::destroy_none',
+            arguments: [zroCoin],
+            typeArguments: [`0x2::coin::Coin<${this.protocolSDK.getZro().zroType}>`],
         })
     }
 
@@ -431,9 +448,11 @@ export class OFT {
      * @returns Promise<MessagingFee> - The calculated messaging fees
      */
     async quoteSend(
-        sender: string | TransactionArgument,
+        sender: string,
         sendParam: SendParam | TransactionArgument,
-        payInZro: boolean | TransactionArgument
+        payInZro: boolean | TransactionArgument,
+        validators?: IPTBValidator[],
+        maxSimulationTimes?: number
     ): Promise<MessagingFee> {
         const tx = new Transaction()
         const sendParamArg = isTransactionArgument(sendParam) ? sendParam : this.#buildSendParam(tx, sendParam)
@@ -444,7 +463,7 @@ export class OFT {
             arguments: [tx.object(this.oftObjectId), asAddress(tx, sender), sendParamArg, asBool(tx, payInZro)],
         })
 
-        return this.protocolSDK.getEndpoint().quote(tx, quoteCall)
+        return this.protocolSDK.getEndpoint().quote(tx, quoteCall, sender, validators, maxSimulationTimes)
     }
 
     // ==========================================
@@ -483,6 +502,33 @@ export class OFT {
         )
     }
 
+    oftAddressMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('oft_address'),
+            typeArguments: [this.coinType],
+            arguments: [tx.object(this.oftObjectId)],
+        })
+    }
+
+    async oftAddress(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => this.oftAddressMoveCall(tx),
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
+    async messagingChannel(): Promise<string> {
+        return executeSimulate(
+            this.client,
+            (tx) => {
+                const oftAddress = this.oftAddressMoveCall(tx)
+                this.protocolSDK.getEndpoint().getMessagingChannelMoveCall(tx, oftAddress)
+            },
+            (result) => bcs.Address.parse(result[0].value)
+        )
+    }
+
     /**
      * Get coin metadata address
      * @param tx - The transaction to add the move call to
@@ -925,6 +971,16 @@ export class OFT {
         )
     }
 
+    // ==========================================
+    // OFT SENDER
+    // ==========================================
+
+    txSenderMoveCall(tx: Transaction): TransactionResult {
+        return tx.moveCall({
+            target: this.#target('tx_sender', OFT_SENDER_MODULE_NAME),
+        })
+    }
+
     // ==========================================
     // PRIVATE HELPER FUNCTIONS
     // ==========================================
@@ -960,7 +1016,7 @@ export class OFT {
      * @private
      */
     #target(name: string, module_name = MODULE_NAME): string {
-        return `${this.corePackageId}::${module_name}::${name}`
+        return `${this.oftPackageId}::${module_name}::${name}`
     }
 
     /**