@sign-global/tokentable 0.2.1 → 0.4.0-beta.1

package/src/airdrop/index.ts

@@ -1,310 +1,5 @@
-import { TonClient } from '@ton/ton';
-import { getAirdropPro, getAirdropProject, getAirdropQuery, getAirdropContractConfig, getAirdropProjectId } from './services';
-import {
-  ChainType,
-  ETokenType,
-  EvmAirdropVersionEnum,
-  IAirdropClaim,
-  IAirdropOptions,
-  IContractConfig,
-  IProject,
-  IWalletClient
-} from './types';
-import { getTonProjectIdByAddress } from './common';
-import { AirdropStrategyFactory } from './strategies/AirdropStrategyFactory';
-import { IAirdropStrategy } from './strategies/IAirdropStrategy';
-import { strategyCache } from './strategies/StrategyCache';
+export { AirdropClient } from './AirdropClient';
+export { SignatureAirdropClient } from './SignatureAirdropClient';
 
-export class AirdropClient {
-  private tonClient?: TonClient;
-  private slug?: string;
-  private projectId?: string;
-  private endpoint?: string;
-  private project: IProject | undefined;
-  protected claims?: IAirdropClaim[];
-  private projectPromise: Promise<void> | undefined;
-  private claimHook: ((v: any) => any) | undefined;
-  private contractConfig: IContractConfig | null = null;
-
-  constructor(params: IAirdropOptions) {
-    if ('slug' in params) {
-      this.slug = params.slug;
-    }
-    this.projectId = params.projectId;
-    this.endpoint = params.endpoint;
-    this.projectPromise = this.initializeProjects();
-  }
-
-  setTonClient(tonClient: TonClient) {
-    this.tonClient = tonClient;
-  }
-
-  private getTonClient(): TonClient | undefined {
-    if (!this.tonClient) {
-      return undefined;
-    }
-    return this.tonClient;
-  }
-
-
-  // move
-  private async fetchProjectFromSlug(address: string): Promise<string | undefined> {
-    if (!this.slug) return undefined;
-    
-    const res = await getAirdropProjectId({ recipient: address, slug: this.slug }, this.endpoint);
-
-    if(!res.projectIds?.length) return undefined;
-    return res?.projectIds?.[0];
-    // const projectMap = res?.childProjectMapping || {};
-    
-    // return getTonProjectIdByAddress({ 
-    //   address, 
-    //   slug: this.slug, 
-    //   data: projectMap 
-    // });
-  }
-
-  private async fetchProjectDetails(projectId: string): Promise<void> {
-    this.project = await getAirdropProject(projectId, this.endpoint);
-  }
-
-  protected async initializeProjects(address?: string) {
-    try {
-      let projectId = this.projectId;
-      
-      // If slug is provided, try to fetch project ID from slug
-      if (!projectId && address) {
-        projectId = await this.fetchProjectFromSlug(address);
-      }
-
-      if (!projectId) {
-        return;
-      }
-
-      // Fetch project details
-      await this.fetchProjectDetails(projectId);
-    } catch (error: any) {
-      throw new Error(`Failed to initialize project: ${error.message}`);
-    }
-  }
-
-  async getProjectInfo() {
-    await this.projectPromise;
-    if (!this.project) throw new Error('Project not found');
-    return this.project;
-  }
-
-  async getAirdropClaims(data: { address: string }) {
-    if (this.slug) {
-      await this.initializeProjects(data.address); // 根据地址
-    }
-    const project = await this.getProjectInfo();
-
-    const res = await getAirdropQuery(
-      {
-        recipient: data.address,
-        projectId: project!.id,
-        recipientType: project!.recipientType
-      },
-      this.endpoint
-    );
-    const claimsRes = res.claims?.map((it) => ({
-      ...it,
-      project: project!,
-      claimId: project!.chainType === ChainType.Evm ? `${project!.id}:${it.leaf}` : `${project!.id}:${it.index}`
-    }));
-    this.claims = claimsRes;
-    return this.claims;
-  }
-
-  public async getStrategy(walletClient?: IWalletClient): Promise<IAirdropStrategy> {
-    const project = await this.getProjectInfo();
-    const version = this.contractConfig?.version || undefined;
-
-    const hasWallet = !!walletClient;
-
-    // Try to get cached strategy
-    let strategy = strategyCache.getStrategy(
-      project.contractAddress,
-      project.chainId,
-      project.chainType,
-      hasWallet
-    );
-
-    if (!strategy) {
-      // Create new strategy if not cached
-      strategy = AirdropStrategyFactory.createStrategy({
-        chainType: project.chainType,
-        contractAddress: project.contractAddress,
-        chainId: project.chainId,
-        walletClient,
-        tonClient: this.getTonClient(),
-        version
-      });
-
-      // 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) {
-    const claimData = this.claims?.find((it) => it.claimId === claimId);
-    if (!claimData) throw new Error('Claim data not found');
-    return claimData;
-  }
-
-  setClaimHook(fn: (v: any) => any) {
-    this.claimHook = fn;
-  }
-
-  private getDefaultExtraData() {
-    return {
-      isLegacy: true,
-      attestationId: BigInt(1)
-    };
-  }
-
-  private async calculateClaimFee(project: IProject, claimAmount: string): Promise<string | bigint | undefined> {
-    if (project.chainType === ChainType.Evm) {
-      const version = await this.getVersion();
-      const isNativeFreeVersion = 
-      project.tokenType === ETokenType.Native &&
-      [EvmAirdropVersionEnum.V3, EvmAirdropVersionEnum.V4].includes(version as EvmAirdropVersionEnum);
-      return isNativeFreeVersion ? undefined : await this.getClaimFee(BigInt(claimAmount));
-    }
-
-    if(project.chainType === ChainType.Ton) {
-      return await this.getClaimFee(BigInt(claimAmount));
-    }
-
-    return undefined;
-  }
-
-  async claimAirdrop(
-    { claimId, walletClient }: { claimId: string; walletClient: IWalletClient },
-    options?: { onLoading?: () => void }
-  ) {
-    // Get claim data and initialize strategy
-    const claimData = this.getClaimDataById(claimId);
-    const strategy = await this.getStrategy(walletClient);
-    const project = await this.getProjectInfo();
-
-    // Process extra data
-    const extraData = project.chainType === ChainType.Ton
-      ? undefined
-      : this.claimHook 
-        ? this.claimHook(claimData)
-        : this.getDefaultExtraData();
-
-    // Calculate claim value based on project type
-    const value = await this.calculateClaimFee(project, claimData.amount);
-
-    // Execute claim with processed data
-    return strategy.claim({
-      ...claimData,
-      extraData,
-      value
-    }, options);
-  }
-
-  async checkClaimed(claimId: string): Promise<boolean> {
-    const claimData = this.getClaimDataById(claimId);
-    const strategy = await this.getStrategy();
-    return strategy.checkClaimed(claimData);
-  }
-
-  private async getContractConfig(): Promise<IContractConfig | null> {
-    try {
-      const project = await this.getProjectInfo();
-
-      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;
-    }
-  }
-
-  async getVersion(): Promise<string> {
-    const config = await this.getContractConfig();
-    if (config?.version) {
-      return config.version;
-    }
-    
-    const strategy = await this.getStrategy();
-    return strategy.getVersion();
-  }
-
-  async getPaused(): Promise<boolean> {
-    const config = await this.getContractConfig();
-    if (config && config?.paused !== null) {
-      return config.paused;
-    }
-
-    const strategy = await this.getStrategy();
-    if (!strategy.getPaused) {
-      throw new Error('getPaused is not supported for this chain');
-    }
-    return strategy.getPaused();
-  }
-
-  async getClaimFee(amount?: bigint): Promise<string | bigint> {
-    const config = await this.getContractConfig();
-    if (config?.claimFee) {
-      return config.claimFee;
-    }
-
-    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));
-  }
-
-  // params claimId[]
-  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 strategy.batchCheckClaimed(leafs);
-  }
-
-  async getNFT(): Promise<string> {
-    const strategy = await this.getStrategy();
-    if (!strategy.getNFT) {
-      throw new Error('getNFT is not supported for this chain');
-    }
-    return strategy.getNFT();
-  }
-
-  async getKycThreshold(): Promise<bigint> {
-    const strategy = await this.getStrategy();
-    if (!strategy.getKycThreshold) {
-      throw new Error('getKycThreshold is not supported for this chain');
-    }
-    return strategy.getKycThreshold();
-  }
-}
+export { CONST } from './constants';
+export * from './core/useWeb3ConnectWallet';

