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

package/src/airdrop/index.ts

@@ -1,305 +1,5 @@
-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 { 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;
-  }
-
-  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() {
-    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();
-  }
-}
+export { CONST } from './constants';
+export * from './core/useWeb3ConnectWallet';

package/src/airdrop/services/index.ts

@@ -1,6 +1,13 @@
 import { apiClient } from '../../utils/api-client';
 import { safeParseJSON } from '../../utils/utils';
-import { IAirdropData, IContractConfig, IProject } from '../types';
+import {
+  AirdropSigIdentityTypeEnum,
+  IAirdropData,
+  IAirdropSignatureData,
+  IClaimSignature,
+  IContractConfig,
+  IProject
+} from '../types';
 
 export { TonWalletService } from './wallet-service/ton';
 
@@ -11,7 +18,7 @@ const createApiClient = (baseURL?: string) => {
 export const getAirdropProject = async (projectId: string, baseURL?: string): Promise<IProject> => {
   const client = createApiClient(baseURL);
   const res = await client.get<any>(`/airdrop-open/projects/${projectId}`);
-  if (!res) return res; // res为null
+  if (!res) return res; // res is null
   const projectConfig = res?.themeConf;
   const blockCountries = safeParseJSON(projectConfig?.blockCountries);
   return {
@@ -54,7 +61,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 +76,82 @@ export const getJettonInfo = async (
   const client = createApiClient(baseURL);
   return client.get(`/airdrop-open/jetton/${data.address}?isTestnet=${data.isTestnet}`);
 };
+
+interface SidResponse {
+  sid: string;
+}
+
+interface TwitterConnectParams {
+  code: string;
+  projectId: string;
+}
+
+interface WalletBindParams {
+  projectId: string;
+  key: string;
+  signature: string;
+  message: string;
+  timestamp: number;
+  recipientType: string;
+}
+
+const getSidHeader = (projectId: string) => ({
+  sid: window.localStorage.getItem(`sid_${projectId}`) || ''
+});
+
+export const connectTwitter = async (data: TwitterConnectParams, baseURL?: string): Promise<SidResponse> => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/connect-twitter', data, {
+    headers: getSidHeader(data.projectId)
+  });
+};
+
+export const checkEligibility = async (
+  data: { projectId: string },
+  baseURL?: string
+): Promise<IAirdropSignatureData> => {
+  const headers = getSidHeader(data.projectId);
+  if (!headers.sid)
+    return {
+      claims: [],
+      identities: []
+    };
+  const client = createApiClient(baseURL);
+
+  return client.post('/airdrop-open/check-eligibility', data, {
+    headers: headers
+  });
+};
+
+export const bindWallet = async (data: WalletBindParams, baseURL?: string): Promise<SidResponse> => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/connect-wallet', data, {
+    headers: getSidHeader(data.projectId)
+  });
+};
+
+interface DisconnectParams {
+  projectId: string;
+  recipientType: AirdropSigIdentityTypeEnum;
+  recipient?: string;
+}
+
+export const disconnectRecipient = async (data: DisconnectParams, baseURL?: string): Promise<void> => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/disconnect', data, {
+    headers: getSidHeader(data.projectId)
+  });
+};
+
+export const checkGetSignatures = async (
+  data: {
+    projectId: string;
+    claimIds: string[];
+  },
+  baseURL?: string
+): Promise<{ signatures: IClaimSignature[] }> => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/check-get-signatures', data, {
+    headers: getSidHeader(data.projectId)
+  });
+};

package/src/airdrop/types/index.ts

@@ -1,7 +1,6 @@
 import { TonConnectUI } from '@tonconnect/ui-react';
 import { AirdropService as TonAirdropService } from '../core/ton/AirdropService';
 import { AirdropService as EvmAirdropService } from '../core/evm/AirdropService';
-import { TonClient } from '@ton/ton';
 import { ChainConfig } from '../constants';
 import { WalletClient as ViemWalletClient } from 'viem';
 
@@ -61,10 +60,28 @@ export interface IProject {
   blockCountries: Record<string, string>;
   themeConf: ThemeConfig | null;
   version: string;
-  extra?: {
-    kyc: boolean;
-    tag: string;
-  };
+  extra?: IProjectExtra;
+  identities: Identity[];
+  projectTag: string;
+}
+
+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 {
@@ -96,10 +113,39 @@ export type IAirdropClaim = {
   project: IProject;
 };
 
+export type IAirdropSignatureClaim = {
+  percent: number;
+  unlockingAt: number;
+  claimDeadline: number;
+  value: string;
+  recipient: string;
+  recipientType: string;
+  claimId: string;
+  data?: string;
+  signature?: string;
+  claimed?: boolean;
+};
+
+export interface IAirdropSignatureIdentity {
+  type: AirdropSigIdentityTypeEnum;
+  value: string;
+}
+
 export interface IAirdropData {
   claims: IAirdropClaim[];
 }
 
+export interface IAirdropSignatureData {
+  claims: IAirdropSignatureClaim[];
+  identities: IAirdropSignatureIdentity[];
+}
+
+export interface IClaimSignature {
+  claimId: string;
+  data: string;
+  signature: string;
+}
+
 export enum TonAirdropVersionEnum {
   V1 = '1.0.0',
   V2 = '2.0.0',
@@ -119,6 +165,7 @@ export type IAirdropService = TonAirdropService | EvmAirdropService;
 
 type BaseAirdropOptions = {
   endpoint?: string;
+  project?: IProject;
 };
 
 type ProjectIdOptions = BaseAirdropOptions & {
@@ -137,4 +184,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/api-client.ts

@@ -5,6 +5,7 @@ export type ApiClientOptions = {
 export type ApiRequestOptions = {
   params?: Record<string, string | number>;
   skipHandleError?: boolean;
+  headers?: Record<string, string>;
 };
 
 type ApiResponse = {
@@ -48,11 +49,11 @@ export class ApiClient {
   ): Promise<unknown> {
     const finalUrl = (this.options?.baseURL || '') + url;
 
-    const init: RequestInit = { method };
+    const init: RequestInit = { method, headers: options?.headers || {} };
     if (data instanceof FormData) {
       init.body = data;
     } else {
-      init.headers = { 'content-type': 'application/json' };
+      init.headers = { 'content-type': 'application/json', ...init.headers };
       init.body = data ? JSON.stringify(data) : void 0;
     }
 

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,