@sign-global/tokentable 0.0.5 → 0.0.6

package/dist/esm/airdrop/strategies/EvmAirdropStrategy.d.ts

@@ -0,0 +1,26 @@
+import { IWalletClient } from '../types';
+import { IAirdropStrategy } from './IAirdropStrategy';
+export declare class EvmAirdropStrategy implements IAirdropStrategy {
+    private service;
+    private readonly contractAddress;
+    private readonly chainId;
+    private walletClient?;
+    private cachedVersion;
+    constructor(params: {
+        contractAddress: string;
+        chainId: string | number;
+        walletClient?: IWalletClient;
+    });
+    initialize(walletClient?: IWalletClient): Promise<void>;
+    isInitialized(): boolean;
+    getVersion(): Promise<string>;
+    claim(claimData: any): Promise<any>;
+    checkClaimed(claimData: any): Promise<boolean>;
+    batchCheckClaimed(leafs: string[]): Promise<{
+        result: boolean;
+        status: string;
+    }[]>;
+    getNFT(): Promise<string>;
+    getKycThreshold(): Promise<bigint>;
+    getClaimFee(contractAddress: string, amount: bigint): Promise<bigint>;
+}

package/dist/esm/airdrop/strategies/EvmAirdropStrategy.js

@@ -0,0 +1,75 @@
+import { AirdropService as EvmAirdropService } from '../core/evm/AirdropService';
+export class EvmAirdropStrategy {
+    service;
+    contractAddress;
+    chainId;
+    walletClient;
+    cachedVersion = null;
+    constructor(params) {
+        this.contractAddress = params.contractAddress;
+        this.chainId = Number(params.chainId);
+        if (params.walletClient) {
+            this.walletClient = params.walletClient;
+        }
+    }
+    async initialize(walletClient) {
+        if (walletClient) {
+            this.walletClient = walletClient;
+        }
+        this.service = new EvmAirdropService({
+            contractAddress: this.contractAddress,
+            chainId: this.chainId,
+            walletClient: this.walletClient
+        });
+    }
+    isInitialized() {
+        return !!this.service;
+    }
+    async getVersion() {
+        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) {
+        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) {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.isLeafUsed(claimData.leaf);
+    }
+    async batchCheckClaimed(leafs) {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.batchFetchClaimed(leafs);
+    }
+    async getNFT() {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.getNFT();
+    }
+    async getKycThreshold() {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.getKycThreshold();
+    }
+    async getClaimFee(contractAddress, amount) {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.getClaimFee(contractAddress, amount);
+    }
+}
+//# sourceMappingURL=EvmAirdropStrategy.js.map

package/dist/esm/airdrop/strategies/EvmAirdropStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvmAirdropStrategy.js","sourceRoot":"","sources":["../../../../src/airdrop/strategies/EvmAirdropStrategy.ts"],"names":[],"mappings":"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"}

package/dist/esm/airdrop/strategies/IAirdropStrategy.d.ts

@@ -0,0 +1,27 @@
+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>;
+    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/dist/esm/airdrop/strategies/IAirdropStrategy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IAirdropStrategy.js.map

package/dist/esm/airdrop/strategies/IAirdropStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAirdropStrategy.js","sourceRoot":"","sources":["../../../../src/airdrop/strategies/IAirdropStrategy.ts"],"names":[],"mappings":""}

package/dist/esm/airdrop/strategies/StrategyCache.d.ts

@@ -0,0 +1,10 @@
+import { IAirdropStrategy } from './IAirdropStrategy';
+export declare class StrategyCache {
+    private readOnlyStrategies;
+    private walletStrategies;
+    private getCacheKey;
+    getStrategy(contractAddress: string, chainId: string | number, chainType: string, hasWallet?: boolean): IAirdropStrategy | undefined;
+    setStrategy(contractAddress: string, chainId: string | number, chainType: string, strategy: IAirdropStrategy, hasWallet?: boolean): void;
+    clearStrategy(contractAddress: string, chainId: string | number, chainType: string, hasWallet?: boolean): void;
+}
+export declare const strategyCache: StrategyCache;

package/dist/esm/airdrop/strategies/StrategyCache.js