package/src/airdrop/services/index.ts

@@ -54,7 +54,10 @@ 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> => {
+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);
 };
@@ -66,3 +69,28 @@ export const getJettonInfo = async (
   const client = createApiClient(baseURL);
   return client.get(`/airdrop-open/jetton/${data.address}?isTestnet=${data.isTestnet}`);
 };
+
+export const connectTwitter = async (data: { code: string; redirectUri: string }, baseURL?: string) => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/connect-twitter', data);
+};
+
+export const checkEligibility = async (data: { projectId: string }, baseURL?: string) => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/check-eligibility', data);
+};
+
+export const bindWallet = async (
+  data: {
+    projectId: string;
+    key: string;
+    signature: string;
+    message: string;
+    timestamp: number;
+    recipientType: string;
+  },
+  baseURL?: string
+) => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/connect-wallet', data);
+};

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

@@ -22,18 +22,15 @@ describe('AirdropClient', () => {
 
       const projectInfo = await client.getProjectInfo();
       expect(projectInfo).toBeDefined();
-    });
+    }, 6000);
 
     it('should use slug correctly', async () => {
       client = new AirdropClient({
-        slug: 'move',
-      }); 
-      const claims = await client.getAirdropClaims({ address: '0xEa53D21c05ebc87865558a2F8769074DA3bE3821' });
+        slug: 'wat',
+      });
+
       const projectInfo = await client.getProjectInfo();
