@sign-global/tokentable 0.4.2-beta.2 → 0.4.2-beta.4

package/src/airdrop/tests/index.test.ts

@@ -1,387 +0,0 @@
-import { AirdropClient } from '../AirdropClient';
-import { TonClient } from '@ton/ton';
-
-describe('AirdropClient', () => {
-  let client: AirdropClient;
-  const mockTonClient = new TonClient({
-    endpoint: 'https://testnet.toncenter.com/api/v2/jsonRPC'
-  });
-  const mockEndpoint = 'https://dev.dev.ethsign.xyz:3057/api';
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('initialize', () => {
-    it('should use projectId correctly', async () => {
-      client = new AirdropClient({
-        projectId: 'AD_TEV94wvkxkvn',
-        endpoint: mockEndpoint
-      });
-
-      const projectInfo = await client.getProjectInfo();
-      expect(projectInfo).toBeDefined();
-    }, 6000);
-
-    it('should use slug correctly', async () => {
-      client = new AirdropClient({
-        slug: 'wat'
-      });
-
-      const projectInfo = await client.getProjectInfo();
-      expect(projectInfo).toBeTruthy();
-    });
-  });
-
-  describe('test main features', () => {
-    beforeEach(async () => {
-      client = new AirdropClient({
-        projectId: 'AD_TEV94wvkxkvn',
-        endpoint: mockEndpoint
-      });
-    });
-
-    it('should get version', async () => {
-      const version = await client.getVersion();
-      console.log(version);
-      expect(version).toBeDefined();
-
-      const client1 = new AirdropClient({
-        projectId: 'AD_oLDjKWXU6JZe'
-      });
-
-      const version1 = await client1.getVersion();
-      console.log(version1, 'v1');
-      expect(version1).toBeDefined();
-    });
-
-    it('should get paused', async () => {
-      const client = new AirdropClient({
-        projectId: 'AD_PeMV2dboWAui',
-        endpoint: mockEndpoint
-      });
-      const paused = await client.getPaused();
-      console.log(paused);
-      expect(paused).toBeDefined();
-    });
-
-    it('should get claim fee', async () => {
-      // evm
-      const client = new AirdropClient({
-        projectId: 'AD_50lczFu9Yhvq',
-        endpoint: mockEndpoint
-      });
-      const fee = await client.getClaimFee();
-      console.log(fee);
-      expect(fee).toBeDefined();
-    });
-
-    it('should get paused throw error', async () => {
-      // evm
-      const client = new AirdropClient({
-        projectId: 'AD_50lczFu9Yhvq',
-        endpoint: mockEndpoint
-      });
-      await expect(client.getPaused()).rejects.toThrow();
-    });
-
-    it('should check ton claimed', async () => {
-      const tonClient = new TonClient({
-        endpoint: 'https://testnet.toncenter.com/api/v2/jsonRPC'
-      });
-
-      const client = new AirdropClient({
-        projectId: 'AD_WIN4aTbjJPOp',
-        endpoint: mockEndpoint
-      });
-      client.setTonClient(tonClient);
-
-      const version = await client.getVersion();
-      console.log(version);
-      expect(version).toBeDefined();
-
-      const claims = await client.getAirdropClaims({ address: 'UQANAsrLyyHoq8N4EZ-QfADXhtoSUybdSKXOknMLWLbA7rt7' });
-
-      const claimed = await client.checkClaimed(claims?.[0].claimId as string);
-      expect(claimed).toBeDefined();
-    });
-
-    //AD_S4dSTEXQN96i
-
-    it('should work on native v1', async () => {
-      client = new AirdropClient({
-        projectId: 'AD_S4dSTEXQN96i',
-        endpoint: mockEndpoint
-      });
-      const version = await client.getVersion();
-      console.log(version);
-      expect(version).toBeDefined();
-      const fee = await client.getClaimFee();
-      console.log(fee);
-      expect(fee).toBeDefined();
-    });
-
-    it('should get airdrop claims', async () => {
-      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
-      expect(claims).toBeTruthy();
-      expect(claims?.length).toBe(1);
-    });
-
-    it('should check claimed', async () => {
-      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
-
-      const claimed = await client.checkClaimed(claims?.[0].claimId as string);
-      expect(claimed).toBeDefined();
-    });
-  });
-
-  describe('getStrategy', () => {
-    let client: AirdropClient;
-    const mockWalletClient = {
-      connected: true,
-      account: { address: '0xMockAddress' },
-      network: { name: 'mock', chainId: 1 },
-      connector: { name: 'mock' },
-      sendTransaction: jest.fn()
-    } as any;
-
-    beforeEach(async () => {
-      client = new AirdropClient({
-        projectId: 'AD_TEV94wvkxkvn',
-        endpoint: mockEndpoint
-      });
-      // Clear strategy cache before each test
-      jest.clearAllMocks();
-    });
-
-    it('should get strategy without wallet client (read-only mode)', async () => {
-      const strategy = await client.getStrategy();
-      expect(strategy).toBeDefined();
-      // Verify it's in read-only mode
-      expect((strategy as any).walletClient).toBeUndefined();
-    });
-
-    it('should get strategy with wallet client (interactive mode)', async () => {
-      const strategy = await client.getStrategy(mockWalletClient);
-      expect(strategy).toBeDefined();
-      expect((strategy as any).walletClient).toBeDefined();
-    });
-
-    it('should use cached strategy when available', async () => {
-      // First call to get strategy
-      const strategy1 = await client.getStrategy(mockWalletClient);
-
-      // Second call should return cached strategy
-      const strategy2 = await client.getStrategy(mockWalletClient);
-
-      // Both should be the same instance
-      expect(strategy1).toBe(strategy2);
-    });
-
-    it('should reinitialize wallet client even with cached strategy', async () => {
-      // Get strategy with first wallet client
-      const strategy1 = await client.getStrategy(mockWalletClient);
-
-      // Create new mock wallet client
-      const newMockWalletClient = {
-        connected: true,
-        account: { address: '0xNewMockAddress' },
-        network: { name: 'mock', chainId: 1 },
-        connector: { name: 'mock' },
-        sendTransaction: jest.fn()
-      } as any;
-
-      // Get strategy with new wallet client
-      const strategy2 = await client.getStrategy(newMockWalletClient);
-
-      // Should be same strategy instance but reinitialized with new wallet
-      expect((strategy2 as any).walletClient).toBeDefined();
-      expect((strategy2 as any).walletClient).toBe(newMockWalletClient);
-    });
-  });
-
-  describe('claimAirdrop', () => {
-    const mockClaim = jest.fn();
-    const mockGetClaimFee = jest.fn();
-    const mockWalletClient = {
-      connected: true,
-      account: { address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' },
-      network: { name: 'mock', chainId: 1 },
-      connector: { name: 'mock' },
-      sendTransaction: jest.fn(),
-      writeContract: jest.fn()
-    } as any;
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-      // Mock getStrategy to return a mock strategy
-      jest.spyOn(AirdropClient.prototype, 'getStrategy').mockResolvedValue({
-        claim: mockClaim,
-        isInitialized: () => true,
-        initialize: jest.fn(),
-        getVersion: jest.fn().mockResolvedValue('1.0.0'),
-        checkClaimed: jest.fn(),
-        getClaimFee: mockGetClaimFee
-      });
-    });
-
-    afterEach(() => {
-      jest.restoreAllMocks();
-    });
-
-    it('should claim EVM airdrop with fee (v1/v2)', async () => {
-      // Mock getClaimFee to return a specific value for this test
-      mockGetClaimFee.mockResolvedValueOnce(BigInt(1000));
-
-      const client = new AirdropClient({
-        projectId: 'AD_50lczFu9Yhvq', // EVM project with fee
-        endpoint: mockEndpoint
-      });
-
-      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
-
-      await client.claimAirdrop({
-        claimId: claims[0].claimId as string,
-        walletClient: mockWalletClient
-      });
-
-      // Verify claim was called with correct parameters
-      expect(mockClaim).toHaveBeenCalledWith(
-        expect.objectContaining({
-          extraData: {
-            isLegacy: true,
-            attestationId: BigInt(1)
-          },
-          value: BigInt(1000) // Should match the mocked getClaimFee value
-        }),
-        undefined
-      );
-    });
-
-    it('should claim EVM airdrop without fee', async () => {
-      // Mock getClaimFee to return undefined for this test
-      mockGetClaimFee.mockResolvedValueOnce(undefined);
-
-      const client = new AirdropClient({
-        projectId: 'AD_WMTW9cHZJB46', // EVM v3/v4 native project
-        endpoint: mockEndpoint
-      });
-
-      const claims = await client.getAirdropClaims({ address: '0x5f5F5919dEc54AdF9743dd2c9dA4EbE7D60B8B9b' });
-
-      await client.claimAirdrop({
-        claimId: claims[0].claimId as string,
-        walletClient: mockWalletClient
-      });
-
-      expect(mockClaim).toHaveBeenCalledWith(
-        expect.objectContaining({
-          extraData: {
-            isLegacy: true,
-            attestationId: BigInt(1)
-          },
-          value: undefined
-        }),
-        undefined
-      );
-    });
-
-    it('should claim TON airdrop', async () => {
-      const mockTonWallet = {
-        connected: true,
-        account: { address: 'EQMockTonAddress' },
-        network: { name: 'mock', chainId: 'mainnet' },
-        connector: { name: 'mock' },
-        sendTransaction: jest.fn()
-      } as any;
-
-      const client = new AirdropClient({
-        projectId: 'AD_PeMV2dboWAui', // TON project
-        endpoint: mockEndpoint
-      });
-
-      const claims = await client.getAirdropClaims({ address: 'UQANAsrLyyHoq8N4EZ-QfADXhtoSUybdSKXOknMLWLbA7rt7' });
-
-      await client.claimAirdrop({
-        claimId: claims[0].claimId!,
-        walletClient: mockTonWallet
-      });
-
-      // Verify claim parameters don't include extraData for TON
-      expect(mockClaim).toHaveBeenCalledWith(
-        expect.not.objectContaining({
-          extraData: expect.anything()
-        }),
-        undefined
-      );
-
-      // Verify the claim parameters have the necessary data
-      const callArgs = mockClaim.mock.calls[0][0];
-      expect(callArgs).toHaveProperty('claimId');
-      expect(callArgs).toHaveProperty('value', '0.1');
-      expect(callArgs).toHaveProperty('extraData', undefined);
-    });
-
-    it('should use custom claimHook if provided', async () => {
-      const client = new AirdropClient({
-        projectId: 'AD_50lczFu9Yhvq',
-        endpoint: mockEndpoint
-      });
-
-      const customExtraData = {
-        isLegacy: false,
-        attestationId: BigInt(999)
-      };
-
-      client.setClaimHook(() => customExtraData);
-
-      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
-
-      await client.claimAirdrop({
-        claimId: claims[0].claimId as string,
-        walletClient: mockWalletClient
-      });
-
-      expect(mockClaim).toHaveBeenCalledWith(
-        expect.objectContaining({
-          extraData: customExtraData
-        }),
-        undefined
-      );
-    });
-
-    it('should handle loading callback', async () => {
-      const client = new AirdropClient({
-        projectId: 'AD_PeMV2dboWAui',
-        endpoint: mockEndpoint
-      });
-
-      const claims = await client.getAirdropClaims({ address: 'UQANAsrLyyHoq8N4EZ-QfADXhtoSUybdSKXOknMLWLbA7rt7' });
-      const onLoading = jest.fn();
-
-      await client.claimAirdrop(
-        {
-          claimId: claims[0].claimId!,
-          walletClient: mockWalletClient
-        },
-        { onLoading }
-      );
-
-      expect(mockClaim).toHaveBeenCalledWith(expect.any(Object), { onLoading });
-    });
-
-    it('should throw error for invalid claim ID', async () => {
-      const client = new AirdropClient({
-        projectId: 'AD_50lczFu9Yhvq',
-        endpoint: mockEndpoint
-      });
-
-      await expect(
-        client.claimAirdrop({
-          claimId: 'invalid_claim_id',
-          walletClient: mockWalletClient
-        })
-      ).rejects.toThrow();
-    });
-  });
-});

