@sign-global/tokentable-core 1.1.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

@@ -93,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 = {
@@ -137,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;
@@ -180,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/vitest.config.ts

@@ -2,13 +2,13 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
+    silent: false,
     environment: 'jsdom',
-    globals: true,
-    setupFiles: ['./src/test/setup.ts']
+    globals: true
   },
   resolve: {
     alias: {
       '@': './src'
     }
   }
-});
+});

package/src/test/setup.ts

@@ -1,24 +0,0 @@
-import { vi } from 'vitest';
-
-// Mock console.log to avoid noise in tests
-global.console = {
-  ...console,
-  log: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn()
-};
-
-// Setup global test environment
-Object.defineProperty(window, 'matchMedia', {
-  writable: true,
-  value: vi.fn().mockImplementation(query => ({
-    matches: false,
-    media: query,
-    onchange: null,
-    addListener: vi.fn(),
-    removeListener: vi.fn(),
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-    dispatchEvent: vi.fn(),
-  })),
-});

package/src/utils/__tests__/web3.test.ts

@@ -1,326 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Connection, PublicKey, Transaction, Commitment } from '@solana/web3.js';
-import {
-  getAccount,
-  getAssociatedTokenAddress,
-  createAssociatedTokenAccountInstruction,
-  TokenAccountNotFoundError,
-  TokenInvalidAccountOwnerError,
-  TokenInvalidMintError,
-  TokenInvalidOwnerError,
-  TOKEN_PROGRAM_ID,
-  ASSOCIATED_TOKEN_PROGRAM_ID
-} from '@solana/spl-token';
-import { getOrCreateAssociatedTokenAccount } from '../web3';
-
-// Mock @solana/spl-token
-vi.mock('@solana/spl-token', () => ({
-  getAccount: vi.fn(),
-  getAssociatedTokenAddress: vi.fn(),
-  createAssociatedTokenAccountInstruction: vi.fn(),
-  TokenAccountNotFoundError: class extends Error {},
-  TokenInvalidAccountOwnerError: class extends Error {},
-  TokenInvalidMintError: class extends Error {},
-  TokenInvalidOwnerError: class extends Error {},
-  TOKEN_PROGRAM_ID: new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
-  ASSOCIATED_TOKEN_PROGRAM_ID: new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL')
-}));
-
-// Mock @solana/web3.js
-vi.mock('@solana/web3.js', async () => {
-  const actual = await vi.importActual('@solana/web3.js');
-  return {
-    ...actual,
-    Connection: vi.fn(),
-    PublicKey: actual.PublicKey,
-    Transaction: vi.fn()
-  };
-});
-
-describe('getOrCreateAssociatedTokenAccount', () => {
-  let mockConnection: any;
-  let mockSignTransaction: any;
-  let mockPayer: PublicKey;
-  let mockMint: PublicKey;
-  let mockOwner: PublicKey;
-  let mockAssociatedToken: PublicKey;
-  let mockTransaction: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Setup mock objects with valid base58 public keys
-    mockPayer = new PublicKey('11111111111111111111111111111112');
-    mockMint = new PublicKey('So11111111111111111111111111111111111111112');
-    mockOwner = new PublicKey('9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM');
-    mockAssociatedToken = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
-
-    mockConnection = {
-      getLatestBlockhash: vi.fn().mockResolvedValue({
-        blockhash: 'test-blockhash',
-        lastValidBlockHeight: 12345
-      }),
-      sendRawTransaction: vi.fn().mockResolvedValue('test-signature'),
-      confirmTransaction: vi.fn().mockResolvedValue({ value: { err: null } })
-    };
-
-    mockTransaction = {
-      add: vi.fn().mockReturnThis(),
-      serialize: vi.fn().mockReturnValue(Buffer.from('serialized-transaction')),
-      feePayer: undefined,
-      recentBlockhash: undefined
-    };
-
-    mockSignTransaction = vi.fn().mockResolvedValue(mockTransaction);
-
-    // Setup mocks
-    vi.mocked(getAssociatedTokenAddress).mockResolvedValue(mockAssociatedToken);
-    vi.mocked(Transaction).mockReturnValue(mockTransaction);
-    vi.mocked(createAssociatedTokenAccountInstruction).mockReturnValue({} as any);
-  });
-
-  it('should return existing account when account exists', async () => {
-    const mockAccount = {
-      address: mockAssociatedToken,
-      mint: mockMint,
-      owner: mockOwner,
-      amount: BigInt(1000),
-      delegate: null,
-      delegatedAmount: BigInt(0),
-      isInitialized: true,
-      isFrozen: false,
-      isNative: false,
-      rentExemptReserve: null,
-      closeAuthority: null,
-      tlvData: Buffer.alloc(0),
-    };
-
-    vi.mocked(getAccount).mockResolvedValue(mockAccount);
-
-    const result = await getOrCreateAssociatedTokenAccount({
-      connection: mockConnection,
-      payer: mockPayer,
-      mint: mockMint,
-      owner: mockOwner,
-      signTransaction: mockSignTransaction
-    });
-
-    expect(result).toBe(mockAccount);
-    expect(getAssociatedTokenAddress).toHaveBeenCalledWith(
-      mockMint,
-      mockOwner,
-      false,
-      TOKEN_PROGRAM_ID,
-      ASSOCIATED_TOKEN_PROGRAM_ID
-    );
-    expect(getAccount).toHaveBeenCalledWith(
-      mockConnection,
-      mockAssociatedToken,
-      undefined,
-      TOKEN_PROGRAM_ID
-    );
-  });
-
-  it('should create new account when TokenAccountNotFoundError occurs', async () => {
-    const mockAccount = {
-      address: mockAssociatedToken,
-      mint: mockMint,
-      owner: mockOwner,
-      amount: BigInt(1000),
-      delegate: null,
-      delegatedAmount: BigInt(0),
-      isInitialized: true,
-      isFrozen: false,
-      isNative: false,
-      rentExemptReserve: null,
-      closeAuthority: null,
-      tlvData: Buffer.alloc(0),
-    };
-
-    // First call throws error, second call returns account
-    vi.mocked(getAccount)
-      .mockRejectedValueOnce(new TokenAccountNotFoundError())
-      .mockResolvedValueOnce(mockAccount);
-
-    const result = await getOrCreateAssociatedTokenAccount({
-      connection: mockConnection,
-      payer: mockPayer,
-      mint: mockMint,
-      owner: mockOwner,
-      signTransaction: mockSignTransaction
-    });
-
-    expect(result).toBe(mockAccount);
-    expect(createAssociatedTokenAccountInstruction).toHaveBeenCalledWith(
-      mockPayer,
-      mockAssociatedToken,
-      mockOwner,
-      mockMint,
-      TOKEN_PROGRAM_ID,
-      ASSOCIATED_TOKEN_PROGRAM_ID
-    );
-    expect(mockSignTransaction).toHaveBeenCalledWith(mockTransaction);
-    expect(mockConnection.sendRawTransaction).toHaveBeenCalledWith(
-      Buffer.from('serialized-transaction')
-    );
-    expect(mockConnection.confirmTransaction).toHaveBeenCalled();
-  });
-
-  it('should create new account when TokenInvalidAccountOwnerError occurs', async () => {
-    const mockAccount = {
-      address: mockAssociatedToken,
-      mint: mockMint,
-      owner: mockOwner,
-      amount: BigInt(1000),
-      delegate: null,
-      delegatedAmount: BigInt(0),
-      isInitialized: true,
-      isFrozen: false,
-      isNative: false,
-      rentExemptReserve: null,
-      closeAuthority: null,
-      tlvData: Buffer.alloc(0),
-    };
-
-    // First call throws error, second call returns account
-    vi.mocked(getAccount)
-      .mockRejectedValueOnce(new TokenInvalidAccountOwnerError())
-      .mockResolvedValueOnce(mockAccount);
-
-    const result = await getOrCreateAssociatedTokenAccount({
-      connection: mockConnection,
-      payer: mockPayer,
-      mint: mockMint,
-      owner: mockOwner,
-      signTransaction: mockSignTransaction
-    });
-
-    expect(result).toBe(mockAccount);
-    expect(createAssociatedTokenAccountInstruction).toHaveBeenCalled();
-    expect(mockSignTransaction).toHaveBeenCalled();
-  });
-
-  it('should throw TokenInvalidMintError when mint does not match', async () => {
-    const wrongMint = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
-    const wrongAccount = {
-        address: mockAssociatedToken,
-        mint: wrongMint,
-        owner: mockOwner,
-        amount: BigInt(1000),
-        delegate: null,
-        delegatedAmount: BigInt(0),
-        isInitialized: true,
-        isFrozen: false,
-        isNative: false,
-        rentExemptReserve: null,
-        closeAuthority: null,
-        tlvData: Buffer.alloc(0),
-      };
-
-    vi.mocked(getAccount).mockResolvedValue(wrongAccount);
-
-    await expect(
-      getOrCreateAssociatedTokenAccount({
-        connection: mockConnection,
-        payer: mockPayer,
-        mint: mockMint,
-        owner: mockOwner,
-        signTransaction: mockSignTransaction
-      })
-    ).rejects.toThrow(TokenInvalidMintError);
-  });
-
-  it('should throw TokenInvalidOwnerError when owner does not match', async () => {
-    const wrongOwner = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
-    const wrongAccount = {
-        address: mockAssociatedToken,
-        mint: mockMint,
-        owner: wrongOwner,
-        amount: BigInt(1000),
-        delegate: null,
-        delegatedAmount: BigInt(0),
-        isInitialized: true,
-        isFrozen: false,
-        isNative: false,
-        rentExemptReserve: null,
-        closeAuthority: null,
-        tlvData: Buffer.alloc(0),
-      };
-
-    vi.mocked(getAccount).mockResolvedValue(wrongAccount);
-
-    await expect(
-      getOrCreateAssociatedTokenAccount({
-        connection: mockConnection,
-        payer: mockPayer,
-        mint: mockMint,
-        owner: mockOwner,
-        signTransaction: mockSignTransaction
-      })
-    ).rejects.toThrow(TokenInvalidOwnerError);
-  });
-
-  it('should handle custom parameters', async () => {
-    const customCommitment: Commitment = 'confirmed';
-    const customProgramId = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
-    const customAssociatedTokenProgramId = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
-    
-    const mockAccount = {
-      address: mockAssociatedToken,
-      mint: mockMint,
-      owner: mockOwner,
-      amount: BigInt(1000),
-      delegate: null,
-      delegatedAmount: BigInt(0),
-      isInitialized: true,
-      isFrozen: false,
-      isNative: false,
-      rentExemptReserve: null,
-      closeAuthority: null,
-      tlvData: Buffer.alloc(0),
-    };
-
-    vi.mocked(getAccount).mockResolvedValue(mockAccount);
-
-    await getOrCreateAssociatedTokenAccount({
-      connection: mockConnection,
-      payer: mockPayer,
-      mint: mockMint,
-      owner: mockOwner,
-      signTransaction: mockSignTransaction,
-      allowOwnerOffCurve: true,
-      commitment: customCommitment,
-      programId: customProgramId,
-      associatedTokenProgramId: customAssociatedTokenProgramId
-    });
-
-    expect(getAssociatedTokenAddress).toHaveBeenCalledWith(
-      mockMint,
-      mockOwner,
-      true,
-      customProgramId,
-      customAssociatedTokenProgramId
-    );
-    expect(getAccount).toHaveBeenCalledWith(
-      mockConnection,
-      mockAssociatedToken,
-      customCommitment,
-      customProgramId
-    );
-  });
-
-  it('should rethrow unexpected errors', async () => {
-    const unexpectedError = new Error('Unexpected error');
-    vi.mocked(getAccount).mockRejectedValue(unexpectedError);
-
-    await expect(
-      getOrCreateAssociatedTokenAccount({
-        connection: mockConnection,
-        payer: mockPayer,
-        mint: mockMint,
-        owner: mockOwner,
-        signTransaction: mockSignTransaction
-      })
-    ).rejects.toThrow('Unexpected error');
-  });
-});