@sign-global/tokentable-core 1.14.2 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sign-global/tokentable-core",
-  "version": "1.14.2",
+  "version": "2.0.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -36,9 +36,8 @@
     "bignumber.js": "^9.1.2",
     "dayjs": "^1.11.13",
     "nanoid": "^5.0.9",
-    "@mysten/dapp-kit": "^0.16.3",
-    "@mysten/sui": "^1.29.1",
-    "@mysten/wallet-standard": "^0.16.10",
+    "@mysten/sui": "^2.28.0",
+    "@mysten/wallet-standard": "^0.21.21",
     "@aptos-labs/ts-sdk": "^4.0.0",
     "@aptos-labs/wallet-adapter-react": "^7.0.4"
   },

package/src/constants/network.ts

@@ -1,4 +1,3 @@
-import { getFullnodeUrl } from '@mysten/sui/client';
 import { CHAIN } from '@tonconnect/sdk';
 import { defineChain } from 'viem';
 
@@ -163,10 +162,10 @@ export const suiTestNet = {
   },
   rpcUrls: {
     public: {
-      http: [getFullnodeUrl('testnet')]
+      http: ['https://fullnode.testnet.sui.io:443']
     },
     default: {
-      http: [getFullnodeUrl('testnet')]
+      http: ['https://fullnode.testnet.sui.io:443']
     }
   },
   blockExplorers: {
@@ -189,10 +188,10 @@ export const suiMainNet = {
   },
   rpcUrls: {
     public: {
-      http: [getFullnodeUrl('mainnet')]
+      http: ['https://fullnode.mainnet.sui.io:443']
     },
     default: {
-      http: [getFullnodeUrl('mainnet')]
+      http: ['https://fullnode.mainnet.sui.io:443']
     }
   },
   blockExplorers: {

package/src/contracts/sui/BaseDistributorClient.ts

@@ -1,6 +1,7 @@
 import { SuiContractClientBase, SuiContractInfo } from './SuiContractClient';
 import { Transaction } from '@mysten/sui/transactions';
 import { bcs } from '@mysten/sui/bcs';
+import { fromBase64 } from '@mysten/sui/utils';
 
 export class SuiBaseDistributorClient extends SuiContractClientBase {
   constructor(info: SuiContractInfo) {
@@ -20,19 +21,14 @@ export class SuiBaseDistributorClient extends SuiContractClientBase {
 
     const result = await this.signAndExecute(tx);
 
-    let distributorId: string | undefined;
-    if (result.effects?.created) {
-      const createdObj = result.effects.created.find(
-        (obj: any) => obj.owner === 'Shared' || obj.owner?.Shared // 某些版本字段是对象
-      );
-      if (createdObj) {
-        distributorId = createdObj.reference.objectId;
-      }
-    }
+    // 新建的 shared object 即 distributor
+    const createdObj = result.effects?.changedObjects.find(
+      (obj) => obj.idOperation === 'Created' && obj.outputOwner?.$kind === 'Shared'
+    );
 
     return {
       txResult: result,
-      distributorId
+      distributorId: createdObj?.objectId
     };
   }
 
@@ -69,20 +65,20 @@ export class SuiBaseDistributorClient extends SuiContractClientBase {
   }
 
   async getDistributorInfo() {
-    const res = await this.client.getObject({
-      id: this.distributorId!,
-      options: { showContent: true }
+    const { object } = await this.client.getObject({
+      objectId: this.distributorId!,
+      include: { json: true }
     });
-    const content: any = (res as any).data?.content as any;
-    const fields = content?.fields as any;
-    const match = content?.type.match(/<(.+)>$/);
+    const fields = object.json as any;
+    const match = object.type.match(/<(.+)>$/);
     const coinType = match ? match[1] : '';
     return {
       startTime: fields?.start_time,
       endTime: fields?.end_time,
-      signer: fields?.authorized_signer,
+      signer: fields?.authorized_public_key,
       ownerCapId: fields?.owner_cap_id,
-      version: fields?.version ? String.fromCharCode(...(fields.version as number[])) : undefined,
+      // gRPC JSON 中 vector<u8> 以 base64 返回
+      version: fields?.version ? new TextDecoder().decode(fromBase64(fields.version)) : undefined,
       feeCollector: fields?.fee_collector_config,
       token: coinType,
       tokenBalance: fields?.token_balance,
@@ -113,42 +109,30 @@ export class SuiBaseDistributorClient extends SuiContractClientBase {
 
   async batchFetchClaimed(coinType: string, claimIds: string[]): Promise<boolean[]> {
     const claimIdsBytes = claimIds.map((id) => Array.from(new TextEncoder().encode(id)));
-    const res = await this.readMoveFunction<[number[], string]>(
-      'get_claim_status',
-      [coinType],
-      [this.distributorId!, claimIdsBytes]
-    );
-
-    const [data, type] = res;
+    const res = await this.readMoveFunction('get_claim_status', [coinType], [this.distributorId!, claimIdsBytes]);
 
     // 使用 BCS 解码 vector<bool>
-    if (type === 'vector<bool>' && data) {
-      // data 通常是 Uint8Array 格式
-      const uint8Array = new Uint8Array(data);
-      return Array.from(bcs.vector(bcs.bool()).parse(uint8Array));
-    }
-    return [];
+    return bcs.vector(bcs.bool()).parse(res);
   }
 
   async getDistributorId(projectId: string, projectRegistryId: string) {
-    const distributorId = await this.readMoveFunction<{ Some?: string; None?: null }>(
+    const res = await this.readMoveFunction(
       'get_distributor_by_project_id',
       [],
       [projectRegistryId, Array.from(Buffer.from(projectId, 'utf8'))]
     );
-    return distributorId.Some;
+    // 使用 BCS 解码 Option<ID>
+    return bcs.option(bcs.Address).parse(res);
   }
 
   async getOwnerCapId() {
-    const objects = await this.client.getOwnedObjects({
+    const { objects } = await this.client.listOwnedObjects({
       owner: this.wallet.accounts[0].address,
-      filter: {
-        StructType: `${this.packageId}::ownable::OwnerCap`
-      }
+      type: `${this.packageId}::ownable::OwnerCap`
     });
 
     // 获取 OwnerCap 对象ID
-    const ownerCapId = objects.data[0]?.data?.objectId;
+    const ownerCapId = objects[0]?.objectId;
 
     return ownerCapId;
   }

package/src/contracts/sui/DistributorWithFeeClient.ts

@@ -12,27 +12,27 @@ export class SuiDistributorWithFeeClient extends SuiContractClientBase {
     const totalFees = BigInt(totalFeesStr);
 
     // 获取用户的 coins
-    const coins = await this.client.getCoins({
+    const coins = await this.client.listCoins({
       owner: this.wallet.accounts[0].address,
       coinType: feeTokenType
     });
 
     // 找到足够余额的单个 coin
-    const suitableCoin = coins.data.find((coin) => BigInt(coin.balance) >= totalFees);
+    const suitableCoin = coins.objects.find((coin) => BigInt(coin.balance) >= totalFees);
 
     if (suitableCoin) {
       // 如果coin的余额正好等于所需费用，直接使用
       if (BigInt(suitableCoin.balance) === totalFees) {
-        return tx.object(suitableCoin.coinObjectId);
+        return tx.object(suitableCoin.objectId);
       }
       // 如果coin的余额大于所需费用，需要分割coin
-      const [feeCoin] = tx.splitCoins(tx.object(suitableCoin.coinObjectId), [tx.pure(bcs.u64().serialize(totalFees))]);
+      const [feeCoin] = tx.splitCoins(tx.object(suitableCoin.objectId), [tx.pure(bcs.u64().serialize(totalFees))]);
       return feeCoin;
     }
 
     // 如果没有单个足够的 coin，需要合并多个 coins
     // 这里可以实现 coin 合并逻辑或抛出错误
-    throw new Error(`Insufficient balance. Required: ${totalFeesStr}, Available coins: ${coins.data.length}`);
+    throw new Error(`Insufficient balance. Required: ${totalFeesStr}, Available coins: ${coins.objects.length}`);
   }
 
   async claimWithFee(coinType: string, feeCollector: string, data: ISignatureClaimData[]) {
@@ -73,13 +73,13 @@ export class SuiDistributorWithFeeClient extends SuiContractClientBase {
     const feeTokenType = '0x2::sui::SUI'; // 或其他费用代币类型
 
     // 在splitCoins之前添加余额检查
-    const gasBalance = await this.client.getBalance({
+    const { balance: gasBalance } = await this.client.getBalance({
       owner: this.wallet.accounts[0].address,
       coinType: feeTokenType
     });
 
-    if (BigInt(gasBalance.totalBalance) < totalFees) {
-      throw new Error(`Insufficient SUI balance. Required: ${totalFees}, Available: ${gasBalance.totalBalance}`);
+    if (BigInt(gasBalance.balance) < totalFees) {
+      throw new Error(`Insufficient SUI balance. Required: ${totalFees}, Available: ${gasBalance.balance}`);
     }
 
     const [feeCoin] = tx.splitCoins(

package/src/contracts/sui/SuiContractClient.ts

@@ -1,6 +1,7 @@
-import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
 import { bcs } from '@mysten/sui/bcs';
 import { Transaction } from '@mysten/sui/transactions';
+import { fromBase64 } from '@mysten/sui/utils';
 import { signTransaction, Wallet } from '@mysten/wallet-standard';
 
 export interface SuiContractInfo {
@@ -9,6 +10,7 @@ export interface SuiContractInfo {
   walletClient: Wallet;
   coinType: string;
   distributorId?: string;
+  /** gRPC endpoint, e.g. https://fullnode.mainnet.sui.io:443 */
   chainRpc?: string;
 }
 
@@ -18,7 +20,7 @@ export abstract class SuiContractClientBase {
   protected moduleName: string;
   protected distributorId?: string;
   protected wallet: Wallet;
-  protected client: SuiClient;
+  protected client: SuiGrpcClient;
 
   constructor(contractInfo: SuiContractInfo & { moduleName: string }) {
     this.packageId = contractInfo.packageId;
@@ -26,7 +28,10 @@ export abstract class SuiContractClientBase {
     this.moduleName = contractInfo.moduleName;
     this.distributorId = contractInfo.distributorId;
     this.wallet = contractInfo.walletClient;
-    this.client = new SuiClient({ network: this.chainId, url: contractInfo.chainRpc || getFullnodeUrl(this.chainId) });
+    this.client = new SuiGrpcClient({
+      network: this.chainId,
+      baseUrl: contractInfo.chainRpc || `https://fullnode.${this.chainId}.sui.io:443`
+    });
   }
 
   async signAndExecute(tx: Transaction) {
@@ -77,35 +82,36 @@ export abstract class SuiContractClientBase {
     });
 
     // 发送交易
-    const result = await this.client.executeTransactionBlock({
-      transactionBlock: bytes,
-      signature,
-      options: {
-        showEffects: true,
-        showEvents: true
-      }
+    const result = await this.client.executeTransaction({
+      transaction: fromBase64(bytes),
+      signatures: [signature],
+      include: { effects: true, events: true }
     });
 
+    if (result.$kind === 'FailedTransaction') {
+      throw new Error(result.FailedTransaction.status.error?.message ?? 'Transaction failed');
+    }
+
     // 等待交易确认
-    await this.waitForTx(result.digest);
+    await this.waitForTx(result.Transaction.digest);
 
-    return result;
+    return result.Transaction;
   }
 
   protected async waitForTx(digest: string) {
     return this.client.waitForTransaction({
       digest,
-      options: { showEffects: true, showEvents: true }
+      include: { effects: true, events: true }
     });
   }
 
   /**
-   * 读取合约返回值（只读调用）
+   * 读取合约返回值（只读调用），返回第一个返回值的 BCS 字节
    * @param func Move function 名
    * @param typeArgs 类型参数
    * @param args Move function 参数
    */
-  async readMoveFunction<T = any>(func: string, typeArgs: string[] = [], args: any[] = []): Promise<T> {
+  async readMoveFunction(func: string, typeArgs: string[] = [], args: any[] = []): Promise<Uint8Array> {
     const DEFAULT_SENDER = '0x0000000000000000000000000000000000000000000000000000000000000001';
     const sender = this.wallet?.accounts?.[0]?.address || DEFAULT_SENDER;
     if (!sender) throw new Error('No wallet account selected');
@@ -122,55 +128,55 @@ export abstract class SuiContractClientBase {
         return tx.pure(arg); // 纯量 u64、address 等
       })
     });
+    tx.setSender(sender);
 
-    // devInspectTransactionBlock 不消耗 Gas
-    const res = await this.client.devInspectTransactionBlock({
-      sender,
-      transactionBlock: tx // ✅ 这里传 Transaction，不再报 TS 类型错误
+    // simulateTransaction 不消耗 Gas；关闭 checks 以允许调用非 entry 函数
+    const res = await this.client.simulateTransaction({
+      transaction: tx,
+      checksEnabled: false,
+      include: { commandResults: true }
     });
 
     console.log(res, 'res');
 
-    if (!res || !res.results?.[0]?.returnValues) {
+    if (res.$kind === 'FailedTransaction') {
+      throw new Error(`Failed to read ${func}: ${res.FailedTransaction.status.error?.message}`);
+    }
+
+    const returnValue = res.commandResults?.[0]?.returnValues?.[0]?.bcs;
+    if (!returnValue) {
       throw new Error(`Failed to read ${func}`);
     }
 
-    return res.results[0].returnValues[0] as T;
+    return returnValue;
   }
 
   /**
    * 查询 Distributor MoveObject 的 fields
    */
   async getObjectFields(objectId: string) {
-    const res = await this.client.getObject({
-      id: objectId,
-      options: { showContent: true }
+    const { object } = await this.client.getObject({
+      objectId,
+      include: { json: true }
     });
 
-    if (res.data?.content?.dataType !== 'moveObject') {
+    if (!object.json) {
       throw new Error(`Object ${objectId} is not a moveObject`);
     }
 
-    return res.data.content.fields;
+    return object.json;
   }
 
   async getSharedObjectRef(tx: Transaction, objectId: string, mutable: boolean) {
-    const obj = await this.client.getObject({
-      id: objectId,
-      options: { showOwner: true }
-    });
+    const { object } = await this.client.getObject({ objectId });
 
-    console.log(obj, 'obj');
-
-    if (!obj.data) {
-      throw new Error(`Object ${objectId} not found`);
-    }
+    console.log(object, 'obj');
 
-    if (!(obj.data.owner as any)?.Shared) {
+    if (object.owner.$kind !== 'Shared') {
       throw new Error(`Object ${objectId} is not a shared object`);
     }
 
-    const initialSharedVersion = (obj.data.owner as any).Shared.initial_shared_version;
+    const initialSharedVersion = object.owner.Shared.initialSharedVersion;
 
     return tx.sharedObjectRef({
       objectId,

package/src/contracts/sui/__tests__/SuiContractClient.test.ts

@@ -2,13 +2,12 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 const suiClientArgs = vi.fn();
 
-vi.mock('@mysten/sui/client', () => ({
-  SuiClient: class {
-    constructor(args: { network: string; url: string }) {
+vi.mock('@mysten/sui/grpc', () => ({
+  SuiGrpcClient: class {
+    constructor(args: { network: string; baseUrl: string }) {
       suiClientArgs(args);
     }
-  },
-  getFullnodeUrl: (network: string) => `https://fullnode.${network}.sui.io:443`
+  }
 }));
 
 import { SuiContractClientBase, SuiContractInfo } from '../SuiContractClient';
@@ -29,11 +28,11 @@ describe('SuiContractClientBase RPC selection', () => {
   });
 
   it('uses chainRpc when provided', () => {
-    new TestClient({ ...baseInfo, chainRpc: 'https://sui-mainnet.g.alchemy.com/v2/key' });
+    new TestClient({ ...baseInfo, chainRpc: 'https://sui-mainnet.grpc.example.com:443' });
 
     expect(suiClientArgs).toHaveBeenCalledWith({
       network: 'mainnet',
-      url: 'https://sui-mainnet.g.alchemy.com/v2/key'
+      baseUrl: 'https://sui-mainnet.grpc.example.com:443'
     });
   });
 
@@ -42,7 +41,16 @@ describe('SuiContractClientBase RPC selection', () => {
 
     expect(suiClientArgs).toHaveBeenCalledWith({
       network: 'mainnet',
-      url: 'https://fullnode.mainnet.sui.io:443'
+      baseUrl: 'https://fullnode.mainnet.sui.io:443'
+    });
+  });
+
+  it('uses the testnet fullnode for testnet', () => {
+    new TestClient({ ...baseInfo, chainId: 'testnet' });
+
+    expect(suiClientArgs).toHaveBeenCalledWith({
+      network: 'testnet',
+      baseUrl: 'https://fullnode.testnet.sui.io:443'
     });
   });
 });