@easysui/sdk 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -2,12 +2,13 @@ import path from 'path';
 import * as fs3 from 'fs';
 import fs3__default from 'fs';
 import dotenv from 'dotenv';
-import { getJsonRpcFullnodeUrl, SuiJsonRpcClient } from '@mysten/sui/jsonRpc';
+import { getJsonRpcFullnodeUrl } from '@mysten/sui/jsonRpc';
 import { decodeSuiPrivateKey } from '@mysten/sui/cryptography';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { Secp256k1Keypair } from '@mysten/sui/keypairs/secp256k1';
 import { Secp256r1Keypair } from '@mysten/sui/keypairs/secp256r1';
 import { SUI_CLOCK_OBJECT_ID, fromHex, fromBase64, toBase64, normalizeStructTag, deriveObjectID, toHex } from '@mysten/sui/utils';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
 import { Transaction, coinWithBalance } from '@mysten/sui/transactions';
 import { bcs } from '@mysten/sui/bcs';
 import { spawn } from 'child_process';
@@ -1635,16 +1636,11 @@ var MoveType = /* @__PURE__ */ ((MoveType2) => {
   MoveType2[MoveType2["vec_u64"] = 14] = "vec_u64";
   return MoveType2;
 })(MoveType || {});
-var txOptions = {
-  showEffects: true,
-  showObjectChanges: true,
-  showBalanceChanges: true
-};
 var SuiClient = class _SuiClient {
   static instance = null;
   client;
   constructor() {
-    this.client = new SuiJsonRpcClient({ url: Config.vars.RPC, network: Config.vars.NETWORK });
+    this.client = new SuiGrpcClient({ baseUrl: Config.vars.RPC, network: Config.vars.NETWORK });
   }
   static getInstance() {
     if (!_SuiClient.instance) {
@@ -1656,20 +1652,31 @@ var SuiClient = class _SuiClient {
     return this.getInstance().client;
   }
   static async waitForTransaction(ptb, resp) {
-    await _SuiClient.client.waitForTransaction({ digest: resp.digest });
-    if (resp.effects?.status.status !== "success") {
+    await _SuiClient.client.core.waitForTransaction({ digest: resp.digest });
+    if (!resp.status.success) {
       throw new Error(JSON.stringify(resp));
     }
     analyze_cost(ptb, resp);
     return resp;
   }
   static async signAndExecute(ptb, signer) {
-    const resp = await _SuiClient.client.signAndExecuteTransaction({
+    const result = await _SuiClient.client.core.signAndExecuteTransaction({
       transaction: ptb,
       signer,
-      options: txOptions
+      include: {
+        effects: true,
+        events: true,
+        balanceChanges: true,
+        objectTypes: true,
+        transaction: true,
+        bcs: true
+      }
     });
-    return _SuiClient.waitForTransaction(ptb, resp);
+    const tx = result.Transaction ?? result.FailedTransaction;
+    if (!tx) {
+      throw new Error("Transaction failed with no response");
+    }
+    return _SuiClient.waitForTransaction(ptb, tx);
   }
   static toMoveArg(ptb, value, type3) {
     if (typeof value === "object" && !Array.isArray(value)) {
@@ -1760,11 +1767,14 @@ var SuiClient = class _SuiClient {
       gasOwnerSignature = await this.getSignature(gasOwnerSignature, transactionBlock);
       signature.push(gasOwnerSignature);
     }
-    const resp = await _SuiClient.client.executeTransactionBlock({
-      transactionBlock: toBase64(transactionBlock),
-      signature,
-      options: txOptions
+    const result = await _SuiClient.client.core.executeTransaction({
+      transaction: transactionBlock,
+      signatures: signature
     });
+    const resp = result.Transaction ?? result.FailedTransaction;
+    if (!resp) {
+      throw new Error("Transaction execution failed with no response");
+    }
     const ptb = Transaction.from(toBase64(transactionBlock));
     return _SuiClient.waitForTransaction(ptb, resp);
   }
@@ -1786,14 +1796,20 @@ var SuiClient = class _SuiClient {
     return await _SuiClient.signAndExecute(tx, from);
   }
   static async devInspect(ptb, sender) {
-    return await _SuiClient.client.devInspectTransactionBlock({
-      transactionBlock: ptb,
-      sender
+    ptb.setSender(sender);
+    return await _SuiClient.client.core.simulateTransaction({
+      transaction: ptb,
+      checksEnabled: false,
+      include: { commandResults: true }
     });
   }
   static async devInspectRaw(ptb, sender) {
     const result = await this.devInspect(ptb, sender);
-    return result.results?.[0].returnValues?.[0]?.[0];
+    const commandResult = result.commandResults?.[0];
+    if (!commandResult || !commandResult.returnValues?.[0]) {
+      return void 0;
+    }
+    return commandResult.returnValues[0];
   }
   static async devInspectBool(ptb, sender) {
     const result = await this.devInspectRaw(ptb, sender);
@@ -1819,24 +1835,25 @@ var SuiClient = class _SuiClient {
     return bcs.string().parse(new Uint8Array(value));
   }
   static async getObject(id) {
-    return _SuiClient.client.getObject({
-      id,
-      options: {
-        showContent: true,
-        showType: true,
-        showDisplay: true,
-        showBcs: true
+    return _SuiClient.client.core.getObject({
+      objectId: id,
+      include: {
+        content: true,
+        type: true,
+        display: true,
+        bcs: true
       }
     });
   }
   static async getObjectsByType(owner, type3) {
-    const res = await _SuiClient.client.getOwnedObjects({
+    const res = await _SuiClient.client.core.listOwnedObjects({
       owner,
-      filter: {
-        StructType: type3
+      type: type3,
+      include: {
+        content: true
       }
     });
-    return res.data.map((o) => o.data?.objectId).filter((o) => o);
+    return res.objects.map((o) => o.objectId).filter((o) => o);
   }
 };
 
@@ -16236,24 +16253,27 @@ var Coin = class {
     throw new Error("`coinType` getter must be implemented !");
   }
   static async getBalance(owner) {
-    const result = await SuiClient.client.getBalance({
-      owner,
-      coinType: this.coinType
+    const result = await SuiClient.client.core.listBalances({
+      owner
     });
-    return BigInt(result.totalBalance);
+    const balance = result.balances.find((b) => b.coinType === this.coinType);
+    return BigInt(balance?.balance || 0);
   }
-  static async getCoin(owner, amount) {
-    const balance = amount || await this.getBalance(owner.toSuiAddress());
-    const tx = new Transaction();
-    const coinSplit = coinWithBalance({
+  static coinWithBalance(balance) {
+    return coinWithBalance({
       balance,
       useGasCoin: false,
       type: this.coinType
     });
+  }
+  static async getCoin(owner, amount) {
+    const balance = amount || await this.getBalance(owner.toSuiAddress());
+    const tx = new Transaction();
+    const coinSplit = this.coinWithBalance(balance);
     tx.transferObjects([coinSplit], owner.toSuiAddress());
     const result = await SuiClient.signAndExecute(tx, owner);
-    const coin = result.objectChanges?.find(
-      (o) => o.type === "created" && o.objectType === `0x2::coin::Coin<${this.coinType}>`
+    const coin = result.effects?.changedObjects?.find(
+      (o) => o.idOperation === "Created"
     );
     return coin?.objectId;
   }
@@ -16282,9 +16302,8 @@ var Coin = class {
     });
   }
   static async send(amount, from, to) {
-    const coin = await this.getCoin(from, amount);
     const ptb = new Transaction();
-    ptb.transferObjects([ptb.object(coin)], to);
+    ptb.transferObjects([this.coinWithBalance(amount)], to);
     await SuiClient.signAndExecute(ptb, from);
   }
   static async assertBalance(wallet, amount) {
@@ -16535,12 +16554,14 @@ function sleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function waitForNextEpoch(timeoutMs = 5 * 60 * 1e3, pollIntervalMs = 2e3) {
-  const startEpoch = (await SuiClient.client.getLatestSuiSystemState()).epoch;
+  const startEpochData = await SuiClient.client.core.getCurrentSystemState();
+  const startEpoch = BigInt(startEpochData.systemState.epoch);
   const startTime = Date.now();
   while (true) {
-    const { epoch } = await SuiClient.client.getLatestSuiSystemState();
-    if (Number(epoch) > Number(startEpoch)) {
-      return epoch;
+    const currentEpochData = await SuiClient.client.core.getCurrentSystemState();
+    const currentEpoch = BigInt(currentEpochData.systemState.epoch);
+    if (currentEpoch > startEpoch) {
+      return currentEpoch.toString();
     }
     if (Date.now() - startTime > timeoutMs) {
       throw new Error("Timeout waiting for next epoch.");