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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sign-global/tokentable",
-  "version": "0.3.0",
+  "version": "0.4.0-beta.10",
   "publishConfig": {
     "access": "public"
   },
@@ -17,14 +17,25 @@
   "author": "Evan",
   "license": "ISC",
   "dependencies": {
+    "@ethsign/utils-web": "^0.8.9",
     "@orbs-network/ton-access": "^2.3.3",
+    "@rainbow-me/rainbowkit": "^2.2.3",
+    "@solana/wallet-adapter-react": "^0.15.35",
+    "@solana/wallet-adapter-react-ui": "^0.9.35",
+    "@solana/wallet-adapter-wallets": "^0.19.32",
+    "@solana/web3.js": "^1.98.0",
     "@ton/core": "^0.59.0",
     "@ton/ton": "^15.1.0",
-    "@tonconnect/ui-react": "^2.0.9",
+    "@tonconnect/ui": "^2.0.11",
+    "@tonconnect/ui-react": "^2.0.11",
     "@types/jest": "^29.5.14",
     "bignumber.js": "^9.1.2",
+    "bs58": "^6.0.0",
     "dayjs": "^1.11.13",
     "jest": "^29.7.0",
+    "nanoid": "^5.0.9",
+    "react": "^18.2.0",
+    "ton-core": "^0.53.0",
     "tonapi-sdk-js": "^2.0.3",
     "tonweb": "^0.0.66",
     "ts-jest": "^29.2.5",
@@ -32,7 +43,8 @@
     "wagmi": "^2.13.0"
   },
   "devDependencies": {
+    "@types/react": "^18.2.0",
     "bun-types": "latest",
     "typescript": "^5.6.3"
   }
-}
+}

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,248 @@
+import { getAddress } from 'viem';
+import { CONST } from './constants';
+import { SignatureAirdropService } from './core/evm/SignatureAirdropService';
+import { WalletFactory } from './core/useWeb3ConnectWallet';
+import { ChainType } from './core/useWeb3ConnectWallet/types';
+import {
+  bindWallet,
+  checkEligibility,
+  checkGetSignatures,
+  connectTwitter,
+  disconnectRecipient,
+  getAirdropProject
+} from './services';
+import {
+  AirdropSigIdentityTypeEnum,
+  ChainId,
+  IAirdropOptions,
+  IAirdropSignatureClaim,
+  IClaimSignature,
+  IProject,
+  IWalletClient
+} from './types';
+
+export class SignatureAirdropClient {
+  private projectId?: string;
+  private endpoint?: string;
+  private project: IProject | undefined;
+  protected claims?: IAirdropSignatureClaim[];
+  private projectPromise: Promise<void> | undefined;
+  constructor(params: IAirdropOptions) {
+    this.projectId = params.projectId;
+    this.endpoint = params.endpoint;
+    if (this.project) {
+      this.project = params.project;
+    } else {
+      this.projectPromise = this.initializeProjects();
+    }
+  }
+
+  private readonly LOCAL_STORAGE_SID_PREFIX = 'sid_';
+
+  private setSid(projectId: string, sid: string): void {
+    window.localStorage.setItem(`${this.LOCAL_STORAGE_SID_PREFIX}${projectId}`, sid);
+  }
+
+  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 { code } = message.data.data || {};
+        try {
+          const res = await connectTwitter({ code, projectId: project.id }, this.endpoint);
+
+          if (res?.sid) {
+            this.setSid(project.id, res?.sid);
+          }
+          onSuccess();
+        } 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);
+      await wallet.disconnect();
+      const timestamp = Date.now();
+      const recipientTypeMap = {
+        [ChainType.Evm]: AirdropSigIdentityTypeEnum.EVMWallet,
+        [ChainType.Solana]: AirdropSigIdentityTypeEnum.SolanaWallet,
+        [ChainType.Ton]: ''
+      };
+      const msg = [project.id, recipientTypeMap[chainType], timestamp].join(',');
+      const signResult = await wallet.signin(msg, false);
+
+      const { message, signature } = signResult || {};
+
+      const payload = {
+        signature: signature as string,
+        message: message as string,
+        key: wallet.publicKey || wallet.address!,
+        projectId: project.id,
+        timestamp: timestamp,
+        recipientType: recipientTypeMap[chainType]
+      };
+
+      const res = await bindWallet(payload, this.endpoint);
+      if (res?.sid) {
+        this.setSid(project.id, res?.sid);
+      }
+      onSuccess?.();
+    } catch (error) {
+      onError?.(error);
+    }
+  }
+
+  async getClaims() {
+    const project = await this.getProjectInfo();
+    const res = await checkEligibility(
+      {
+        projectId: project.id
+      },
+      this.endpoint
+    );
+    this.claims = res.claims;
+    return res;
+  }
+
+  public async disconnectIdentity({
+    recipientType,
+    recipient
+  }: {
+    recipientType: AirdropSigIdentityTypeEnum;
+    recipient?: string;
+  }) {
+    const project = await this.getProjectInfo();
+    return await disconnectRecipient(
+      {
+        projectId: project.id,
+        recipientType,
+        recipient
+      },
+      this.endpoint
+    );
+  }
+
+  public async getStrategy(walletClient?: IWalletClient): Promise<SignatureAirdropService> {
+    const project = await this.getProjectInfo();
+
+    return new SignatureAirdropService({
+      chainId: Number(project.chainId) as ChainId,
+      contractAddress: project.contractAddress,
+      walletClient: walletClient as any
+    });
+  }
+
+  async getVersion(): Promise<string> {
+    const strategy = await this.getStrategy();
+    return strategy.getVersion();
+  }
+
+  async getClaimFee(amount?: bigint): Promise<undefined | bigint> {
+    const strategy = await this.getStrategy();
+    if (!strategy.getClaimFee) {
+      throw new Error('getClaimFee is not supported for this chain');
+    }
+    return await strategy.getClaimFee(this.project?.contractAddress || '', amount || BigInt(1));
+  }
+
+  async claimAirdrop({
+    claimIds,
+    walletClient,
+    recipient
+  }: {
+    claimIds: string[];
+    walletClient: IWalletClient;
+    recipient?: string;
+  }) {
+    if (!claimIds.length) {
+      throw new Error('Claim IDs cannot be empty');
+    }
+    if (!walletClient) {
+      throw new Error('Wallet client is required');
+    }
+    const service = await this.getStrategy(walletClient);
+    const res = await checkGetSignatures(
+      {
+        claimIds,
+        projectId: this.projectId!
+      },
+      this.endpoint
+    );
+    const signatureMap = res?.signatures?.reduce((map, item) => {
+      map[item.claimId] = item;
+      return map;
+    }, {} as Record<string, IClaimSignature>);
+    const claimData =
+      this.claims
+        ?.filter((it) => claimIds.includes(it.claimId))
+        .map((it) => ({
+          ...it,
+          recipient: recipient ? recipient : walletClient.account?.address!,
+          ...signatureMap?.[it.claimId]
+        })) || [];
+    const delegateMode = recipient ? getAddress(recipient) !== walletClient.account?.address : false;
+    const feeData = (await this.getClaimFee(1n)) || 0n;
+    const hash = (await service!.claim(
+      claimData,
+      delegateMode ? feeData * BigInt(claimData.length) : feeData
+    )) as `0x${string}`;
+    return hash;
+  }
+
+  async batchCheckClaimed(): Promise<boolean[]> {
+    if (!this.claims?.length) return [];
+    const strategy = await this.getStrategy();
+    if (!strategy.batchFetchClaimed) {
+      throw new Error('batchCheckClaimed is not supported for this chain');
+    }
+    const claimIds = this.claims?.map((it) => it.claimId);
+    return strategy.batchFetchClaimed(claimIds);
+  }
+}

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/SignatureAirdropService.ts