package/src/airdrop/types/index.ts

@@ -1,200 +0,0 @@
-import { TonConnectUI as TonWalletClient } from '@tonconnect/ui-react';
-import { AirdropService as TonAirdropService } from '../contracts/ton/AirdropService';
-import { AirdropService as EvmAirdropService } from '../contracts/evm/AirdropService';
-import { ChainConfig } from '../constants';
-import { WalletClient as ViemWalletClient } from 'viem';
-import { WalletContextState as SolanaWalletState } from '@solana/wallet-adapter-react';
-
-export type ChainId = keyof typeof ChainConfig;
-
-export interface EvmContractClientOption {
-  chainId: ChainId;
-  walletClient?: ViemWalletClient;
-  contractAddress: string;
-  abi?: any;
-}
-
-export enum ChainType {
-  Evm = 'evm',
-  Ton = 'ton',
-  Solana = 'solana'
-}
-
-export type ThemeConfig = {
-  logo?: string;
-  title?: string;
-  description?: string;
-  coverImage?: string;
-  subTitle?: string;
-  primaryColor?: string;
-  secondaryColor?: string;
-  buttonPrimaryHover?: string;
-  buttonSecondaryHover?: string;
-  buttonPrimaryForeground?: string;
-  buttonSecondaryForeground?: string;
-  welcomeModalText?: string;
-  welcomeModalTitle?: string;
-  isShowWelcomeModal?: boolean;
-  blockCountries?: string;
-  termsOfUse?: string;
-  successModalPrimaryBtnText?: string;
-  successModalUrl?: string;
-  successModalTitle?: string;
-  successModalDesc?: string;
-  successModalShareTexts?: string;
-  isUnAvailable?: boolean;
-  privacyPolicy?: string;
-};
-
-export interface IProject {
-  id: string;
-  name: string;
-  chainId: string;
-  chainType: ChainType;
-  tokenAddress: string;
-  tokenType: string;
-  startTime: number;
-  endTime: number;
-  contractAddress: string;
-  recipientType: string;
-  merkleRoot: string;
-  ownerAddress: string;
-  blockCountries: Record<string, string>;
-  themeConf: ThemeConfig | null;
-  version: string;
-  extra?: IProjectExtra;
-  identities: Identity[];
-  projectTag: string;
-}
-
-export interface Identity {
-  identityType: string;
-  authorizeUrl?: string;
-}
-
-export enum AirdropSigIdentityTypeEnum {
-  Twitter = 'X Account',
-  SolanaWallet = 'Solana Wallet',
-  EVMWallet = 'EVM Wallet',
-  TONWallet = 'TON Wallet',
-  Google = 'Google Account'
-}
-
-export interface IProjectExtra {
-  kyc: boolean;
-  tag: string;
-  seed: number;
-  signer: string;
-  identities: string[];
-}
-
-export enum ETokenType {
-  Erc20 = 'ERC20',
-  Native = 'NATIVE_TOKEN',
-  NFT = 'ERC721'
-}
-
-export type IAirdropClaim = {
-  index: number;
-  recipient: string;
-  proof: string[];
-  amount: string;
-  unlockingAt: number;
-  group: string;
-  data: string;
-  leaf: string;
-  claimed?: boolean;
-
-  claimId?: string;
-
-  // ton
-  claimable?: boolean;
-  proofHash: string;
-  ownerAddress: string;
-  proofBoc: string;
-  expiryTimestamp: number;
-  expired?: boolean;
-  project: IProject;
-};
-
-export type IAirdropSignatureClaim = {
-  percent: number;
-  unlockingAt: number;
-  claimDeadline: number;
-  value: string;
-  recipient: string;
-  recipientType: string;
-  claimId: string;
-  data?: string;
-  signature?: string;
-  claimed?: boolean;
-  note: string;
-};
-
-export interface IAirdropSignatureIdentity {
-  type: AirdropSigIdentityTypeEnum;
-  value: string;
-  displayName: string;
-}
-
-export interface IAirdropData {
-  claims: IAirdropClaim[];
-}
-
-export interface IAirdropSignatureData {
-  claims: IAirdropSignatureClaim[];
-  identities: IAirdropSignatureIdentity[];
-}
-
-export interface IClaimSignature {
-  claimId: string;
-  data: string;
-  signature: string;
-  hash: string;
-}
-
-export enum TonAirdropVersionEnum {
-  V1 = '1.0.0',
-  V2 = '2.0.0',
-  LiteV1 = '11.0.0',
-  NativeV1 = '21.0.0'
-}
-
-export enum EvmAirdropVersionEnum {
-  V0 = '0.0.2', // 兼容btc减半 airdrop
-  V3 = '0.3.0', // zeta 收费
-  V4 = '0.4.0' // zeta kyc、kyc threshold
-}
-
-export type IWalletClient = TonWalletClient | ViemWalletClient | SolanaWalletState;
-
-export type { TonWalletClient, ViemWalletClient, SolanaWalletState };
-export type IAirdropService = TonAirdropService | EvmAirdropService;
-
-type BaseAirdropOptions = {
-  endpoint?: string;
-  project?: IProject;
-};
-
-type ProjectIdOptions = BaseAirdropOptions & {
-  projectId: string;
-  slug?: never;
-};
-
-type SlugOptions = BaseAirdropOptions & {
-  slug: string;
-  projectId?: never;
-};
-
-export type IAirdropOptions = ProjectIdOptions | SlugOptions;
-
-export interface IContractConfig {
-  version?: string | null;
-  paused: boolean | null;
-  claimFee?: string | null;
-}
-
-export enum ErrorCode {
-  // 'Wallet already connected'
-  WALLET_ALREADY_CONNECTED = 'Wallet already connected'
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export { AirdropClient, SignatureAirdropClient, CONST } from './airdrop';
-export { WalletFactory, EvmProvider, SolanaProvider, TonProvider } from './wallets';
-export * from './airdrop/types';

package/src/utils/api-client.ts

@@ -1,69 +0,0 @@
-export type ApiClientOptions = {
-  baseURL?: string;
-};
-
-export type ApiRequestOptions = {
-  params?: Record<string, string | number>;
-  skipHandleError?: boolean;
-  headers?: Record<string, string>;
-};
-
-type ApiResponse = {
-  message: string;
-  statusCode: number;
-  data: unknown;
-  success: boolean;
-};
-
-export class ApiClient {
-  constructor(private options?: ApiClientOptions) {}
-
-  extend(options: ApiClientOptions): ApiClient {
-    return new ApiClient({
-      ...this.options,
-      ...options
-    });
-  }
-
-  async get<TRes>(url: string, options?: ApiRequestOptions): Promise<TRes> {
-    return this.request('GET', url, null, options) as TRes;
-  }
-
-  async post<TRes, TReq = unknown>(url: string, data?: TReq, options?: ApiRequestOptions): Promise<TRes> {
-    return this.request('POST', url, data, options) as TRes;
-  }
-
-  async put<TRes, TReq = unknown>(url: string, data?: TReq, options?: ApiRequestOptions): Promise<TRes> {
-    return this.request('PUT', url, data, options) as TRes;
-  }
-
-  async delete<TRes>(url: string, options?: ApiRequestOptions): Promise<TRes> {
-    return this.request('DELETE', url, null, options) as TRes;
-  }
-
-  private async request(
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE',
-    url: string,
-    data: unknown,
-    options?: ApiRequestOptions
-  ): Promise<unknown> {
-    const finalUrl = (this.options?.baseURL || '') + url;
-
-    const init: RequestInit = { method, headers: options?.headers || {} };
-    if (data instanceof FormData) {
-      init.body = data;
-    } else {
-      init.headers = { 'content-type': 'application/json', ...init.headers };
-      init.body = data ? JSON.stringify(data) : void 0;
-    }
-
-    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) {
-      return Promise.reject(resData);
-    }
-    return resData.data;
-  }
-}
-
-export const apiClient = new ApiClient({ baseURL: 'https://claim.tokentable.xyz/api' });