@@ -0,0 +1,28 @@
+export class StrategyCache {
+    readOnlyStrategies = new Map();
+    walletStrategies = new Map();
+    getCacheKey(contractAddress, chainId, chainType) {
+        return `${chainType}:${contractAddress}:${chainId}`;
+    }
+    getStrategy(contractAddress, chainId, chainType, hasWallet = false) {
+        const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
+        const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
+        return cache.get(cacheKey);
+    }
+    setStrategy(contractAddress, chainId, chainType, strategy, hasWallet = false) {
+        const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
+        const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
+        cache.set(cacheKey, strategy);
+    }
+    clearStrategy(contractAddress, chainId, chainType, hasWallet) {
+        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();
+//# sourceMappingURL=StrategyCache.js.map

package/dist/esm/airdrop/strategies/StrategyCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrategyCache.js","sourceRoot":"","sources":["../../../../src/airdrop/strategies/StrategyCache.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,aAAa;IAChB,kBAAkB,GAAkC,IAAI,GAAG,EAAE,CAAC;IAC9D,gBAAgB,GAAkC,IAAI,GAAG,EAAE,CAAC;IAE5D,WAAW,CAAC,eAAuB,EAAE,OAAwB,EAAE,SAAiB;QACtF,OAAO,GAAG,SAAS,IAAI,eAAe,IAAI,OAAO,EAAE,CAAC;IACtD,CAAC;IAED,WAAW,CAAC,eAAuB,EAAE,OAAwB,EAAE,SAAiB,EAAE,YAAqB,KAAK;QAC1G,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC;QAC1E,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QACvE,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC7B,CAAC;IAED,WAAW,CAAC,eAAuB,EAAE,OAAwB,EAAE,SAAiB,EAAE,QAA0B,EAAE,YAAqB,KAAK;QACtI,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC;QAC1E,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QACvE,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAChC,CAAC;IAED,aAAa,CAAC,eAAuB,EAAE,OAAwB,EAAE,SAAiB,EAAE,SAAmB;QACrG,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QACvE,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,EAAE,CAAC;YACzC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,SAAS,EAAE,CAAC;YAC1C,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;CACF;AAED,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC"}

package/dist/esm/airdrop/strategies/TonAirdropStrategy.d.ts

@@ -0,0 +1,26 @@
+import { TonClient } from '@ton/ton';
+import { IWalletClient } from '../types';
+import { IAirdropStrategy } from './IAirdropStrategy';
+export declare class TonAirdropStrategy implements IAirdropStrategy {
+    private service;
+    private readonly contractAddress;
+    private readonly chainId;
+    private readonly tonClient?;
+    private walletClient?;
+    private cachedVersion;
+    constructor(params: {
+        contractAddress: string;
+        chainId: string | number;
+        walletClient?: IWalletClient;
+        tonClient?: TonClient;
+    });
+    initialize(walletClient?: IWalletClient): Promise<void>;
+    isInitialized(): boolean;
+    getVersion(): Promise<string>;
+    claim(claimData: any, options?: {
+        onLoading?: () => void;
+    }): Promise<any>;
+    checkClaimed(claimData: any): Promise<boolean>;
+    getPaused(): Promise<boolean>;
+    getClaimFee(contractAddress: string, amount: bigint): Promise<string>;
+}

package/dist/esm/airdrop/strategies/TonAirdropStrategy.js

@@ -0,0 +1,60 @@
+import { AirdropService as TonAirdropService } from '../core/ton/AirdropService';
+export class TonAirdropStrategy {
+    service;
+    contractAddress;
+    chainId;
+    tonClient;
+    walletClient;
+    cachedVersion = null;
+    constructor(params) {
+        this.contractAddress = params.contractAddress;
+        this.chainId = params.chainId.toString();
+        this.tonClient = params.tonClient;
+        if (params.walletClient) {
+            this.walletClient = params.walletClient;
+        }
+    }
+    async initialize(walletClient) {
+        if (walletClient) {
+            this.walletClient = walletClient;
+        }
+        this.service = new TonAirdropService({
+            address: this.contractAddress,
+            chainId: this.chainId,
+            walletClient: this.walletClient,
+            tonClient: this.tonClient
+        });
+    }
+    isInitialized() {
+        return !!this.service;
+    }
+    async getVersion() {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        if (!this.cachedVersion) {
+            this.cachedVersion = await this.service.getVersion();
+        }
+        return this.cachedVersion;
+    }
+    async claim(claimData, options) {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.claim(claimData, options);
+    }
+    async checkClaimed(claimData) {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.checkClaimed(claimData);
+    }
+    async getPaused() {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.getPaused();
+    }
+    async getClaimFee(contractAddress, amount) {
+        if (!this.service)
+            throw new Error('Strategy not initialized');
+        return this.service.getClaimFee(contractAddress, amount);
+    }
+}
+//# sourceMappingURL=TonAirdropStrategy.js.map

package/dist/esm/airdrop/strategies/TonAirdropStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TonAirdropStrategy.js","sourceRoot":"","sources":["../../../../src/airdrop/strategies/TonAirdropStrategy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,IAAI,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAIjF,MAAM,OAAO,kBAAkB;IACrB,OAAO,CAAgC;IAC9B,eAAe,CAAS;IACxB,OAAO,CAAS;IAChB,SAAS,CAAa;IAC/B,YAAY,CAAgB;IAC5B,aAAa,GAAkB,IAAI,CAAC;IAE5C,YAAY,MAKX;QACC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC9C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;QACzC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YACxB,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAA4B,CAAC;QAC1D,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,YAA4B;QAC3C,IAAI,YAAY,EAAE,CAAC;YACjB,IAAI,CAAC,YAAY,GAAG,YAA4B,CAAC;QACnD,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAiB,CAAC;YACnC,OAAO,EAAE,IAAI,CAAC,eAAe;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC,CAAC;IACL,CAAC;IAED,aAAa;QACX,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC/D,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;QACvD,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,SAAc,EAAE,OAAoC;QAC9D,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,SAAc;QAC/B,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED,KAAK,CAAC,SAAS;QACb,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;IAClC,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,eAAuB,EAAE,MAAc;QACvD,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;IAC3D,CAAC;CACF"}

package/dist/esm/airdrop/types/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sign-global/tokentable",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "publishConfig": {
     "access": "public"
   },

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