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

package/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2026 - LayerZero Labs Ltd.
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,183 @@
-# Temporary Holding Version
+# @layerzerolabs/oft-sui-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+LayerZero V2 SUI OFT (Omnichain Fungible Token) SDK
+
+## Overview
+
+This SDK provides TypeScript bindings for interacting with LayerZero V2 OFT contracts on the SUI blockchain. It enables developers to create, manage, and transfer omnichain fungible tokens across different blockchains using the LayerZero protocol.
+
+## Installation
+
+```bash
+npm install @layerzerolabs/oft-sui-sdk
+# or
+yarn add @layerzerolabs/oft-sui-sdk
+# or
+pnpm add @layerzerolabs/oft-sui-sdk
+```
+
+The package is ESM only. It replaces `@layerzerolabs/lz-sui-oft-sdk-v2`, which also shipped a CommonJS build. CommonJS code can `require` it only on Node versions with `require(esm)` (20.19+ or 22.12+). Otherwise, use `import` or a dynamic `import()`.
+
+TypeScript consumers need `moduleResolution: bundler`. Under `node16` or `nodenext`, the package's type declarations do not resolve.
+
+## Features
+
+- **Cross-chain Transfers**: Send tokens across different blockchains
+- **OFT & OFT Adapter**: Interact with deployed OFT & OFT Adapter
+- **OFT Composer Manager**: Advanced composition functionality for complex cross-chain operations
+
+## Usage
+
+### Initialize OFT
+
+Create a new OFT that mints/burns tokens for cross-chain transfers:
+
+```typescript
+import { OFT } from '@layerzerolabs/oft-sui-sdk';
+import { SDK, validateTransaction } from '@layerzerolabs/lz-sui-sdk-v2';
+import { Transaction } from '@mysten/sui/transactions';
+import { Stage } from '@layerzerolabs/lz-definitions';
+
+// Initialize LayerZero protocol SDK
+const protocolSDK = new SDK({
+    client: suiClient,
+    stage: Stage.MAINNET,
+});
+
+// Create OFT instance with its call cap ID and coin type
+const oft = new OFT(protocolSDK, oftCallCapId, undefined, coinType);
+
+// Initialize OFT with treasury capability (for minting/burning)
+const initTx = new Transaction();
+const [adminCap, migrationCap] = oft.initOftMoveCall(
+    initTx,
+    coinType, // e.g., "0x123::my_coin::MY_COIN"
+    oftInitTicketId, // OFT creation ticket
+    oappObjectId, // Associated OApp object
+    treasuryCapId, // Treasury cap for minting/burning
+    metadataId, // Coin metadata
+    6, // Shared decimals for cross-chain compatibility
+);
+
+// Transfer capabilities to your address
+initTx.transferObjects([adminCap, migrationCap], initTx.pure.address(yourAddress));
+
+// Execute the transaction
+const result = await validateTransaction(suiClient, signer, initTx);
+```
+
+### Initialize OFT Adapter
+
+Create an OFT Adapter that wraps existing tokens:
+
+```typescript
+// Initialize OFT Adapter (wraps existing tokens without minting/burning)
+const adapterTx = new Transaction();
+const [adminCap, migrationCap] = oft.initOftAdapterMoveCall(
+    adapterTx,
+    coinType, // e.g., "0x123::my_coin::MY_COIN"
+    oftInitTicketId, // OFT creation ticket
+    oappObjectId, // Associated OApp object
+    metadataId, // Coin metadata
+    6, // Shared decimals for cross-chain compatibility
+);
+
+// Transfer capabilities to your address
+adapterTx.transferObjects([adminCap, migrationCap], adapterTx.pure.address(yourAddress));
+
+// Execute the transaction
+const result = await validateTransaction(suiClient, signer, adapterTx);
+```
+
+### Register OFT with LayerZero Endpoint
+
+```typescript
+import { validateTransaction } from '@layerzerolabs/lz-sui-sdk-v2';
+
+// Register the OFT as an OApp with the LayerZero endpoint
+const registerTx = new Transaction();
+
+await oft.registerOAppMoveCall(
+    registerTx,
+    coinType, // Coin type
+    oftObjectId, // Created OFT object ID
+    oappObjectId, // Associated OApp object ID
+    composerManagerId, // OFT Composer Manager for handling compose messages
+);
+
+// Execute the transaction
+const result = await validateTransaction(suiClient, signer, registerTx);
+```
+
+### Set Peer for Cross-Chain Communication
+
+```typescript
+import { validateTransaction } from '@layerzerolabs/lz-sui-sdk-v2';
+
+// Get OApp instance from OFT
+const oapp = protocolSDK.getOApp(oft.oftCallCapId);
+
+// Set peer OFT on destination chain
+const setPeerTx = new Transaction();
+await oapp.setPeerMoveCall(
+    setPeerTx,
+    remoteEid, // Remote chain endpoint ID (e.g., 30102 for Ethereum)
+    remotePeerBytes, // Remote OFT address as 32-byte array
+);
+
+// Execute the transaction
+const result = await validateTransaction(suiClient, signer, setPeerTx);
+```
+
+### Quote and Send Tokens
+
+```typescript
+// Create OFT instance with its OFT object ID and coin type
+const oft = new OFT(protocolSDK, oftCallCapId, oftObjectId, coinType);
+
+// Prepare send parameters
+const sendParam = {
+    dstEid: 30102, // Destination endpoint ID
+    to: recipientAddressBytes, // Recipient address as Uint8Array (32 bytes)
+    amountLd: 1000000n, // Amount in local decimals
+    minAmountLd: 990000n, // Minimum amount (slippage protection)
+    extraOptions: new Uint8Array(0), // LayerZero execution options
+    composeMsg: new Uint8Array(0), // Optional compose message
+    oftCmd: new Uint8Array(0), // Optional OFT command (unused in default OFT)
+};
+
+// Quote the transfer fees
+const messagingFee = await oft.quoteSend(
+    senderAddress,
+    sendParam,
+    false, // payInZro: false = pay in native token
+);
+
+// Execute the transfer
+const tx = new Transaction();
+
+// Split coins from sender's wallet
+const coin = await oft.splitCoinMoveCall(tx, senderAddress, sendParam.amountLd);
+
+// Send the tokens
+await oft.sendMoveCall(
+    tx,
+    senderAddress,
+    sendParam,
+    coin,
+    messagingFee.nativeFee,
+    messagingFee.zroFee,
+    senderAddress, // refund address
+);
+
+// Transfer any remaining coins back to sender
+tx.transferObjects([coin], senderAddress);
+```
+
+## Documentation
+
+For detailed documentation and examples, please visit the [LayerZero documentation](https://docs.layerzero.network/).
+
+## License
+
+MIT

package/dist/2EH6TEKC.js

@@ -0,0 +1,106 @@
+import { __name } from './VUOMXK5T.js';
+import { bcs } from '@mysten/sui/bcs';
+import { asObject, asAddress, asBytes32, executeSimulate } from '@layerzerolabs/lz-sui-sdk-v2';
+
+var OFTComposerManagerErrorCode = {
+  // OFT Composer Manager related errors
+  EComposeTransferNotFound: 1,
+  EDepositAddressNotFound: 2
+};
+var OFTComposerManager = class {
+  static {
+    __name(this, "OFTComposerManager");
+  }
+  packageId;
+  client;
+  registryObjectId;
+  protocolSDK;
+  constructor(protocolSDK, packageId, registryObjectId) {
+    this.client = protocolSDK.client;
+    this.protocolSDK = protocolSDK;
+    this.packageId = packageId;
+    this.registryObjectId = registryObjectId;
+  }
+  // === Set Functions ===
+  /**
+   * Set deposit address for OFT composer
+   * @param tx - The transaction to add the move call to
+   * @param composerCallCap - The composer call capability transaction result
+   * @param depositAddress - The new deposit address
+   * @returns Transaction result containing the set operation
+   */
+  setDepositAddressMoveCall(tx, composerCallCap, depositAddress) {
+    return tx.moveCall({
+      target: this.#target("set_deposit_address"),
+      arguments: [
+        tx.object(this.registryObjectId),
+        asObject(tx, composerCallCap),
+        asAddress(tx, depositAddress)
+      ]
+    });
+  }
+  // === View Functions ===
+  /**
+   * Get deposit address for a composer
+   * @param tx - The transaction to add the move call to
+   * @param composer - The composer address
+   * @returns Transaction result containing the deposit address
+   */
+  getDepositAddressMoveCall(tx, composer) {
+    return tx.moveCall({
+      target: this.#target("get_deposit_address"),
+      arguments: [
+        tx.object(this.registryObjectId),
+        asAddress(tx, composer)
+      ]
+    });
+  }
+  /**
+   * Get compose transfer object for composition operations
+   * @param tx - The transaction to add the move call to
+   * @param from - The sender address
+   * @param guid - The GUID transaction result
+   * @param composer - The composer address
+   * @returns Transaction result containing the compose transfer object
+   */
+  getComposeTransferMoveCall(tx, from, guid, composer) {
+    return tx.moveCall({
+      target: this.#target("get_compose_transfer"),
+      arguments: [
+        tx.object(this.registryObjectId),
+        asAddress(tx, from),
+        asBytes32(tx, guid, this.protocolSDK.getUtils()),
+        asAddress(tx, composer)
+      ]
+    });
+  }
+  /**
+   * Get compose transfer object address
+   * @param from - The sender address
+   * @param guid - The GUID as number array
+   * @param composer - The composer address
+   * @returns Promise<string> - The compose transfer object address
+   */
+  async getComposeTransfer(from, guid, composer) {
+    return executeSimulate(this.client, (tx) => {
+      return this.getComposeTransferMoveCall(tx, from, asBytes32(tx, guid, this.protocolSDK.getUtils()), composer);
+    }, (result) => {
+      const parsed = bcs.Address.parse(result[0].value);
+      return parsed;
+    });
+  }
+  // === Private Functions ===
+  /**
+   * Generate the full target path for move calls
+   * @param func - The function name to call
+   * @returns The full module path for the move call
+   * @private
+   */
+  #target(func) {
+    return `${this.packageId}::oft_composer_manager::${func}`;
+  }
+};
+
+export { OFTComposerManager, OFTComposerManagerErrorCode };
+//# sourceMappingURL=2EH6TEKC.js.map
+//# sourceMappingURL=2EH6TEKC.js.map

