@sign-global/tokentable 0.4.3-beta.0 → 0.4.3-beta.2

package/src/airdrop/strategies/AirdropStrategyFactory.ts

@@ -1,31 +0,0 @@
-import { ChainType, IWalletClient } from '../types';
-import { EvmAirdropStrategy } from './EvmAirdropStrategy';
-import { IAirdropStrategy, IAirdropStrategyConstructor } from './IAirdropStrategy';
-import { TonAirdropStrategy } from './TonAirdropStrategy';
-import { TonClient } from '@ton/ton';
-
-export class AirdropStrategyFactory {
-  private static strategyMap: Record<ChainType, IAirdropStrategyConstructor | null> = {
-    [ChainType.Evm]: EvmAirdropStrategy,
-    [ChainType.Ton]: TonAirdropStrategy,
-    [ChainType.Solana]: null
-  };
-
-  static createStrategy(params: {
-    chainType: ChainType;
-    contractAddress: string;
-    chainId: string | number;
-    walletClient?: IWalletClient;
-    tonClient?: TonClient;
-    version?: string;
-  }): IAirdropStrategy {
-    const { chainType, ...strategyParams } = params;
-    const StrategyClass = this.strategyMap[chainType];
-
-    if (!StrategyClass) {
-      throw new Error(`Unsupported chain type: ${chainType}`);
-    }
-
-    return new StrategyClass(strategyParams);
-  }
-}

package/src/airdrop/strategies/EvmAirdropStrategy.ts

@@ -1,81 +0,0 @@
-import { EvmAirdropService } from '../contracts';
-import { ChainId, IWalletClient } from '../types';
-import { IAirdropStrategy } from './IAirdropStrategy';
-import { WalletClient as ViemWalletClient } from 'viem';
-
-export class EvmAirdropStrategy implements IAirdropStrategy {
-  private service: EvmAirdropService | undefined;
-  private readonly contractAddress: string;
-  private readonly chainId: ChainId;
-  private walletClient?: ViemWalletClient;
-  private cachedVersion: string | null = null;
-
-  constructor(params: { contractAddress: string; chainId: string | number; walletClient?: IWalletClient }) {
-    this.contractAddress = params.contractAddress;
-    this.chainId = Number(params.chainId) as ChainId;
-    if (params.walletClient) {
-      this.walletClient = params.walletClient as ViemWalletClient;
-    }
-  }
-
-  async initialize(walletClient?: IWalletClient): Promise<void> {
-    if (walletClient) {
-      this.walletClient = walletClient as ViemWalletClient;
-    }
-    this.service = new EvmAirdropService({
-      contractAddress: this.contractAddress,
-      chainId: this.chainId,
-      walletClient: this.walletClient
-    });
-  }
-
-  isInitialized(): boolean {
-    return !!this.service;
-  }
-
-  async getVersion(): Promise<string> {
-    if (this.cachedVersion) {
-      return this.cachedVersion;
-    }
-    if (!this.service) throw new Error('Strategy not initialized');
-    this.cachedVersion = await this.service.getVersion();
-    return this.cachedVersion;
-  }
-
-  async claim(claimData: any): Promise<any> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    const { proof, group, data, value, extraData } = claimData;
-    return this.service.claim({
-      proof,
-      group,
-      data,
-      value,
-      extraData
-    });
-  }
-
-  async checkClaimed(claimData: any): Promise<boolean> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.isLeafUsed(claimData.leaf);
-  }
-
-  async batchCheckClaimed(leafs: string[]): Promise<{ result: boolean; status: string }[]> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.batchFetchClaimed(leafs);
-  }
-
-  async getNFT(): Promise<string> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getNFT() as unknown as string;
-  }
-
-  async getKycThreshold(): Promise<bigint> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getKycThreshold();
-  }
-
-  async getClaimFee(contractAddress: string, amount: bigint): Promise<bigint> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getClaimFee(contractAddress, amount) as unknown as bigint;
-  }
-}

package/src/airdrop/strategies/IAirdropStrategy.ts