package/src/utils/index.ts

@@ -1,3 +0,0 @@
-export * from './web3';
-export * from './utils';
-export * from './api-client';

package/src/utils/utils.ts

@@ -1,45 +0,0 @@
-import dayjs from 'dayjs';
-
-export const safeParseJSON = (str: string): any => {
-  try {
-    return JSON.parse(str);
-  } catch (error) {
-    return {};
-  }
-};
-
-export const isBeforeByUnix = (unix: number) => {
-  return dayjs(new Date()).isBefore(dayjs.unix(unix), 'millisecond');
-};
-
-export const delay = (ms: number): Promise<unknown> => new Promise((res) => setTimeout(res, ms));
-
-export async function retry<T>(fn: () => Promise<T>, options: { retries: number; delay: number }): Promise<T> {
-  let lastError: Error | undefined;
-  for (let i = 0; i < options.retries; i++) {
-    try {
-      return await fn();
-    } catch (e) {
-      if (e instanceof Error) {
-        lastError = e;
-      }
-      await new Promise((resolve) => setTimeout(resolve, options.delay));
-    }
-  }
-  throw lastError;
-}
-
-export const isMobile = () => {
-  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
-};
-
-export const cleanUrlParams = (paramsToRemove: string[]) => {
-  if (typeof window !== 'undefined') {
-    const url = new URL(window.location.href);
-    paramsToRemove.forEach((param) => {
-      url.searchParams.delete(param);
-    });
-
-    window.history.replaceState({}, document.title, url.toString());
-  }
-};