package/dist/2EH6TEKC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/modules/oft-composer-manager.ts"],"names":["OFTComposerManagerErrorCode","EComposeTransferNotFound","EDepositAddressNotFound","OFTComposerManager","packageId","client","registryObjectId","protocolSDK","setDepositAddressMoveCall","tx","composerCallCap","depositAddress","moveCall","target","arguments","object","asObject","asAddress","getDepositAddressMoveCall","composer","getComposeTransferMoveCall","from","guid","asBytes32","getUtils","getComposeTransfer","executeSimulate","result","parsed","bcs","Address","parse","value","func"],"mappings":";;;;AAOO,IAAMA,2BAAAA,GAA8B;;EAEvCC,wBAAAA,EAA0B,CAAA;EAC1BC,uBAAAA,EAAyB;AAC7B;AAQO,IAAMC,qBAAN,MAAMA;EAnBb;;;AAoBWC,EAAAA,SAAAA;AACSC,EAAAA,MAAAA;AACAC,EAAAA,gBAAAA;AACCC,EAAAA,WAAAA;EAEjB,WAAA,CAAYA,WAAAA,EAAkBH,WAAmBE,gBAAAA,EAA0B;AACvE,IAAA,IAAA,CAAKD,SAASE,WAAAA,CAAYF,MAAAA;AAC1B,IAAA,IAAA,CAAKE,WAAAA,GAAcA,WAAAA;AACnB,IAAA,IAAA,CAAKH,SAAAA,GAAYA,SAAAA;AACjB,IAAA,IAAA,CAAKE,gBAAAA,GAAmBA,gBAAAA;AAC5B,EAAA;;;;;;;;;EAWAE,yBAAAA,CACIC,EAAAA,EACAC,iBACAC,cAAAA,EACiB;AACjB,IAAA,OAAOF,GAAGG,QAAAA,CAAS;MACfC,MAAAA,EAAQ,IAAA,CAAK,QAAQ,qBAAA,CAAA;MACrBC,SAAAA,EAAW;QACPL,EAAAA,CAAGM,MAAAA,CAAO,KAAKT,gBAAgB,CAAA;AAC/BU,QAAAA,QAAAA,CAASP,IAAIC,eAAAA,CAAAA;AACbO,QAAAA,SAAAA,CAAUR,IAAIE,cAAAA;;KAEtB,CAAA;AACJ,EAAA;;;;;;;;AAUAO,EAAAA,yBAAAA,CACIT,IACAU,QAAAA,EACiB;AACjB,IAAA,OAAOV,GAAGG,QAAAA,CAAS;MACfC,MAAAA,EAAQ,IAAA,CAAK,QAAQ,qBAAA,CAAA;MACrBC,SAAAA,EAAW;QAACL,EAAAA,CAAGM,MAAAA,CAAO,KAAKT,gBAAgB,CAAA;AAAGW,QAAAA,SAAAA,CAAUR,IAAIU,QAAAA;;KAChE,CAAA;AACJ,EAAA;;;;;;;;;EAUAC,0BAAAA,CACIX,EAAAA,EACAY,IAAAA,EACAC,IAAAA,EACAH,QAAAA,EACiB;AACjB,IAAA,OAAOV,GAAGG,QAAAA,CAAS;MACfC,MAAAA,EAAQ,IAAA,CAAK,QAAQ,sBAAA,CAAA;MACrBC,SAAAA,EAAW;QACPL,EAAAA,CAAGM,MAAAA,CAAO,KAAKT,gBAAgB,CAAA;AAC/BW,QAAAA,SAAAA,CAAUR,IAAIY,IAAAA,CAAAA;AACdE,QAAAA,SAAAA,CAAUd,EAAAA,EAAIa,IAAAA,EAAM,IAAA,CAAKf,WAAAA,CAAYiB,UAAQ,CAAA;AAC7CP,QAAAA,SAAAA,CAAUR,IAAIU,QAAAA;;KAEtB,CAAA;AACJ,EAAA;;;;;;;;EASA,MAAMM,kBAAAA,CAAmBJ,IAAAA,EAAcC,IAAAA,EAAkBH,QAAAA,EAAmC;AACxF,IAAA,OAAOO,eAAAA,CACH,IAAA,CAAKrB,MAAAA,EACL,CAACI,EAAAA,KAAAA;AACG,MAAA,OAAO,IAAA,CAAKW,0BAAAA,CACRX,EAAAA,EACAY,IAAAA,EACAE,SAAAA,CAAUd,EAAAA,EAAIa,IAAAA,EAAM,IAAA,CAAKf,WAAAA,CAAYiB,QAAAA,EAAQ,CAAA,EAC7CL,QAAAA,CAAAA;AAER,IAAA,CAAA,EACA,CAACQ,MAAAA,KAAAA;AACG,MAAA,MAAMC,SAASC,GAAAA,CAAIC,OAAAA,CAAQC,MAAMJ,MAAAA,CAAO,CAAA,EAAGK,KAAK,CAAA;AAChD,MAAA,OAAOJ,MAAAA;IACX,CAAA,CAAA;AAER,EAAA;;;;;;;;AAUA,EAAA,OAAA,CAAQK,IAAAA,EAAY;AAChB,IAAA,OAAO,CAAA,EAAG,IAAA,CAAK7B,SAAS,CAAA,wBAAA,EAA2B6B,IAAAA,CAAAA,CAAAA;AACvD,EAAA;AACJ","file":"2EH6TEKC.js","sourcesContent":["import { bcs } from '@mysten/sui/bcs';\nimport type { SuiClient } from '@mysten/sui/client';\nimport type { Transaction, TransactionArgument, TransactionResult } from '@mysten/sui/transactions';\n\nimport type { SDK } from '@layerzerolabs/lz-sui-sdk-v2';\nimport { asAddress, asBytes32, asObject, executeSimulate } from '@layerzerolabs/lz-sui-sdk-v2';\n\nexport const OFTComposerManagerErrorCode = {\n    // OFT Composer Manager related errors\n    EComposeTransferNotFound: 1,\n    EDepositAddressNotFound: 2,\n} as const;\n\n/**\n * OFT Composer Manager\n *\n * This class manages the registry for OFT Composer operations, including\n * deposit addresses and compose transfer routing for cross-chain composition.\n */\nexport class OFTComposerManager {\n    public packageId: string;\n    public readonly client: SuiClient;\n    public readonly registryObjectId: string;\n    private readonly protocolSDK: SDK;\n\n    constructor(protocolSDK: SDK, packageId: string, registryObjectId: string) {\n        this.client = protocolSDK.client;\n        this.protocolSDK = protocolSDK;\n        this.packageId = packageId;\n        this.registryObjectId = registryObjectId;\n    }\n\n    // === Set Functions ===\n\n    /**\n     * Set deposit address for OFT composer\n     * @param tx - The transaction to add the move call to\n     * @param composerCallCap - The composer call capability transaction result\n     * @param depositAddress - The new deposit address\n     * @returns Transaction result containing the set operation\n     */\n    setDepositAddressMoveCall(\n        tx: Transaction,\n        composerCallCap: string | TransactionArgument,\n        depositAddress: string | TransactionArgument,\n    ): TransactionResult {\n        return tx.moveCall({\n            target: this.#target('set_deposit_address'),\n            arguments: [\n                tx.object(this.registryObjectId),\n                asObject(tx, composerCallCap),\n                asAddress(tx, depositAddress),\n            ],\n        });\n    }\n\n    // === View Functions ===\n\n    /**\n     * Get deposit address for a composer\n     * @param tx - The transaction to add the move call to\n     * @param composer - The composer address\n     * @returns Transaction result containing the deposit address\n     */\n    getDepositAddressMoveCall(\n        tx: Transaction,\n        composer: string | TransactionArgument,\n    ): TransactionResult {\n        return tx.moveCall({\n            target: this.#target('get_deposit_address'),\n            arguments: [tx.object(this.registryObjectId), asAddress(tx, composer)],\n        });\n    }\n\n    /**\n     * Get compose transfer object for composition operations\n     * @param tx - The transaction to add the move call to\n     * @param from - The sender address\n     * @param guid - The GUID transaction result\n     * @param composer - The composer address\n     * @returns Transaction result containing the compose transfer object\n     */\n    getComposeTransferMoveCall(\n        tx: Transaction,\n        from: string | TransactionArgument,\n        guid: Uint8Array | TransactionArgument,\n        composer: string | TransactionArgument,\n    ): TransactionResult {\n        return tx.moveCall({\n            target: this.#target('get_compose_transfer'),\n            arguments: [\n                tx.object(this.registryObjectId),\n                asAddress(tx, from),\n                asBytes32(tx, guid, this.protocolSDK.getUtils()),\n                asAddress(tx, composer),\n            ],\n        });\n    }\n\n    /**\n     * Get compose transfer object address\n     * @param from - The sender address\n     * @param guid - The GUID as number array\n     * @param composer - The composer address\n     * @returns Promise<string> - The compose transfer object address\n     */\n    async getComposeTransfer(from: string, guid: Uint8Array, composer: string): Promise<string> {\n        return executeSimulate(\n            this.client,\n            (tx) => {\n                return this.getComposeTransferMoveCall(\n                    tx,\n                    from,\n                    asBytes32(tx, guid, this.protocolSDK.getUtils()),\n                    composer,\n                );\n            },\n            (result) => {\n                const parsed = bcs.Address.parse(result[0].value);\n                return parsed;\n            },\n        );\n    }\n\n    // === Private Functions ===\n\n    /**\n     * Generate the full target path for move calls\n     * @param func - The function name to call\n     * @returns The full module path for the move call\n     * @private\n     */\n    #target(func: string): string {\n        return `${this.packageId}::oft_composer_manager::${func}`;\n    }\n}\n"]}

package/dist/I5Z2GNDD.js

@@ -0,0 +1,9 @@
+// src/types.ts
+var OFTMsgType = {
+  SEND: 1,
+  SEND_AND_CALL: 2
+};
+
+export { OFTMsgType };
+//# sourceMappingURL=I5Z2GNDD.js.map
+//# sourceMappingURL=I5Z2GNDD.js.map

package/dist/I5Z2GNDD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"names":["OFTMsgType","SEND","SEND_AND_CALL"],"mappings":";AACO,IAAMA,UAAAA,GAAa;EACtBC,IAAAA,EAAM,CAAA;EACNC,aAAAA,EAAe;AACnB","file":"I5Z2GNDD.js","sourcesContent":["// Constants\nexport const OFTMsgType = {\n    SEND: 1,\n    SEND_AND_CALL: 2,\n} as const;\n\n// Type Definitions\nexport interface SendParam {\n    dstEid: number;\n    to: Uint8Array;\n    amountLd: bigint;\n    minAmountLd: bigint;\n    extraOptions: Uint8Array;\n    composeMsg: Uint8Array;\n    oftCmd: Uint8Array;\n}\n\nexport interface OFTLimit {\n    minAmountLd: bigint;\n    maxAmountLd: bigint;\n}\n\nexport interface OFTFeeDetail {\n    feeAmountLd: bigint;\n    description: string;\n    isReward: boolean;\n}\n\nexport interface OFTReceipt {\n    amountSentLd: bigint;\n    amountReceivedLd: bigint;\n}\n\nexport interface OFTInfoV1 {\n    oftPackage: string;\n    oftObject: string;\n}\n"]}