-      console.log(projectInfo);
-      console.log(claims);
-      expect(projectInfo).toBeDefined();
-      expect(claims.length).toBeTruthy();
+      expect(projectInfo).toBeTruthy();
     });
   });
 

package/src/airdrop/types/index.ts

@@ -61,10 +61,27 @@ export interface IProject {
   blockCountries: Record<string, string>;
   themeConf: ThemeConfig | null;
   version: string;
-  extra?: {
-    kyc: boolean;
-    tag: string;
-  };
+  extra?: IProjectExtra;
+  identities: Identity[];
+}
+
+export interface Identity {
+  identityType: string;
+  authorizeUrl?: string;
+}
+
+export enum AirdropSigIdentityTypeEnum {
+  Twitter = 'X Account',
+  SolanaWallet = 'Solana Wallet',
+  EVMWallet = 'EVM Wallet'
+}
+
+export interface IProjectExtra {
+  kyc: boolean;
+  tag: string;
+  seed: number;
+  signer: string;
+  identities: string[];
 }
 
 export enum ETokenType {
@@ -119,7 +136,6 @@ export type IAirdropService = TonAirdropService | EvmAirdropService;
 
 type BaseAirdropOptions = {
   endpoint?: string;
-  tonClient?: TonClient;
 };
 
 type ProjectIdOptions = BaseAirdropOptions & {
@@ -138,4 +154,4 @@ export interface IContractConfig {
   version?: string | null;
   paused: boolean | null;
   claimFee?: string | null;
-}
+}

package/src/index.ts

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

package/src/utils/utils.ts

@@ -28,3 +28,5 @@ export async function retry<T>(fn: () => Promise<T>, options: { retries: number;
   }
   throw lastError;
 }
+
+export const isLocal = window.location.href.includes('localhost');

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     // Enable latest features
-    "lib": ["ESNext"],
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
     "target": "ESNext",
     "module": "ESNext",
     
@@ -14,7 +14,7 @@
     "moduleResolution": "node",
    "esModuleInterop": true,
     "resolveJsonModule": true,
-
+    "jsx": "react-jsx",
     // Best practices
     "strict": true,
     "skipLibCheck": true,