@sign-global/tokentable 0.0.4 → 0.0.6

package/src/airdrop/index.ts

@@ -1,20 +1,17 @@
 import { TonClient } from '@ton/ton';
-import { TonConnectUI } from '@tonconnect/ui-react';
-import { AirdropService as TonAirdropService } from './core/ton/AirdropService';
-import { AirdropService as EvmAirdropService } from './core/evm/AirdropService';
-import { getAirdropPro, getAirdropProject, getAirdropQuery } from './services';
+import { getAirdropPro, getAirdropProject, getAirdropQuery, getAirdropContractConfig } from './services';
 import {
-  ChainId,
   ChainType,
-  ETokenType,
-  EvmAirdropVersionEnum,
   IAirdropClaim,
   IAirdropOptions,
+  IContractConfig,
   IProject,
   IWalletClient
 } from './types';
 import { getTonProjectIdByAddress } from './common';
-import { WalletClient as ViemWalletClient } from 'viem';
+import { AirdropStrategyFactory } from './strategies/AirdropStrategyFactory';
+import { IAirdropStrategy } from './strategies/IAirdropStrategy';
+import { strategyCache } from './strategies/StrategyCache';
 
 export class AirdropClient {
   private tonClient?: TonClient;
@@ -23,11 +20,9 @@ export class AirdropClient {
   private endpoint?: string;
   private project: IProject | undefined;
   protected claims?: IAirdropClaim[];
-  private contractInstanceWithWallet: TonAirdropService | EvmAirdropService | undefined;
-  private contractInstanceWithoutWallet: TonAirdropService | EvmAirdropService | undefined;
   private projectPromise: Promise<void> | undefined;
   private claimHook: ((v: any) => any) | undefined;
-  private cachedVersion: string | null = null;
+  private contractConfig: IContractConfig | null = null;
 
   constructor(params: IAirdropOptions) {
     if ('slug' in params) {
@@ -39,21 +34,41 @@ export class AirdropClient {
     this.projectPromise = this.initializeProjects();
   }
 
-  protected async initializeProjects(address?: string) {
-    let projectId: string | undefined = this.projectId;
-    if (this.slug) {
-      const res = await getAirdropPro(this.slug, this.endpoint);
-      const projectMap = res?.childProjectMapping || {};
+  private async fetchProjectFromSlug(address?: string): Promise<string | undefined> {
+    if (!this.slug) return undefined;
+    
+    const res = await getAirdropPro(this.slug, this.endpoint);
+    const projectMap = res?.childProjectMapping || {};
+    
+    return getTonProjectIdByAddress({ 
+      address, 
+      slug: this.slug, 
+      data: projectMap 
+    });
+  }
 
-      let legacyProjectId: string | undefined;
-      legacyProjectId = getTonProjectIdByAddress({ address, slug: this.slug, data: projectMap });
+  private async fetchProjectDetails(projectId: string): Promise<void> {
+    this.project = await getAirdropProject(projectId, this.endpoint);
+  }
 
-      if (legacyProjectId) {
-        projectId = legacyProjectId;
+  protected async initializeProjects(address?: string) {
+    try {
+      let projectId = this.projectId;
+      
+      // If slug is provided, try to fetch project ID from slug
+      if (!projectId) {
+        projectId = await this.fetchProjectFromSlug(address);
       }
+
+      if (!projectId) {
+        throw new Error('Project ID is required and could not be determined');
+      }
+
+      // Fetch project details
+      await this.fetchProjectDetails(projectId);
+    } catch (error: any) {
+      throw new Error(`Failed to initialize project: ${error.message}`);
     }
-    if (!projectId) throw new Error('Project ID is required');
-    this.project = await getAirdropProject(projectId, this.endpoint);
   }
 
   async getProjectInfo() {
@@ -82,46 +97,45 @@ export class AirdropClient {
     return this.claims;
   }
 
-  async getAirdropContractWrapper(options?: {
-    walletClient?: IWalletClient;
-  }): Promise<TonAirdropService | EvmAirdropService> {
+  public async getStrategy(walletClient?: IWalletClient): Promise<IAirdropStrategy> {
     const project = await this.getProjectInfo();
+    const hasWallet = !!walletClient;
+
+    // Try to get cached strategy
+    let strategy = strategyCache.getStrategy(
+      project.contractAddress,
+      project.chainId,
+      project.chainType,
+      hasWallet
+    );
 
-    if (options?.walletClient) {
-      if (!this.contractInstanceWithWallet) {
-        const instance =
-          project.chainType === ChainType.Evm
-            ? new EvmAirdropService({
-                contractAddress: project.contractAddress,
-                chainId: Number(project.chainId) as ChainId,
-                walletClient: options.walletClient as ViemWalletClient
-              })
-            : new TonAirdropService({
-                chainId: project.chainId.toString(),
-                address: project.contractAddress,
-                walletClient: options.walletClient as TonConnectUI,
-                tonClient: this.tonClient
-              });
-        this.contractInstanceWithWallet = instance;
-      }
-      return this.contractInstanceWithWallet;
-    } else {
-      if (!this.contractInstanceWithoutWallet) {
-        const instance =
-          project.chainType === ChainType.Evm
-            ? new EvmAirdropService({
-                contractAddress: project.contractAddress,
-                chainId: Number(project.chainId) as ChainId
-              })
-            : new TonAirdropService({
-                chainId: project.chainId.toString(),
-                address: project.contractAddress,
-                tonClient: this.tonClient
-              });
-        this.contractInstanceWithoutWallet = instance;
-      }
-      return this.contractInstanceWithoutWallet;
+    if (!strategy) {
+      // Create new strategy if not cached
+      strategy = AirdropStrategyFactory.createStrategy({
+        chainType: project.chainType,
+        contractAddress: project.contractAddress,
+        chainId: project.chainId,
+        walletClient,
+        tonClient: this.tonClient
+      });
+
+      // Initialize the strategy
+      await strategy.initialize(walletClient);
+
+      // Cache the initialized strategy
+      strategyCache.setStrategy(
+        project.contractAddress,
+        project.chainId,
+        project.chainType,
+        strategy,
+        hasWallet
+      );
+    } else if (hasWallet) {
+      // If we have a wallet and the strategy exists, just initialize with the new wallet
+      await strategy.initialize(walletClient);
     }
+
+    return strategy;
   }
 
   private getClaimDataById(claimId: string) {
@@ -139,115 +153,102 @@ export class AirdropClient {
     options?: { onLoading?: () => void }
   ) {
     const claimData = this.getClaimDataById(claimId);
-    const project = await this.getProjectInfo();
-
-    const contractWrapper = await this.getAirdropContractWrapper({
-      walletClient
-    });
-
-    if (project.chainType === ChainType.Evm) {
-      const version = await contractWrapper.getVersion();
-      const needsFeeData = !(
-        project.tokenType === ETokenType.Native &&
-        [EvmAirdropVersionEnum.V3, EvmAirdropVersionEnum.V4].includes(version as EvmAirdropVersionEnum)
-      );
-
-      const value = needsFeeData ? await this.getClaimFee(BigInt(claimData.amount)) : undefined;
-
-      let extraData = {
-        isLegacy: true,
-        attestationId: BigInt(1)
-      };
-      if (this.claimHook) {
-        extraData = this.claimHook(claimData);
-      }
+    const strategy = await this.getStrategy(walletClient);
 
-      return (contractWrapper as EvmAirdropService).claim({
-        proof: claimData.proof,
-        group: claimData.group,
-        data: claimData.data,
-        value: value as bigint | undefined,
-        extraData: extraData
-      });
+    let extraData = {
+      isLegacy: true,
+      attestationId: BigInt(0)
+    }
+    if (this.claimHook) {
+      extraData = this.claimHook(claimData);
     }
 
-    return (contractWrapper as TonAirdropService).claim(claimData, options);
+    return strategy.claim(claimData, options);
   }
 
   async checkClaimed(claimId: string): Promise<boolean> {
     const claimData = this.getClaimDataById(claimId);
-    const project = await this.getProjectInfo();
+    const strategy = await this.getStrategy();
+    return strategy.checkClaimed(claimData);
+  }
 
-    const contractWrapper = await this.getAirdropContractWrapper();
+  private async getContractConfig(): Promise<IContractConfig | null> {
+    try {
+      const project = await this.getProjectInfo();
 
-    if (project.chainType === ChainType.Evm) {
-      return (contractWrapper as EvmAirdropService).isLeafUsed(claimData.leaf);
+      if (!this.contractConfig) {
+        this.contractConfig = await getAirdropContractConfig({
+          chainId: project.chainId,
+          chainType: project.chainType,
+          contractAddress: project.contractAddress
+        }, this.endpoint);
+      }
+      return this.contractConfig;
+    } catch (error) {
+      console.error('Error fetching contract config:', error);
+      return null;
     }
-
-    return (contractWrapper as TonAirdropService).checkClaimed(claimData);
   }
 
-  async getPaused() {
-    const project = await this.getProjectInfo();
-    const contractWrapper = await this.getAirdropContractWrapper();
-    if (project.chainType === ChainType.Evm) {
-      throw new Error('EVM chain is not supported');
+  async getVersion(): Promise<string> {
+    const config = await this.getContractConfig();
+    if (config?.version) {
+      return config.version;
     }
-    return (contractWrapper as TonAirdropService).getPaused();
+    
+    const strategy = await this.getStrategy();
+    return strategy.getVersion();
   }
 
-  async getVersion() {
-    if (this.cachedVersion) {
-      return this.cachedVersion;
+  async getPaused(): Promise<boolean> {
+    const config = await this.getContractConfig();
+    if (config && config?.paused !== null) {
+      return config.paused;
     }
-    const contractWrapper = await this.getAirdropContractWrapper();
 
-    this.cachedVersion = await contractWrapper?.getVersion();
-    return this.cachedVersion;
+    const strategy = await this.getStrategy();
+    if (!strategy.getPaused) {
+      throw new Error('getPaused is not supported for this chain');
+    }
+    return strategy.getPaused();
   }
 
-  async batchCheckClaimed() {
-    const project = await this.getProjectInfo();
+  async getClaimFee(amount?: bigint): Promise<string | bigint> {
+    const config = await this.getContractConfig();
+    if (config?.claimFee) {
+      return config.claimFee;
+    }
 
-    if (project.chainType === ChainType.Ton) {
-      throw new Error('TON chain is not supported');
+    const strategy = await this.getStrategy();
+    if (!strategy.getClaimFee) {
+      throw new Error('getClaimFee is not supported for this chain');
     }
+    return strategy.getClaimFee(this.project?.contractAddress || '', amount || BigInt(0));
+  }
 
-    const contractWrapper = await this.getAirdropContractWrapper();
+  async batchCheckClaimed(): Promise<{ result: boolean; status: string }[]> {
+    const strategy = await this.getStrategy();
+    if (!strategy.batchCheckClaimed) {
+      throw new Error('batchCheckClaimed is not supported for this chain');
+    }
     const leafs = this.claims?.map((it) => it.leaf);
-
     if (!leafs) return [];
-
-    return (contractWrapper as EvmAirdropService).batchFetchClaimed(leafs);
+    return strategy.batchCheckClaimed(leafs);
   }
 
-  async getNFT() {
-    const project = await this.getProjectInfo();
-
-    if (project.chainType === ChainType.Ton) {
-      throw new Error('TON chain is not supported');
+  async getNFT(): Promise<string> {
+    const strategy = await this.getStrategy();
+    if (!strategy.getNFT) {
+      throw new Error('getNFT is not supported for this chain');
     }
-
-    const contractWrapper = await this.getAirdropContractWrapper();
-
-    return (contractWrapper as EvmAirdropService).getNFT();
+    return strategy.getNFT();
   }
 
-  async getKycThreshold() {
-    const project = await this.getProjectInfo();
-
-    if (project.chainType === ChainType.Ton) {
-      throw new Error('TON chain is not supported');
+  async getKycThreshold(): Promise<bigint> {
+    const strategy = await this.getStrategy();
+    if (!strategy.getKycThreshold) {
+      throw new Error('getKycThreshold is not supported for this chain');
     }
-    const contractWrapper = await this.getAirdropContractWrapper();
-    return (contractWrapper as EvmAirdropService).getKycThreshold();
-  }
-
-  async getClaimFee(amount?: bigint) {
-    const project = await this.getProjectInfo();
-
-    const contractWrapper = await this.getAirdropContractWrapper({});
-
-    return contractWrapper.getClaimFee(project.contractAddress, amount || BigInt(1));
+    return strategy.getKycThreshold();
   }
 }

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