@@ -0,0 +1,90 @@
+import { ZERO_ADDRESS } from '../../constants';
+import { ChainId, EvmContractClientOption } from '../../types';
+import { AirdropSignatureClient } from './contracts/AirdropSignatureClient';
+import { DeployerClient } from './contracts/DeployClient';
+import { FeeCollectorClient } from './contracts/FeeCollectorClient';
+
+export class SignatureAirdropService {
+  options: EvmContractClientOption;
+  constructor(options: EvmContractClientOption) {
+    this.options = options;
+  }
+
+  private get airdropClient(): AirdropSignatureClient {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new AirdropSignatureClient(this.options);
+  }
+
+  async getDeployerClient(): Promise<DeployerClient> {
+    const deployer = await this.getDeployer();
+    return new DeployerClient({
+      ...this.options,
+      contractAddress: deployer
+    });
+  }
+
+  private getFeeClient(address: string): FeeCollectorClient {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new FeeCollectorClient({
+      ...this.options,
+      chainId: this.options.chainId as ChainId,
+      contractAddress: address
+    });
+  }
+
+  async getDeployer() {
+    return this.airdropClient.getDeployer();
+  }
+
+  async getVersion() {
+    return this.airdropClient.getVersion();
+  }
+
+  feeCollectors = async (address: string) => {
+    const deployerClient = await this.getDeployerClient();
+    return await deployerClient.feeCollectors(address);
+  };
+
+  feeTokens = async (address: string) => {
+    const deployerClient = await this.getDeployerClient();
+    return await deployerClient.feeTokens(address);
+  };
+
+  async getFeelessThreshold() {
+    // return this.airdropClient.getFeelessThreshold();
+  }
+
+  async getClaimFee(address: string, amount: bigint): Promise<bigint | undefined> {
+    const feeCollector = await this.feeCollectors(this.options.contractAddress as string);
+    if (!feeCollector || feeCollector === ZERO_ADDRESS) {
+      return undefined;
+    }
+    const feeClient = this.getFeeClient(feeCollector as string);
+    const fee = (await feeClient.getFee(address, amount)) as bigint;
+    return fee;
+  }
+
+  async batchFetchClaimed(userClaimIds: string[]): Promise<boolean[]> {
+    const res = await this.airdropClient.batchFetchClaimed(userClaimIds);
+    return res;
+  }
+
+  async claim(
+    data: {
+      recipient: string;
+      claimId: string;
+      data: string;
+      signature: string;
+      extraData?: string;
+    }[],
+    value?: bigint
+  ) {
+    return this.airdropClient.claim(data, value);
+  }
+}