@sign-global/tokentable-core 1.0.0 → 1.2.0

package/src/contracts/sui/SuiContractClient.ts

@@ -0,0 +1,181 @@
+import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
+import { bcs } from '@mysten/sui/bcs';
+import { Transaction } from '@mysten/sui/transactions';
+import { signTransaction, Wallet } from '@mysten/wallet-standard';
+
+export interface SuiContractInfo {
+  packageId: string;
+  chainId?: 'testnet' | 'mainnet';
+  walletClient: Wallet;
+  coinType: string;
+  distributorId?: string;
+  chainRpc?: string;
+}
+
+export abstract class SuiContractClientBase {
+  protected packageId: string;
+  protected chainId: 'testnet' | 'mainnet';
+  protected moduleName: string;
+  protected distributorId?: string;
+  protected wallet: Wallet;
+  protected client: SuiClient;
+
+  constructor(contractInfo: SuiContractInfo & { moduleName: string }) {
+    this.packageId = contractInfo.packageId;
+    this.chainId = contractInfo.chainId ? contractInfo.chainId : 'mainnet';
+    this.moduleName = contractInfo.moduleName;
+    this.distributorId = contractInfo.distributorId;
+    this.wallet = contractInfo.walletClient;
+    this.client = new SuiClient({ network: this.chainId, url: getFullnodeUrl(this.chainId) });
+  }
+
+  async signAndExecute(tx: Transaction) {
+    if (!this.wallet) {
+      throw new Error('Wallet not connected');
+    }
+    if (!this.wallet.features?.['sui:signTransaction'] && !this.wallet.features?.['sui:signTransactionBlock']) {
+      throw new Error("Wallet doesn't support transaction signing");
+    }
+
+    const accounts = await this.wallet.accounts;
+    const client = this.client;
+    if (!accounts || accounts.length === 0) {
+      throw new Error('No wallet account connected');
+    }
+    const signerAccount = accounts[0];
+
+    // 设置交易发送者
+    if ('setSenderIfNotSet' in tx) {
+      tx.setSenderIfNotSet(signerAccount.address);
+    }
+
+    console.log(
+      tx,
+      await tx.toJSON({
+        supportedIntents: [],
+        client
+      })
+    );
+
+    // 准备链标识，匹配 hook 里的格式
+    const chain = `sui:${this.chainId}` as `${string}:${string}`;
+
+    // 调用 wallet-standard 的 signTransaction 来签名
+    const { signature, bytes } = await signTransaction(this.wallet, {
+      transaction: {
+        async toJSON() {
+          return typeof tx === 'string'
+            ? tx
+            : await tx.toJSON({
+                supportedIntents: [],
+                client
+              });
+        }
+      },
+      account: signerAccount,
+      chain: chain
+    });
+
+    // 发送交易
+    const result = await this.client.executeTransactionBlock({
+      transactionBlock: bytes,
+      signature,
+      options: {
+        showEffects: true,
+        showEvents: true
+      }
+    });
+
+    // 等待交易确认
+    await this.waitForTx(result.digest);
+
+    return result;
+  }
+
+  protected async waitForTx(digest: string) {
+    return this.client.waitForTransaction({
+      digest,
+      options: { showEffects: true, showEvents: true }
+    });
+  }
+
+  /**
+   * 读取合约返回值（只读调用）
+   * @param func Move function 名
+   * @param typeArgs 类型参数
+   * @param args Move function 参数
+   */
+  async readMoveFunction<T = any>(func: string, typeArgs: string[] = [], args: any[] = []): Promise<T> {
+    const DEFAULT_SENDER = '0x0000000000000000000000000000000000000000000000000000000000000001';
+    const sender = this.wallet?.accounts?.[0]?.address || DEFAULT_SENDER;
+    if (!sender) throw new Error('No wallet account selected');
+
+    // 创建 Transaction
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::${this.moduleName}::${func}`,
+      typeArguments: typeArgs,
+      arguments: args.map((arg) => {
+        // 自动把纯数据转换成 Move 所需格式
+        if (Array.isArray(arg)) return tx.pure(bcs.vector(bcs.vector(bcs.u8())).serialize(arg)); // vector<u8>
+        if (typeof arg === 'string' && arg.startsWith('0x')) return tx.object(arg); // object ID
+        return tx.pure(arg); // 纯量 u64、address 等
+      })
+    });
+
+    // devInspectTransactionBlock 不消耗 Gas
+    const res = await this.client.devInspectTransactionBlock({
+      sender,
+      transactionBlock: tx // ✅ 这里传 Transaction，不再报 TS 类型错误
+    });
+
+    console.log(res, 'res');
+
+    if (!res || !res.results?.[0]?.returnValues) {
+      throw new Error(`Failed to read ${func}`);
+    }
+
+    return res.results[0].returnValues[0] as T;
+  }
+
+  /**
+   * 查询 Distributor MoveObject 的 fields
+   */
+  async getObjectFields(objectId: string) {
+    const res = await this.client.getObject({
+      id: objectId,
+      options: { showContent: true }
+    });
+
+    if (res.data?.content?.dataType !== 'moveObject') {
+      throw new Error(`Object ${objectId} is not a moveObject`);
+    }
+
+    return res.data.content.fields;
+  }
+
+  async getSharedObjectRef(tx: Transaction, objectId: string, mutable: boolean) {
+    const obj = await this.client.getObject({
+      id: objectId,
+      options: { showOwner: true }
+    });
+
+    console.log(obj, 'obj');
+
+    if (!obj.data) {
+      throw new Error(`Object ${objectId} not found`);
+    }
+
+    if (!(obj.data.owner as any)?.Shared) {
+      throw new Error(`Object ${objectId} is not a shared object`);
+    }
+
+    const initialSharedVersion = (obj.data.owner as any).Shared.initial_shared_version;
+
+    return tx.sharedObjectRef({
+      objectId,
+      initialSharedVersion: Number(initialSharedVersion),
+      mutable
+    });
+  }
+}

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

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { SignatureAirdropService } from '../SignatureAirdropService';
+
+describe('SignatureAirdropService Tests', () => {
+  let service: SignatureAirdropService;
+
+  const mockOptions = {
+    chainId: 'testnet' as const,
+    coinType: '0x294e0f1f6b59549d024451b5cd2399c39a1060ee34732933e8d733d9f7693836::test_coin::TEST_COIN',
+    distributorId: '0x19b0eb3facd913b78d94787175547e33e7f641ad64ed9671bcd10e6ac846a3c0',
+    chainRpc: 'https://fullnode.testnet.sui.io',
+    packageId: '0xb15f286ba26aa10fc237c2c905fe630c840947234fe0b307b93deae271967380'
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Create real service instance
+    service = new SignatureAirdropService({
+      ...mockOptions,
+      walletClient: null as any
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('batchFetchClaimed Real Test', () => {
+    it('should call real batchFetchClaimed method with actual service', async () => {
+      const mockClaimIds = [
+        '0xc189c7c93c1adf3c135076b39c5c860cf18168141da13076f65a95412a51ff35',
+        '0x06e7e937178c19b5ba82999fe118af45abc9442d1f0e556ff1cfa454e6e05081'
+      ];
+
+      // This will call the real method and may fail due to network/contract issues
+      const result = await service.batchFetchClaimed(mockClaimIds);
+      console.log('BatchFetchClaimed result:', result);
+
+      // If we get here, the method executed successfully
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(mockClaimIds.length);
+      // 期望result是两个bool值
+      expect(result.every((item) => typeof item === 'boolean')).toBe(true);
+    });
+  });
+
+  describe('getContractInfo', () => {
+    it('should return actual contract info when called with real service', async () => {
+      // This test calls the real method and may fail due to network/contract issues
+      try {
+        const result = await service.getContractInfo();
+        console.log('Contract info result:', result);
+
+        // If we get here, the method executed successfully
+        expect(result).toBeDefined();
+        expect(typeof result).toBe('object');
+
+        // Check that the result has the expected structure
+        if (result) {
+          expect(result).toHaveProperty('feeCollector');
+          expect(result).toHaveProperty('token');
+        }
+      } catch (error) {
+        console.log('Real contract info test failed (expected in test environment):', error);
+        // In test environment, this might fail due to network issues, which is acceptable
+        expect(error).toBeDefined();
+      }
+    });
+  });
+});

package/src/services/airdrop/index.ts

@@ -15,7 +15,9 @@ const createApiClient = (baseURL?: string) => {
 export const getAirdropProject = async (projectId: string, baseURL?: string): Promise<IProject> => {
   const client = createApiClient(baseURL);
   const res = await client.get<any>(`/airdrop-open/projects/${projectId}`);
-  if (!res) return res; // res is null
+  if (!res) {
+    throw new Error(`Project not found: ${projectId}`);
+  }
   const projectConfig = res?.themeConf;
   const blockCountries = safeParseJSON(projectConfig?.blockCountries);
   return {
@@ -91,6 +93,7 @@ interface WalletBindParams {
   timestamp: number;
   recipientType: string;
   address: string;
+  encodedMessage?: string;
 }
 
 const getSidHeader = (projectId: string) => ({

package/src/types/index.ts

@@ -3,6 +3,7 @@ import { TonAirdropService, EvmAirdropService } from '../contracts';
 import { ChainConfig } from '../constants';
 import { Chain, WalletClient as ViemWalletClient } from 'viem';
 import { WalletContextState as SolanaWalletState } from '@solana/wallet-adapter-react';
+import { Wallet as SuiWalletClient } from '@mysten/wallet-standard';
 
 export type ChainId = keyof typeof ChainConfig;
 
@@ -18,7 +19,8 @@ export interface EvmContractClientOption {
 export enum ChainType {
   Evm = 'evm',
   Ton = 'ton',
-  Solana = 'solana'
+  Solana = 'solana',
+  Sui = 'sui'
 }
 
 export type ThemeConfig = {
@@ -105,6 +107,7 @@ export type IAirdropClaim = {
   data: string;
   leaf: string;
   claimed?: boolean;
+  fees: string;
 
   claimId?: string;
 
@@ -118,9 +121,14 @@ export type IAirdropClaim = {
   project: IProject;
 };
 
+export interface IExtraData {
+  isLegacy: boolean;
+  attestationId: bigint;
+}
+
 export interface IAirdropClaimData extends IAirdropClaim {
-  extraData: any;
-  value: bigint;
+  extraData?: IExtraData;
+  value?: bigint | string;
 }
 
 export type IAirdropSignatureClaim = {
@@ -131,13 +139,33 @@ export type IAirdropSignatureClaim = {
   recipient: string;
   recipientType: string;
   claimId: string;
-  data?: string;
+  data?: {
+    claimableTimestamp: string;
+    claimableAmount: string;
+  };
   signature?: string;
   claimed?: boolean;
   note: string;
   fees: string;
 };
 
+export interface ISignatureClaimData {
+  recipient: string;
+  data:
+    | string
+    | {
+        claimableTimestamp: string;
+        claimableAmount: string;
+      };
+  claimId: string;
+  signature: string;
+  extraData?: string;
+  unlockingAt: number;
+  value: string;
+  fees: string;
+  hash: string;
+}
+
 export interface IAirdropSignatureIdentity {
   type: AirdropSigIdentityTypeEnum;
   value: string;
@@ -174,9 +202,9 @@ export enum EvmAirdropVersionEnum {
   V4 = '0.4.0' // zeta kyc、kyc threshold
 }
 
-export type IWalletClient = TonWalletClient | ViemWalletClient | SolanaWalletState;
+export type IWalletClient = TonWalletClient | ViemWalletClient | SolanaWalletState | SuiWalletClient;
 
-export type { TonWalletClient, ViemWalletClient, SolanaWalletState };
+export type { TonWalletClient, ViemWalletClient, SolanaWalletState, SuiWalletClient };
 export type IAirdropService = TonAirdropService | EvmAirdropService;
 
 type BaseAirdropOptions = {

package/src/utils/api-client.ts

@@ -16,7 +16,7 @@ type ApiResponse = {
 };
 
 export class ApiClient {
-  constructor(private options?: ApiClientOptions) {}
+  constructor(private options?: ApiClientOptions) { }
 
   extend(options: ApiClientOptions): ApiClient {
     return new ApiClient({
@@ -59,7 +59,7 @@ export class ApiClient {
 
     const res = await fetch(finalUrl, init);
     const [status, resData]: [number, ApiResponse] = await Promise.all([res.status, res.json() as any]);
-    if ((status < 200 && status >= 300) || resData?.success !== true) {
+    if (status < 200 || status >= 300 || resData?.success !== true) {
       return Promise.reject(resData);
     }
     return resData.data;

package/src/utils/utils.ts

@@ -6,11 +6,16 @@ export const getCustomNaNoId = (): string => {
   return nanoid();
 };
 
-export const safeParseJSON = (str: string): any => {
+export const safeParseJSON = <T = any>(str: string | null | undefined, defaultValue: T = {} as T): T => {
+  if (!str || typeof str !== 'string') {
+    return defaultValue;
+  }
   try {
-    return JSON.parse(str);
+    const parsed = JSON.parse(str);
+    return parsed !== null && parsed !== undefined ? parsed : defaultValue;
   } catch (error) {
-    return {};
+    console.warn('Failed to parse JSON:', error);
+    return defaultValue;
   }
 };
 

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    silent: false,
+    environment: 'jsdom',
+    globals: true
+  },
+  resolve: {
+    alias: {
+      '@': './src'
+    }
+  }
+});