@layerzerolabs/lz-sui-sdk-v2 3.0.73 → 3.0.75

package/dist/index.cjs

@@ -1,44 +1,1182 @@
 'use strict';
 
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+var bcs = require('@mysten/sui/bcs');
+var transactions = require('@mysten/sui/transactions');
+var fs = require('fs');
+var path = require('path');
+var ed25519 = require('@mysten/sui/keypairs/ed25519');
+var lzCorekitSui = require('@layerzerolabs/lz-corekit-sui');
+var lzDefinitions = require('@layerzerolabs/lz-definitions');
 
-// src/endpoint.ts
-var endpoint_exports = {};
-__export(endpoint_exports, {
-  eid: () => eid,
-  getConfig: () => getConfig,
-  getSendLibrary: () => getSendLibrary,
-  initEid: () => initEid,
-  populateGetConfigTransaction: () => populateGetConfigTransaction,
-  populateQuoteTransaction: () => populateQuoteTransaction,
-  populateSendTransaction: () => populateSendTransaction,
-  populateSetConfigTransaction: () => populateSetConfigTransaction
-});
-async function initEid() {
-  throw new Error("Not implemented");
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
 }
-async function eid() {
-  return Promise.resolve(1);
-}
-async function getSendLibrary(sender, dst_eid) {
-  throw new Error("Not implemented");
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/modules/simple-message-lib.ts
+async function devInspectTransaction(suiClient, tx, sender) {
+  const { results, error } = await suiClient.devInspectTransactionBlock({
+    transactionBlock: tx,
+    sender
+  });
+  if (error != void 0 && error != null) {
+    throw new Error(error);
+  }
+  return results;
 }
-async function getConfig() {
-  throw new Error("Not implemented");
+async function moveView(suiClient, tx, sender) {
+  if (sender === void 0) {
+    sender = ed25519.Ed25519Keypair.generate().toSuiAddress();
+  }
+  const result = await devInspectTransaction(suiClient, tx, sender);
+  return result ? result[result.length - 1] : null;
 }
-async function populateQuoteTransaction(tx) {
+function readAddressFromDeployment(network, name) {
+  const deploymentPath = path__namespace.join(__dirname, "..", "deployments", network, `${name}.json`);
+  if (!fs__namespace.existsSync(deploymentPath)) {
+    return void 0;
+  }
+  const deployment = JSON.parse(fs__namespace.readFileSync(deploymentPath, "utf8"));
+  return deployment.address;
 }
-async function populateSendTransaction(tx) {
+async function validateTransaction(client, signer, tx) {
+  tx.setSenderIfNotSet(signer.getPublicKey().toSuiAddress());
+  const result = await client.signAndExecuteTransaction({
+    signer,
+    transaction: tx,
+    options: {
+      showEffects: true,
+      showObjectChanges: true,
+      showEvents: true
+    }
+  });
+  if (result.effects?.status.status !== "success") {
+    throw new Error(result.effects?.status.error);
+  }
+  await client.waitForTransaction({ digest: result.digest });
+  return result;
 }
-async function populateGetConfigTransaction(tx) {
+
+// src/modules/simple-message-lib.ts
+var SimpleMessageLib = class {
+  constructor(packageId, client, objects, context) {
+    this.context = context;
+    this.packageId = packageId;
+    this.client = client;
+    this.objects = objects;
+    if (this.objects.simple_message_lib.trim() === "") {
+      throw new Error("simple_message_lib object cannot be empty");
+    }
+    if (this.objects.endpoint_admin_cap.trim() === "") {
+      throw new Error("admin_cap object cannot be empty");
+    }
+    if (this.objects.endpoint_v2.trim() === "") {
+      throw new Error("endpoint_v2 object cannot be empty");
+    }
+  }
+  populateInitializeTransaction() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::initialize`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.endpoint_admin_cap), tx.object(this.objects.endpoint_v2)]
+    });
+    return tx;
+  }
+  // === View Functions ===
+  async getNativeFee() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::get_native_fee`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.simple_message_lib)]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    return bcs.bcs.U64.parse(bytes);
+  }
+  async getZroFee() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::get_zro_fee`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.simple_message_lib)]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    return bcs.bcs.U64.parse(bytes);
+  }
+  async getFeeRecipient() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::get_fee_recipient`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.simple_message_lib)]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    return bcs.bcs.Address.parse(bytes);
+  }
+  async isRegistered() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::is_registered`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.simple_message_lib), tx.object(this.objects.endpoint_v2)]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    return bcs.bcs.Bool.parse(bytes);
+  }
+  // === Admin Functions ===
+  populateRegisterLibraryTransaction() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::register_library`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.simple_message_lib),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.object(this.objects.endpoint_v2)
+      ]
+    });
+    return tx;
+  }
+  populateSetMessagingFeeTransaction(zroFee, nativeFee) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::set_messaging_fee`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.simple_message_lib),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.pure.u64(zroFee),
+        tx.pure.u64(nativeFee)
+      ]
+    });
+    return tx;
+  }
+  populateSetDefaultConfigTransaction(eid, configType, config) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::set_default_config`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.simple_message_lib),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.pure.u32(eid),
+        tx.pure.u32(configType),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(config))
+      ]
+    });
+    return tx;
+  }
+  populateSetFeeRecipientTransaction(feeRecipient) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::set_fee_recipient`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.simple_message_lib),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.pure.address(feeRecipient)
+      ]
+    });
+    return tx;
+  }
+  // === Endpoint Validation ===
+  populateValidatePacketTransaction(packetHeader, payloadHash) {
+    const tx = new transactions.Transaction();
+    const payloadHashBytes32 = this.context.utils.fromBytesMoveCall(tx, payloadHash);
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::validate_packet`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.simple_message_lib),
+        tx.object(this.objects.endpoint_v2),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(packetHeader)),
+        payloadHashBytes32,
+        tx.object("0x6")
+        // Clock Object TODO try to get it from the client or sdk
+      ]
+    });
+    return tx;
+  }
+  // === Protocol Discovery ===
+  populateRegisterMessageLibDiscoveryTransaction() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::register_message_lib_discovery`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.simple_message_lib),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.object(this.objects.endpoint_v2),
+        tx.object(this.objects.discovery)
+      ]
+    });
+    return tx;
+  }
+  quoteMoveCall(tx, quoteCall) {
+    return tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::quote`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.simple_message_lib), quoteCall]
+    });
+  }
+  sendMoveCall(tx, sendCall) {
+    return tx.moveCall({
+      target: `${this.packageId}::simple_message_lib::send`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.simple_message_lib), tx.object(this.objects.endpoint_v2), sendCall]
+    });
+  }
+  // === TODO: Core Message Lib Functions ===
+  // These functions are called by the endpoint and require specific parameter types
+  // that need to be implemented based on the endpoint_v2 module interfaces
+  populateQuoteTransaction(tx) {
+  }
+  populateSendTransaction(tx) {
+  }
+  populateSetConfigTransaction(tx) {
+  }
+  populateGetConfigTransaction(tx) {
+  }
+};
+var Endpoint = class {
+  constructor(packageId, client, objects, context) {
+    this.context = context;
+    this.packageId = packageId;
+    this.client = client;
+    this.objects = objects;
+    if (this.objects.endpoint_v2.trim() === "") {
+      throw new Error("endpoint_v2 object cannot be empty");
+    }
+    if (this.objects.endpoint_admin_cap.trim() === "") {
+      throw new Error("endpoint_admin_cap object cannot be empty");
+    }
+  }
+  async eid() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::eid`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.endpoint_v2)]
+    });
+    try {
+      const result = await moveView(this.client, tx);
+      const bytes = new Uint8Array(result?.returnValues[0][0]);
+      return bcs.bcs.U32.parse(bytes);
+    } catch (e) {
+      return 0;
+    }
+  }
+  populateInitEidTransaction(eid) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::init_eid`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.endpoint_v2),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.pure.u32(eid)
+      ]
+    });
+    return tx;
+  }
+  async getDefaultSendLibrary(srcEid) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_default_send_library`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.endpoint_v2), tx.pure.u32(srcEid)]
+    });
+    try {
+      const result = await moveView(this.client, tx);
+      const bytes = new Uint8Array(result?.returnValues[0][0]);
+      return bcs.bcs.Address.parse(bytes);
+    } catch (error) {
+      return "0x0";
+    }
+  }
+  populateSetDefaultSendLibraryTransaction(dstEid, newLib) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::set_default_send_library`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.endpoint_v2),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.pure.u32(dstEid),
+        tx.pure.address(newLib)
+      ]
+    });
+    return tx;
+  }
+  async getDefaultReceiveLibrary(srcEid) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_default_receive_library`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.endpoint_v2), tx.pure.u32(srcEid)]
+    });
+    try {
+      const result = await moveView(this.client, tx);
+      const bytes = new Uint8Array(result?.returnValues[0][0]);
+      return bcs.bcs.Address.parse(bytes);
+    } catch (error) {
+      return "0x";
+    }
+  }
+  populateSetDefaultReceiveLibraryTransaction(srcEid, newLib, gracePeriod) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::set_default_receive_library`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.endpoint_v2),
+        tx.object(this.objects.endpoint_admin_cap),
+        tx.pure.u32(srcEid),
+        tx.pure.address(newLib),
+        tx.pure.u64(gracePeriod),
+        tx.object("0x6")
+        // Clock Object TODO try to get it from the client or sdk
+      ]
+    });
+    return tx;
+  }
+  confirmQuoteMoveCall(tx, executedCall) {
+    return tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::confirm_quote`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.endpoint_v2), executedCall]
+    });
+  }
+  confirmSendMoveCall(tx, executedCall) {
+    return tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::confirm_send`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.endpoint_v2), executedCall]
+    });
+  }
+  // === Worker Endpoint Required Methods ===
+  async getSendLibrary(sender, dstEid) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_send_library`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.endpoint_v2), tx.pure.address(sender), tx.pure.u32(dstEid)]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    const lib = bcs.bcs.Address.parse(bytes);
+    const isDefaultBytes = new Uint8Array(result?.returnValues[1][0]);
+    const isDefault = bcs.bcs.Bool.parse(isDefaultBytes);
+    return [lib, isDefault];
+  }
+  async getReceiveLibrary(receiver, srcEid) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_receive_library`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.endpoint_v2), tx.pure.address(receiver), tx.pure.u32(srcEid)]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    const lib = bcs.bcs.Address.parse(bytes);
+    const isDefaultBytes = new Uint8Array(result?.returnValues[1][0]);
+    const isDefault = bcs.bcs.Bool.parse(isDefaultBytes);
+    return [lib, isDefault];
+  }
+  async getInboundNonce(receiver, srcEid, sender) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_inbound_nonce`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.address(receiver),
+        tx.pure.u32(srcEid),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(sender))
+      ]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    return BigInt(bcs.bcs.U64.parse(bytes));
+  }
+  async getLazyInboundNonce(receiver, srcEid, sender) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_lazy_inbound_nonce`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.address(receiver),
+        tx.pure.u32(srcEid),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(sender))
+      ]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    return BigInt(bcs.bcs.U64.parse(bytes));
+  }
+  async getOutboundNonce(sender, dstEid, receiver) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_outbound_nonce`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.address(sender),
+        tx.pure.u32(dstEid),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(receiver))
+      ]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    return BigInt(bcs.bcs.U64.parse(bytes));
+  }
+  async getInboundPayloadHash(receiver, srcEid, sender, nonce) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_inbound_payload_hash`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.address(receiver),
+        tx.pure.u32(srcEid),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(sender)),
+        tx.pure.u64(nonce)
+      ]
+    });
+    try {
+      const result = await moveView(this.client, tx);
+      const bytes = new Uint8Array(result?.returnValues[0][0]);
+      const parsed = bcs.bcs.vector(bcs.bcs.u8()).parse(bytes);
+      return Buffer.from(parsed);
+    } catch (error) {
+      return null;
+    }
+  }
+  async getComposeMessageHash(from, to, guid, index) {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::endpoint_v2::get_compose_message_hash`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.address(from),
+        tx.pure.address(to),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(guid)),
+        tx.pure.u16(index)
+      ]
+    });
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    const parsed = bcs.bcs.vector(bcs.bcs.u8()).parse(bytes);
+    return Buffer.from(parsed);
+  }
+  // TODO: more view functions to be added here
+  populateQuoteTransaction(tx) {
+  }
+  populateSendTransaction(tx) {
+  }
+  populateGetConfigTransaction(tx) {
+  }
+  populateSetConfigTransaction(tx) {
+  }
+};
+var MessagingFeeBcs = bcs.bcs.struct("MessagingFee", {
+  native_fee: bcs.bcs.U64,
+  zro_fee: bcs.bcs.U64
+});
+
+// src/modules/counter.ts
+var Counter = class {
+  constructor(packageId, utilsPkgId, client, objects, context) {
+    this.context = context;
+    this.packageId = packageId;
+    this.utilsPkgId = utilsPkgId;
+    this.client = client;
+    this.objects = objects;
+  }
+  async getPeer(dstEid) {
+    const tx = new transactions.Transaction();
+    const peerBytes32 = tx.moveCall({
+      target: `${this.packageId}::counter::get_peer`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.counter), tx.pure.u32(dstEid)]
+    });
+    tx.moveCall({
+      target: `${this.utilsPkgId}::bytes32::to_address`,
+      typeArguments: [],
+      arguments: [peerBytes32]
+    });
+    try {
+      const result = await moveView(this.client, tx);
+      const bytes = new Uint8Array(result?.returnValues[0][0]);
+      return bcs.bcs.Address.parse(bytes);
+    } catch (e) {
+      return "";
+    }
+  }
+  async getCount() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::counter::get_count`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.counter)]
+    });
+    try {
+      const result = await moveView(this.client, tx);
+      const bytes = new Uint8Array(result?.returnValues[0][0]);
+      const counterStr = bcs.bcs.U64.parse(bytes);
+      return Number(counterStr);
+    } catch (e) {
+      return 0;
+    }
+  }
+  async getComposedCount() {
+    const tx = new transactions.Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::counter::get_composed_count`,
+      typeArguments: [],
+      arguments: [tx.object(this.objects.counter)]
+    });
+    try {
+      const result = await moveView(this.client, tx);
+      const bytes = new Uint8Array(result?.returnValues[0][0]);
+      const counterStr = bcs.bcs.U64.parse(bytes);
+      return Number(counterStr);
+    } catch (e) {
+      return 0;
+    }
+  }
+  populateSetPeerTransaction(dstEid, peer) {
+    const tx = new transactions.Transaction();
+    const peerBytes32 = tx.moveCall({
+      target: `${this.utilsPkgId}::bytes32::from_bytes`,
+      typeArguments: [],
+      arguments: [tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(peer))]
+    });
+    tx.moveCall({
+      target: `${this.packageId}::counter::set_peer`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.counter),
+        tx.object(this.objects.counter_admin_cap),
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.u32(dstEid),
+        peerBytes32
+      ]
+    });
+    return tx;
+  }
+  /**
+   * Builds a transaction for calling the lz_receive function on the counter contract.
+   *
+   * @param srcEid - The source endpoint ID
+   * @param sender - The sender address as Bytes32
+   * @param nonce - The nonce
+   * @param guid - The GUID as Bytes32
+   * @param message - The message as vector<u8>
+   * @param value - The value to be sent (Coin<SUI>)
+   * @param extraData - Extra data as vector<u8>
+   * @returns A Transaction object ready to be executed
+   */
+  populateLzReceiveTransaction(srcEid, sender, nonce, guid, message, value, extraData = new Uint8Array()) {
+    const tx = new transactions.Transaction();
+    const senderBytes32 = this.context.utils.fromBytesMoveCall(tx, sender);
+    const guidBytes32 = this.context.utils.fromBytesMoveCall(tx, guid);
+    const coin = tx.splitCoins(tx.gas, [tx.pure.u64(value)]);
+    tx.moveCall({
+      target: `${this.packageId}::counter::lz_receive`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.counter),
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.u32(srcEid),
+        senderBytes32,
+        tx.pure.u64(nonce),
+        guidBytes32,
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(message)),
+        coin,
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(extraData))
+      ]
+    });
+    return tx;
+  }
+  async quote(dstEid, msgType, options, payInZero) {
+    const tx = new transactions.Transaction();
+    const quoteCall = tx.moveCall({
+      target: `${this.packageId}::counter::quote`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.counter),
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.u32(dstEid),
+        tx.pure.u8(msgType),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(options)),
+        tx.pure.bool(payInZero)
+      ]
+    });
+    const executedCall = this.context.simpleMessageLib.quoteMoveCall(tx, quoteCall);
+    this.context.endpoint.confirmQuoteMoveCall(tx, executedCall);
+    const result = await moveView(this.client, tx);
+    const bytes = new Uint8Array(result?.returnValues[0][0]);
+    const messageFee = MessagingFeeBcs.parse(bytes);
+    return [BigInt(messageFee.native_fee), BigInt(messageFee.zro_fee)];
+  }
+  async send(sender, dstEid, msgType, options, sendValue, nativeFee, zroFee) {
+    const tx = new transactions.Transaction();
+    const [nativeToken] = tx.splitCoins(tx.gas, [tx.pure.u64(nativeFee)]);
+    const zroToken = this.context.zro.noneOptionMoveCall(tx);
+    const incrementCall = tx.moveCall({
+      target: `${this.packageId}::counter::increment`,
+      typeArguments: [],
+      arguments: [
+        tx.object(this.objects.counter),
+        tx.object(this.objects.endpoint_v2),
+        tx.pure.u32(dstEid),
+        tx.pure.u8(msgType),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(options)),
+        nativeToken,
+        zroToken,
+        tx.pure.u64(sendValue),
+        tx.pure.address(sender.toSuiAddress())
+      ]
+    });
+    const executedCall = this.context.simpleMessageLib.sendMoveCall(tx, incrementCall);
+    this.context.endpoint.confirmSendMoveCall(tx, executedCall);
+    return validateTransaction(this.client, sender, tx);
+  }
+};
+var Utils = class {
+  constructor(packageId, client, context) {
+    this.packageId = packageId;
+    this.client = client;
+    this.context = context;
+    if (this.packageId.trim() === "") {
+      throw new Error("utils package ID cannot be empty");
+    }
+  }
+  // === bytes32 Functions ===
+  fromBytesMoveCall(tx, peer) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::from_bytes`,
+      typeArguments: [],
+      arguments: [tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(peer))]
+    });
+  }
+  fromBytesLeftPaddedMoveCall(tx, bytes) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::from_bytes_left_padded`,
+      typeArguments: [],
+      arguments: [tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(bytes))]
+    });
+  }
+  fromBytesRightPaddedMoveCall(tx, bytes) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::from_bytes_right_padded`,
+      typeArguments: [],
+      arguments: [tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(bytes))]
+    });
+  }
+  fromAddressMoveCall(tx, address) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::from_address`,
+      typeArguments: [],
+      arguments: [tx.pure.address(address)]
+    });
+  }
+  fromIdMoveCall(tx, id) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::from_id`,
+      typeArguments: [],
+      arguments: [tx.object(id)]
+    });
+  }
+  zeroBytes32MoveCall(tx) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::zero_bytes32`,
+      typeArguments: [],
+      arguments: []
+    });
+  }
+  ffBytes32MoveCall(tx) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::ff_bytes32`,
+      typeArguments: [],
+      arguments: []
+    });
+  }
+  isZeroMoveCall(tx, bytes32) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::is_zero`,
+      typeArguments: [],
+      arguments: [tx.object(bytes32)]
+    });
+  }
+  isFfMoveCall(tx, bytes32) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::is_ff`,
+      typeArguments: [],
+      arguments: [tx.object(bytes32)]
+    });
+  }
+  toBytesMoveCall(tx, bytes32) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::to_bytes`,
+      typeArguments: [],
+      arguments: [tx.object(bytes32)]
+    });
+  }
+  toAddressMoveCall(tx, bytes32) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::to_address`,
+      typeArguments: [],
+      arguments: [tx.object(bytes32)]
+    });
+  }
+  toIdMoveCall(tx, bytes32) {
+    return tx.moveCall({
+      target: `${this.packageId}::bytes32::to_id`,
+      typeArguments: [],
+      arguments: [tx.object(bytes32)]
+    });
+  }
+  // === Buffer Functions ===
+  newReaderMoveCall(tx, buffer) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::new_reader`,
+      typeArguments: [],
+      arguments: [tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(buffer))]
+    });
+  }
+  newWriterMoveCall(tx) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::new_writer`,
+      typeArguments: [],
+      arguments: []
+    });
+  }
+  createWriterMoveCall(tx, buffer) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::create_writer`,
+      typeArguments: [],
+      arguments: [tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(buffer))]
+    });
+  }
+  // Reader functions
+  positionMoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::position`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  remainingLengthMoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::remaining_length`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  skipMoveCall(tx, reader, len) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::skip`,
+      typeArguments: [],
+      arguments: [reader, tx.pure.u64(len)]
+    });
+  }
+  setPositionMoveCall(tx, reader, position) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::set_position`,
+      typeArguments: [],
+      arguments: [reader, tx.pure.u64(position)]
+    });
+  }
+  rewindMoveCall(tx, reader, len) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::rewind`,
+      typeArguments: [],
+      arguments: [reader, tx.pure.u64(len)]
+    });
+  }
+  readU8MoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_u8`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readU16MoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_u16`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readU32MoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_u32`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readU64MoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_u64`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readU128MoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_u128`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readU256MoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_u256`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readBytes32MoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_bytes32`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readAddressMoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_address`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readFixedLenBytesMoveCall(tx, reader, len) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_fixed_len_bytes`,
+      typeArguments: [],
+      arguments: [reader, tx.pure.u64(len)]
+    });
+  }
+  readBytesUntilEndMoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::read_bytes_until_end`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readerBufferLengthMoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::reader_buffer_length`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  readerToBytesMoveCall(tx, reader) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::reader_to_bytes`,
+      typeArguments: [],
+      arguments: [reader]
+    });
+  }
+  // Writer functions
+  writerBufferLengthMoveCall(tx, writer) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::writer_buffer_length`,
+      typeArguments: [],
+      arguments: [writer]
+    });
+  }
+  writerToBytesMoveCall(tx, writer) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::writer_to_bytes`,
+      typeArguments: [],
+      arguments: [writer]
+    });
+  }
+  writeU8MoveCall(tx, writer, value) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_u8`,
+      typeArguments: [],
+      arguments: [writer, tx.pure.u8(value)]
+    });
+  }
+  writeU16MoveCall(tx, writer, value) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_u16`,
+      typeArguments: [],
+      arguments: [writer, tx.pure.u16(value)]
+    });
+  }
+  writeU32MoveCall(tx, writer, value) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_u32`,
+      typeArguments: [],
+      arguments: [writer, tx.pure.u32(value)]
+    });
+  }
+  writeU64MoveCall(tx, writer, value) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_u64`,
+      typeArguments: [],
+      arguments: [writer, tx.pure.u64(value)]
+    });
+  }
+  writeU128MoveCall(tx, writer, value) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_u128`,
+      typeArguments: [],
+      arguments: [writer, tx.pure.u128(value)]
+    });
+  }
+  writeU256MoveCall(tx, writer, value) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_u256`,
+      typeArguments: [],
+      arguments: [writer, tx.pure.u256(value)]
+    });
+  }
+  writeBytesMoveCall(tx, writer, bytes) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_bytes`,
+      typeArguments: [],
+      arguments: [writer, tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(bytes))]
+    });
+  }
+  writeAddressMoveCall(tx, writer, address) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_address`,
+      typeArguments: [],
+      arguments: [writer, tx.pure.address(address)]
+    });
+  }
+  writeBytes32MoveCall(tx, writer, bytes32) {
+    return tx.moveCall({
+      target: `${this.packageId}::buffer::write_bytes32`,
+      typeArguments: [],
+      arguments: [writer, tx.object(bytes32)]
+    });
+  }
+  // === Hash Functions ===
+  blake2b256MoveCall(tx, bytes) {
+    return tx.moveCall({
+      target: `${this.packageId}::hash::blake2b256`,
+      typeArguments: [],
+      arguments: [tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(bytes))]
+    });
+  }
+  keccak256MoveCall(tx, bytes) {
+    return tx.moveCall({
+      target: `${this.packageId}::hash::keccak256`,
+      typeArguments: [],
+      arguments: [tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(bytes))]
+    });
+  }
+};
+
+// src/modules/zro.ts
+var Zro = class {
+  constructor(packageId, client, context) {
+    this.context = context;
+    this.packageId = packageId;
+    this.client = client;
+  }
+  zeroOptionMoveCall(tx) {
+    const zroToken = tx.moveCall({
+      target: `0x2::coin::zero`,
+      typeArguments: [`${this.packageId}::zro::ZRO`]
+    });
+    const zroOption = tx.moveCall({
+      target: `0x1::option::some`,
+      typeArguments: [`0x2::coin::Coin<${this.packageId}::zro::ZRO>`],
+      arguments: [zroToken]
+    });
+    return zroOption;
+  }
+  noneOptionMoveCall(tx) {
+    return tx.moveCall({
+      target: `0x1::option::none`,
+      typeArguments: [`0x2::coin::Coin<${this.packageId}::zro::ZRO>`]
+    });
+  }
+};
+function assertSuiProvider(provider) {
+  if (!(provider instanceof lzCorekitSui.SuiProvider)) {
+    throw new Error("Invalid provider");
+  }
 }