@@ -1,26 +0,0 @@
-import { IWalletClient } from '../types';
-import { TonClient } from '@ton/ton';
-
-export interface IAirdropStrategy {
-  getVersion(): Promise<string>;
-  claim(claimData: any, options?: { onLoading?: () => void }): Promise<any>;
-  checkClaimed(claimData: any): Promise<boolean>;
-  isInitialized(): boolean;
-  initialize(walletClient?: IWalletClient): Promise<void>;
-  getPaused?(): Promise<boolean>;
-  // EVM specific methods
-  batchCheckClaimed?(leafs: string[]): Promise<Array<{ result: boolean; status: string }>>;
-  getNFT?(): Promise<string>;
-  getKycThreshold?(): Promise<bigint>;
-  getClaimFee?(contractAddress: string, amount: bigint): Promise<string | bigint>;
-}
-
-export interface IAirdropStrategyConstructor {
-  new (params: {
-    contractAddress: string;
-    chainId: string | number;
-    walletClient?: IWalletClient;
-    tonClient?: TonClient;
-    version?: string;
-  }): IAirdropStrategy;
-}

package/src/airdrop/strategies/StrategyCache.ts

@@ -1,34 +0,0 @@
-import { IAirdropStrategy } from './IAirdropStrategy';
-
-export class StrategyCache {
-  private readOnlyStrategies: Map<string, IAirdropStrategy> = new Map();
-  private walletStrategies: Map<string, IAirdropStrategy> = new Map();
-
-  private getCacheKey(contractAddress: string, chainId: string | number, chainType: string): string {
-    return `${chainType}:${contractAddress}:${chainId}`;
-  }
-
-  getStrategy(contractAddress: string, chainId: string | number, chainType: string, hasWallet: boolean = false): IAirdropStrategy | undefined {
-    const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
-    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
-    return cache.get(cacheKey);
-  }
-
-  setStrategy(contractAddress: string, chainId: string | number, chainType: string, strategy: IAirdropStrategy, hasWallet: boolean = false): void {
-    const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
-    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
-    cache.set(cacheKey, strategy);
-  }
-
-  clearStrategy(contractAddress: string, chainId: string | number, chainType: string, hasWallet?: boolean): void {
-    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
-    if (hasWallet === undefined || hasWallet) {
-      this.walletStrategies.delete(cacheKey);
-    }
-    if (hasWallet === undefined || !hasWallet) {
-      this.readOnlyStrategies.delete(cacheKey);
-    }
-  }
-}
-
-export const strategyCache = new StrategyCache();

package/src/airdrop/strategies/TonAirdropStrategy.ts

@@ -1,77 +0,0 @@
-import { TonClient } from '@ton/ton';
-import { TonConnectUI } from '@tonconnect/ui-react';
-import { TonAirdropService } from '../contracts';
-import { IWalletClient } from '../types';
-import { IAirdropStrategy } from './IAirdropStrategy';
-
-export class TonAirdropStrategy implements IAirdropStrategy {
-  private service: TonAirdropService | undefined;
-  private readonly contractAddress: string;
-  private readonly chainId: string;
-  private readonly tonClient?: TonClient;
-  private walletClient?: TonConnectUI;
-  private cachedVersion: string | null = null;
-
-  constructor(params: {
-    contractAddress: string;
-    chainId: string | number;
-    walletClient?: IWalletClient;
-    tonClient?: TonClient;
-    version?: string;
-  }) {
-    this.contractAddress = params.contractAddress;
-    this.chainId = params.chainId.toString();
-    this.tonClient = params.tonClient;
-    if (params.walletClient) {
-      this.walletClient = params.walletClient as TonConnectUI;
-    }
-    if (params.version) {
-      this.cachedVersion = params.version;
-    }
-  }
-
-  async initialize(walletClient?: IWalletClient): Promise<void> {
-    if (walletClient) {
-      this.walletClient = walletClient as TonConnectUI;
-    }
-    this.service = new TonAirdropService({
-      address: this.contractAddress,
-      chainId: this.chainId,
-      walletClient: this.walletClient,
-      tonClient: this.tonClient,
-      version: this.cachedVersion || undefined
-    });
-  }
-
-  isInitialized(): boolean {
-    return !!this.service;
-  }
-
-  async getVersion(): Promise<string> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    if (!this.cachedVersion) {
-      this.cachedVersion = await this.service.getVersion();
-    }
-    return this.cachedVersion;
-  }
-
-  async claim(claimData: any, options?: { onLoading?: () => void }): Promise<any> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.claim(claimData, options);
-  }
-
-  async checkClaimed(claimData: any): Promise<boolean> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.checkClaimed(claimData);
-  }
-
-  async getPaused(): Promise<boolean> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getPaused();
-  }
-
-  async getClaimFee(contractAddress: string, amount: bigint): Promise<string> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getClaimFee(contractAddress, amount);
-  }
-}

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();
-    });
-  });
-});