@sign-global/tokentable 0.0.5 → 0.0.7

package/src/airdrop/services/index.ts

@@ -1,6 +1,6 @@
 import { apiClient } from '../../utils/api-client';
 import { safeParseJSON } from '../../utils/utils';
-import { IAirdropData, IProject } from '../types';
+import { IAirdropData, IContractConfig, IProject } from '../types';
 
 export { TonWalletService } from './wallet-service/ton';
 
@@ -54,6 +54,11 @@ export const getAirdropQuery = async (
   return client.post(`/airdrop-open/query`, data);
 };
 
+export const getAirdropContractConfig = async (data: { chainId: string; chainType: string; contractAddress: string }, baseURL?: string): Promise<IContractConfig> => {
+  const client = createApiClient(baseURL);
+  return client.post(`/airdrop-open/contract/config`, data);
+};
+
 export const getJettonInfo = async (
   data: { address: string; isTestnet: 'true' | 'false' },
   baseURL?: string

package/src/airdrop/strategies/AirdropStrategyFactory.ts

@@ -0,0 +1,29 @@
+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> = {
+    [ChainType.Evm]: EvmAirdropStrategy,
+    [ChainType.Ton]: TonAirdropStrategy
+  };
+
+  static createStrategy(params: {
+    chainType: ChainType;
+    contractAddress: string;
+    chainId: string | number;
+    walletClient?: IWalletClient;
+    tonClient?: TonClient;
+  }): 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

@@ -0,0 +1,85 @@
+import { AirdropService as EvmAirdropService } from '../core/evm/AirdropService';
+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

@@ -0,0 +1,25 @@
+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;
+  }): IAirdropStrategy;
+}

package/src/airdrop/strategies/StrategyCache.ts

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,72 @@
+import { TonClient } from '@ton/ton';
+import { TonConnectUI } from '@tonconnect/ui-react';
+import { AirdropService as TonAirdropService } from '../core/ton/AirdropService';
+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;
+  }) {
+    this.contractAddress = params.contractAddress;
+    this.chainId = params.chainId.toString();
+    this.tonClient = params.tonClient;
+    if (params.walletClient) {
+      this.walletClient = params.walletClient as TonConnectUI;
+    }
+  }
+
+  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
+    });
+  }
+
+  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

@@ -48,7 +48,18 @@ describe('AirdropClient', () => {
       expect(version).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
@@ -58,6 +69,15 @@ describe('AirdropClient', () => {
       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();
+    });
+
     //AD_S4dSTEXQN96i
 
     it('should work on native v1', async () => {
@@ -87,6 +107,71 @@ describe('AirdropClient', () => {
     });
   });
 
+  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('catch error', () => {
   //     it('throw error when projectId is not provided', async () => {
   //       client = new AirdropClient({

package/src/airdrop/types/index.ts

@@ -133,3 +133,9 @@ type SlugOptions = BaseAirdropOptions & {
 };
 
 export type IAirdropOptions = ProjectIdOptions | SlugOptions;
+
+export interface IContractConfig {
+  version?: string | null;
+  paused: boolean | null;
+  claimFee?: string | null;
+}