-async function populateSetConfigTransaction(tx) {
+function getSDKFromProvider(provider, stage) {
+  assertSuiProvider(provider);
+  const client = provider.native;
+  return new SDK({
+    client,
+    stage
+  });
 }
+var SDK = class {
+  /**
+   * Creates an instance of the SDK.
+   *
+   * @param {SdkOptions} options - The SDK options.
+   */
+  constructor(options) {
+    this.chain = options.chain ?? lzDefinitions.Chain.PLACEHOLDER0;
+    this.stage = options.stage ?? lzDefinitions.Stage.SANDBOX;
+    this.client = options.client;
+    const network = lzDefinitions.chainAndStageToNetwork(this.chain, this.stage, this.stage === lzDefinitions.Stage.SANDBOX);
+    const defaultPackages = {
+      utils: readAddressFromDeployment(network, "utils"),
+      endpoint_v2: readAddressFromDeployment(network, "endpoint_v2"),
+      counter_v2: readAddressFromDeployment(network, "counter"),
+      simple_message_lib: readAddressFromDeployment(network, "simple_message_lib"),
+      zro: readAddressFromDeployment(network, "zro")
+    };
+    this.packages = {
+      ...defaultPackages,
+      ...options.packages
+    };
+    const defaultObjects = {
+      endpoint_v2: readAddressFromDeployment(network, "object-EndpointV2"),
+      simple_message_lib: readAddressFromDeployment(network, "object-SimpleMessageLib"),
+      uln_302: readAddressFromDeployment(network, "object-ULN302"),
+      blocked_message_lib: readAddressFromDeployment(network, "object-BlockedMessageLib"),
+      discovery: readAddressFromDeployment(network, "object-Discovery"),
+      counter: readAddressFromDeployment(network, "object-Counter"),
+      counter_admin_cap: readAddressFromDeployment(network, "object-CounterAdminCap"),
+      endpoint_admin_cap: readAddressFromDeployment(network, "object-EndpointV2AdminCap"),
+      oapp_core: readAddressFromDeployment(network, "object-OAppCore")
+    };
+    this.objects = {
+      ...defaultObjects,
+      ...options.objects
+    };
+    const context = {};
+    this.endpoint = new Endpoint(this.packages.endpoint_v2, this.client, this.objects, context);
+    this.counter = new Counter(this.packages.counter_v2, this.packages.utils, this.client, this.objects, context);
+    this.simpleMessageLib = new SimpleMessageLib(
+      this.packages.simple_message_lib,
+      this.client,
+      this.objects,
+      context
+    );
+    this.utils = new Utils(this.packages.utils, this.client, context);
+    this.zro = new Zro(this.packages.zro, this.client, context);
+    context.endpoint = this.endpoint;
+    context.counter = this.counter;
+    context.simpleMessageLib = this.simpleMessageLib;
+    context.utils = this.utils;
+    context.zro = this.zro;
+  }
+  /**
+   * Gets the Sui client.
+   *
+   * @returns {SuiClient} The Sui client.
+   */
+  getSuiClient() {
+    return this.client;
+  }
+  /**
+   * Gets the chain.
+   *
+   * @returns {Chain} The chain.
+   */
+  getChain() {
+    return this.chain;
+  }
+  /**
+   * Gets the stage.
+   *
+   * @returns {Stage} The stage.
+   */
+  getStage() {
+    return this.stage;
+  }
+  /**
+   * Gets the package options.
+   *
+   * @returns {PackageOptions} The package options.
+   */
+  getPackages() {
+    return this.packages;
+  }
+  /**
+   * Gets the object options.
+   *
+   * @returns {ObjectOptions} The object options.
+   */
+  getObjects() {
+    return this.objects;
+  }
+  /**
+   * Gets the endpoint module.
+   *
+   * @returns {Endpoint} The endpoint module.
+   */
+  getEndpoint() {
+    return this.endpoint;
+  }
+  /**
+   * Gets the counter module.
+   *
+   * @returns {Counter} The counter module.
+   */
+  getCounter() {
+    return this.counter;
+  }
+  /**
+   * Gets the simple message library module.
+   *
+   * @returns {SimpleMessageLib} The simple message library module.
+   */
+  getSimpleMessageLib() {
+    return this.simpleMessageLib;
+  }
+  /**
+   * Gets the utils module.
+   *
+   * @returns {Utils} The utils module.
+   */
+  getUtils() {
+    return this.utils;
+  }
+};
 
-exports.endpoint = endpoint_exports;
+exports.Counter = Counter;
+exports.Endpoint = Endpoint;
+exports.MessagingFeeBcs = MessagingFeeBcs;
+exports.SDK = SDK;
+exports.SimpleMessageLib = SimpleMessageLib;
+exports.Utils = Utils;
+exports.Zro = Zro;
+exports.devInspectTransaction = devInspectTransaction;
+exports.getSDKFromProvider = getSDKFromProvider;
+exports.moveView = moveView;
+exports.readAddressFromDeployment = readAddressFromDeployment;
+exports.validateTransaction = validateTransaction;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map