@sign-global/tokentable 0.3.0 → 0.4.0-beta.2

package/src/airdrop/AirdropClient.ts

@@ -0,0 +1,307 @@
+import { TonClient } from '@ton/ton';
+import { getAirdropPro, getAirdropProject, getAirdropQuery, getAirdropContractConfig } 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 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;
+    if (this.project) {
+      this.project = params.project;
+    } else {
+      this.projectPromise = this.initializeProjects();
+    }
+  }
+
+  setTonClient(tonClient: TonClient) {
+    this.tonClient = tonClient;
+  }
+
+  private getTonClient(): TonClient | undefined {
+    if (!this.tonClient) {
+      return undefined;
+    }
+    return this.tonClient;
+  }
+
+  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
+    });
+  }
+
+  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) {
+        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() {
+    if (this.projectPromise) {
+      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); // Fetch project details by address & slug
+    }
+    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();
+  }
+}

package/src/airdrop/SignatureAirdropClient.ts

@@ -0,0 +1,120 @@
+import { CONST } from './constants';
+import { WalletFactory } from './core/useWeb3ConnectWallet';
+import { ChainType } from './core/useWeb3ConnectWallet/types';
+import { bindWallet, connectTwitter, getAirdropProject } from './services';
+import { AirdropSigIdentityTypeEnum, IAirdropOptions, IProject } from './types';
+
+export class SignatureAirdropClient {
+  private slug?: string;
+  private projectId?: string;
+  private endpoint?: string;
+  private project: IProject | undefined;
+  protected claims?: any[];
+  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;
+    if (this.project) {
+      this.project = params.project;
+    } else {
+      this.projectPromise = this.initializeProjects();
+    }
+  }
+
+  private async fetchProjectDetails(projectId: string): Promise<void> {
+    this.project = await getAirdropProject(projectId, this.endpoint);
+  }
+
+  protected async initializeProjects() {
+    try {
+      let projectId = this.projectId;
+
+      if (!projectId) {
+        return;
+      }
+
+      await this.fetchProjectDetails(projectId);
+    } catch (error: any) {
+      throw new Error(`Failed to initialize project: ${error.message}`);
+    }
+  }
+
+  async getProjectInfo() {
+    if (this.projectPromise) {
+      await this.projectPromise;
+    }
+    if (!this.project) throw new Error('Project not found');
+    return this.project;
+  }
+
+  async connectX({ onSuccess, onError }: { onSuccess: () => void; onError: () => void }) {
+    const project = await this.getProjectInfo();
+    const onWindowMessage = async (message: any) => {
+      if (message.data.name && message.data.name === CONST.TWITTER_AUTH_SUCCESS) {
+        const { isError, code, redirectUri } = message.data.data || {};
+        try {
+          await connectTwitter({ code, redirectUri: redirectUri }, this.endpoint);
+          onSuccess();
+          if (isError) {
+            onError();
+          }
+        } catch (error) {
+          onError();
+        } finally {
+          window.removeEventListener('message', onWindowMessage);
+        }
+      }
+    };
+
+    window.addEventListener('message', onWindowMessage);
+    const authorizeUrl = project.identities.find(
+      (item: any) => item.identityType === AirdropSigIdentityTypeEnum.Twitter
+    )?.authorizeUrl;
+    window.open(authorizeUrl + '&state=state', '_blank', 'width=600,height=800');
+  }
+
+  async connectWallet({
+    chainType,
+    onSuccess,
+    onError
+  }: {
+    chainType: ChainType;
+    onSuccess: () => void;
+    onError: (error: any) => void;
+  }) {
+    try {
+      const project = await this.getProjectInfo();
+      const wallet = WalletFactory.getWallet(chainType);
+      const signResult = await wallet.signin(CONST.WELCOME_SIGNATURE_STATEMENT);
+
+      const { message, signature } = signResult || {};
+
+      const recipientTypeMap = {
+        [ChainType.Evm]: AirdropSigIdentityTypeEnum.EVMWallet,
+        [ChainType.Solana]: AirdropSigIdentityTypeEnum.SolanaWallet,
+        [ChainType.Ton]: ''
+      };
+
+      const payload = {
+        signature: signature as string,
+        message: message as string,
+        key: wallet.publicKey || wallet.address!,
+        projectId: project.id,
+        timestamp: Date.now(),
+        recipientType: recipientTypeMap[chainType]
+      };
+
+      await bindWallet(payload, this.endpoint);
+      onSuccess();
+    } catch (error) {
+      onError(error);
+    } finally {
+      onSuccess();
+    }
+  }
+}

package/src/airdrop/constants/index.ts

@@ -1,3 +1,8 @@
 export * from './chain-config';
 
 export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+
+export const CONST = {
+  TWITTER_AUTH_SUCCESS: 'twitter:auth:success',
+  WELCOME_SIGNATURE_STATEMENT: 'Welcome to TokenTable!'
+} as const;

package/src/airdrop/core/evm/contracts/AirdropSignatureClient.ts

@@ -0,0 +1,59 @@
+import { EvmContractClientOption } from '../../../types';
+import ABI from './abis/FungibleTokenECDSADistributor.json';
+import { ContractBaseClient } from './ContractBaseClient';
+
+export class AirdropSignatureClient extends ContractBaseClient {
+  constructor(options: EvmContractClientOption) {
+    super({
+      ...options,
+      abi: ABI
+    });
+  }
+
+  async getClaimStatus(userClaimId: string) {
+    return this.readContract({ functionName: 'getClaimStatus', args: [userClaimId] });
+  }
+
+  async claim(
+    data: {
+      recipient: string;
+      group: string;
+      data: string;
+      signature: string;
+      extraData: string;
+    }[],
+    value?: bigint
+  ) {
+    const [recipients = [], userClaimIds = [], datas = [], signatures = [], extraDatas = []] = [
+      'recipient',
+      'claimId',
+      'data',
+      'signature',
+      'extraData'
+    ].map((key) => data.map((item) => item[key as keyof (typeof data)[0]] || ''));
+
+    return this.writeContract({
+      functionName: 'claim',
+      args: [recipients, userClaimIds, datas, signatures, extraDatas],
+      value: value || 0n
+    });
+  }
+
+  async batchFetchClaimed(userClaimIds: string[]) {
+    // return this.multiCall({
+    //   chainId: this.chainId as any,
+    //   contracts: userClaimIds?.map((userClaimId) => {
+    //     return {
+    //       address: this.contractAddress,
+    //       abi: this.abi,
+    //       functionName: 'getClaimStatus',
+    //       args: [userClaimId]
+    //     };
+    //   })
+    // });
+  }
+
+  async getDeployer() {
+    return this.readContract({ functionName: 'getDeployer' }) as Promise<string>;
+  }
+}