@sign-global/tokentable 0.5.3-beta.0 → 1.0.0

package/src/SignatureAirdropClient.ts

@@ -0,0 +1,390 @@
+import { WalletFactory } from '@sign-global/tokentable-wallets';
+import {
+  bindWallet,
+  checkEligibility,
+  checkGetSignatures,
+  connectGoogleApi,
+  connectTwitter,
+  disconnectRecipient,
+  getAirdropProject,
+  cleanUrlParams,
+  isMobile,
+  getChainRpc,
+  CONST,
+  EvmSignatureAirdropService,
+  SolanaSignatureAirdropService,
+  AirdropSigIdentityTypeEnum,
+  ChainId,
+  ErrorCode,
+  IAirdropOptions,
+  IAirdropSignatureClaim,
+  IAirdropSignatureIdentity,
+  IClaimSignature,
+  IProject,
+  IWalletClient,
+  SolanaWalletState,
+  ViemWalletClient,
+  ChainType
+} from '@sign-global/tokentable-core';
+
+export class SignatureAirdropClient {
+  private projectId?: string;
+  private endpoint?: string;
+  private project: IProject | undefined;
+  private chainRpc?: string;
+  protected claims?: IAirdropSignatureClaim[];
+  protected identities?: IAirdropSignatureIdentity[];
+  private projectPromise: Promise<void> | undefined;
+  private authPromise: Promise<void> | undefined;
+  private strategyCache: Map<string, EvmSignatureAirdropService | SolanaSignatureAirdropService> = new Map();
+  constructor(params: IAirdropOptions) {
+    this.projectId = params.projectId;
+    this.endpoint = params.endpoint;
+    this.chainRpc = params.chainRpc;
+    if (this.project) {
+      this.project = params.project;
+    } else {
+      this.projectPromise = this.initializeProjects();
+    }
+    if (isMobile()) {
+      this.authPromise = this.checkAndHandleTwitterCode();
+    }
+  }
+
+  private readonly LOCAL_STORAGE_SID_PREFIX = 'sid_';
+
+  private async checkAndHandleTwitterCode() {
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const code = urlParams.get('code');
+      const type = urlParams.get('type');
+
+      if (code && this.projectId) {
+        let res;
+        if (type === 'twitter') {
+          res = await connectTwitter({ code, projectId: this.projectId }, this.endpoint);
+        } else if (type === 'google') {
+          res = await connectGoogleApi({ code, projectId: this.projectId }, this.endpoint);
+        }
+        if (res?.sid) {
+          this.setSid(this.projectId!, res.sid);
+        } else {
+          throw new Error('Failed to connect');
+        }
+        cleanUrlParams(['code', 'type']);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  private setSid(projectId: string, sid: string): void {
+    window.localStorage.setItem(`${this.LOCAL_STORAGE_SID_PREFIX}${projectId}`, sid);
+  }
+
+  private async fetchProjectDetails(projectId: string): Promise<void> {
+    const project = await getAirdropProject(projectId, this.endpoint);
+    this.project = project;
+    if (this.chainRpc) return;
+    const chainId = project.chainType === ChainType.Evm ? Number(project.chainId) : project.chainId;
+    this.chainRpc = getChainRpc(chainId as ChainId);
+  }
+
+  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 connectOAuth({
+    onSuccess,
+    onError,
+    type
+  }: {
+    onSuccess: () => void;
+    onError: (error: Error) => void;
+    type: AirdropSigIdentityTypeEnum;
+  }) {
+    const project = await this.getProjectInfo();
+    const authorizeUrl = project.identities.find((item: any) => item.identityType === type)?.authorizeUrl;
+    if (!authorizeUrl) {
+      onError(new Error('Authorize URL not found'));
+      return;
+    }
+    if (isMobile()) {
+      const state = encodeURIComponent(window.location.href);
+      window.location.href = `${authorizeUrl}&state=${state}`;
+      return;
+    }
+    const onWindowMessage = async (message: any) => {
+      const name = message.data?.name;
+      if (name && [CONST.TWITTER_AUTH_SUCCESS, CONST.GOOGLE_AUTH_SUCCESS].includes(name)) {
+        const { code } = message.data.data || {};
+        try {
+          let res;
+          if (name === CONST.GOOGLE_AUTH_SUCCESS) {
+            res = await connectGoogleApi({ code, projectId: project.id }, this.endpoint);
+          } else if (name === CONST.TWITTER_AUTH_SUCCESS) {
+            res = await connectTwitter({ code, projectId: project.id }, this.endpoint);
+          }
+          if (res?.sid) {
+            this.setSid(project.id, res?.sid);
+            onSuccess();
+          } else {
+            onError(new Error('Failed to connect'));
+          }
+        } catch (error) {
+          onError(error as Error);
+        } finally {
+          window.removeEventListener('message', onWindowMessage);
+        }
+      }
+    };
+
+    window.addEventListener('message', onWindowMessage);
+    window.open(`${authorizeUrl}&state=state`, `twitter_auth_${project.id}`, 'width=600,height=800');
+  }
+
+  async connectX({ onSuccess, onError }: { onSuccess: () => void; onError: (error: Error) => void }) {
+    await this.connectOAuth({
+      onSuccess,
+      onError,
+      type: AirdropSigIdentityTypeEnum.Twitter
+    });
+  }
+
+  async connectGoogle({ onSuccess, onError }: { onSuccess: () => void; onError: (error: Error) => void }) {
+    await this.connectOAuth({
+      onSuccess,
+      onError,
+      type: AirdropSigIdentityTypeEnum.Google
+    });
+  }
+
+  async connectWallet({
+    chainType,
+    onSuccess,
+    onError
+  }: {
+    chainType: ChainType;
+    onSuccess?: (address: string) => void;
+    onError?: (error: any) => void;
+  }) {
+    try {
+      const project = await this.getProjectInfo();
+      const wallet = WalletFactory.getWallet(chainType);
+      const timestamp = Date.now();
+      const recipientTypeMap = {
+        [ChainType.Evm]: AirdropSigIdentityTypeEnum.EVMWallet,
+        [ChainType.Solana]: AirdropSigIdentityTypeEnum.SolanaWallet,
+        [ChainType.Ton]: AirdropSigIdentityTypeEnum.TONWallet
+      };
+      const msg = [project.id, recipientTypeMap[chainType], timestamp].join(',');
+      const signResult = await wallet.signin(msg, false);
+      await wallet.disconnect();
+      const { message, signature } = signResult || {};
+
+      if (this.identities?.find((it) => it.value?.toLowerCase() === wallet.address?.toLowerCase())) {
+        onError?.(ErrorCode.WALLET_ALREADY_CONNECTED);
+        return;
+      }
+
+      const payload = {
+        signature: signature as string,
+        message: message as string,
+        key: wallet.publicKey || wallet.address!,
+        address: 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?.(wallet.address!);
+    } catch (error) {
+      onError?.(error);
+    }
+  }
+
+  async getClaims() {
+    const project = await this.getProjectInfo();
+    if (this.authPromise) {
+      await this.authPromise;
+    }
+    const res = await checkEligibility(
+      {
+        projectId: project.id
+      },
+      this.endpoint
+    );
+    this.claims = res.claims;
+    this.identities = res.identities;
+    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<EvmSignatureAirdropService | SolanaSignatureAirdropService> {
+    const project = await this.getProjectInfo();
+
+    const cacheKey = walletClient
+      ? project.chainType === ChainType.Evm
+        ? (walletClient as ViemWalletClient).account?.address!
+        : project.chainType === ChainType.Solana
+          ? (walletClient as SolanaWalletState).publicKey!.toString()
+          : 'walletClient'
+      : 'default';
+    if (this.strategyCache.has(cacheKey)) {
+      return this.strategyCache.get(cacheKey)!;
+    }
+
+    const strategy =
+      project.chainType === ChainType.Solana
+        ? new SolanaSignatureAirdropService({
+            chainId: project.chainId,
+            projectId: project.id,
+            token: project.tokenAddress,
+            walletClient: walletClient as any,
+            chainRpc: this.chainRpc!
+          })
+        : new EvmSignatureAirdropService({
+            chainId: Number(project.chainId) as ChainId,
+            contractAddress: project.contractAddress,
+            walletClient: walletClient as any,
+            chainRpc: this.chainRpc!
+          });
+    this.strategyCache.set(cacheKey, strategy);
+    return strategy;
+  }
+
+  async getVersion(): Promise<string> {
+    const strategy = await this.getStrategy();
+    return strategy.getVersion();
+  }
+
+  // solana prams need to wallet
+  async getClaimFee(amount?: bigint, walletClient?: IWalletClient): Promise<undefined | bigint> {
+    const strategy = await this.getStrategy(walletClient);
+    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');
+    }
+    if (!this.claims?.length) {
+      throw new Error('No claims available');
+    }
+    const service = await this.getStrategy(walletClient);
+    const project = await this.getProjectInfo();
+    const res = await checkGetSignatures(
+      {
+        claimIds,
+        projectId: this.projectId!,
+        recipient
+      },
+      this.endpoint
+    );
+    if (!res?.signatures?.length) {
+      throw new Error('Failed to get signatures');
+    }
+    const signatureMap = res?.signatures?.reduce(
+      (map, item) => {
+        map[item.claimId] = item;
+        return map;
+      },
+      {} as Record<string, IClaimSignature>
+    );
+    const filteredClaims = this.claims.filter((it) => claimIds.includes(it.claimId));
+    if (!filteredClaims.length) {
+      throw new Error('No matching claims found');
+    }
+
+    // only evm use
+    const defaultRecipient =
+      project.chainType === ChainType.Evm ? (walletClient as ViemWalletClient).account?.address! : '';
+
+    const claimData = filteredClaims.map((it) => {
+      const signature = signatureMap[it.claimId];
+      if (!signature) {
+        throw new Error(`Signature not found for claim ID: ${it.claimId}`);
+      }
+
+      return {
+        ...it,
+        recipient: recipient ? recipient : defaultRecipient,
+        ...signature
+      };
+    });
+
+    const hash = (await service!.claim(claimData, recipient)) 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);
+  }
+
+  async getPaused(): Promise<boolean> {
+    const strategy = await this.getStrategy();
+    if (!strategy.getPaused) {
+      throw new Error('getPaused is not supported for this chain');
+    }
+    return strategy.getPaused();
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { AirdropClient } from './AirdropClient';
+export { SignatureAirdropClient } from './SignatureAirdropClient';
+export * from '@sign-global/tokentable-core';
+export * from '@sign-global/tokentable-wallets';

package/src/strategies/AirdropStrategyFactory.ts

@@ -0,0 +1,34 @@
+import { ChainType, IWalletClient } from '@sign-global/tokentable-core';
+import { EvmAirdropStrategy } from './EvmAirdropStrategy';
+import { IAirdropStrategy, IAirdropStrategyConstructor } from './IAirdropStrategy';
+import { SolanaAirdropStrategy } from './SolanaAirdropStrategy';
+import { TonAirdropStrategy } from './TonAirdropStrategy';
+import { TonClient } from '@ton/ton';
+
+export class AirdropStrategyFactory {
+  private static strategyMap: Record<ChainType, IAirdropStrategyConstructor | null> = {
+    [ChainType.Evm]: EvmAirdropStrategy,
+    [ChainType.Ton]: TonAirdropStrategy,
+    [ChainType.Solana]: SolanaAirdropStrategy
+  };
+
+  static createStrategy(params: {
+    chainType: ChainType;
+    contractAddress: string;
+    chainId: string | number;
+    walletClient?: IWalletClient;
+    tonClient?: TonClient;
+    version?: string;
+    projectId: string;
+    chainRpc: string;
+  }): IAirdropStrategy {
+    const { chainType, ...strategyParams } = params;
+    const StrategyClass = this.strategyMap[chainType];
+
+    if (!StrategyClass) {
+      throw new Error(`Unsupported chain type: ${chainType}`);
+    }
+
+    return new StrategyClass(strategyParams);
+  }
+}

package/src/strategies/EvmAirdropStrategy.ts

@@ -0,0 +1,88 @@
+import { EvmAirdropService, ChainId, IWalletClient } from '@sign-global/tokentable-core';
+import { IAirdropStrategy } from './IAirdropStrategy';
+import { WalletClient as ViemWalletClient } from 'viem';
+
+export class EvmAirdropStrategy implements IAirdropStrategy {
+  private service: EvmAirdropService | undefined;
+  private readonly contractAddress: string;
+  private readonly chainId: ChainId;
+  private readonly chainRpc: string;
+  private walletClient?: ViemWalletClient;
+  private cachedVersion: string | null = null;
+
+  constructor(params: {
+    contractAddress: string;
+    chainId: string | number;
+    walletClient?: IWalletClient;
+    chainRpc: string;
+  }) {
+    this.contractAddress = params.contractAddress;
+    this.chainId = Number(params.chainId) as ChainId;
+    this.chainRpc = params.chainRpc;
+    if (params.walletClient) {
+      this.walletClient = params.walletClient as ViemWalletClient;
+    }
+  }
+
+  async initialize(walletClient?: IWalletClient): Promise<void> {
+    if (walletClient) {
+      this.walletClient = walletClient as ViemWalletClient;
+    }
+    this.service = new EvmAirdropService({
+      contractAddress: this.contractAddress,
+      chainId: this.chainId,
+      walletClient: this.walletClient,
+      chainRpc: this.chainRpc
+    });
+  }
+
+  isInitialized(): boolean {
+    return !!this.service;
+  }
+
+  async getVersion(): Promise<string> {
+    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: any): Promise<any> {
+    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: any): Promise<boolean> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.isLeafUsed(claimData.leaf);
+  }
+
+  async batchCheckClaimed(leafs: string[]): Promise<{ result: boolean; status: string }[]> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.batchFetchClaimed(leafs);
+  }
+
+  async getNFT(): Promise<string> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.getNFT() as unknown as string;
+  }
+
+  async getKycThreshold(): Promise<bigint> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.getKycThreshold();
+  }
+
+  async getClaimFee(contractAddress: string, amount: bigint): Promise<bigint> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.getClaimFee(contractAddress, amount) as unknown as bigint;
+  }
+}

package/src/strategies/IAirdropStrategy.ts

@@ -0,0 +1,28 @@
+import { IWalletClient } from '@sign-global/tokentable-core';
+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>;
+  // EVM specific methods
+  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;
+    version?: string;
+    projectId: string;
+    chainRpc: string;
+  }): IAirdropStrategy;
+}

package/src/strategies/SolanaAirdropStrategy.ts

@@ -0,0 +1,76 @@
+import { SolanaAirdropService, ChainId, IWalletClient, SolanaWalletState } from '@sign-global/tokentable-core';
+import { IAirdropStrategy } from './IAirdropStrategy';
+
+export class SolanaAirdropStrategy implements IAirdropStrategy {
+  private service: SolanaAirdropService | undefined;
+  private readonly chainId: ChainId;
+  private readonly chainRpc: string;
+  private walletClient?: SolanaWalletState;
+  private cachedVersion: string | null = null;
+  private projectId: string;
+
+  constructor(params: {
+    contractAddress: string;
+    chainId: string | number;
+    walletClient?: IWalletClient;
+    projectId: string;
+    chainRpc: string;
+  }) {
+    this.chainId = params.chainId as ChainId;
+    this.projectId = params.projectId;
+    this.chainRpc = params.chainRpc;
+    if (params.walletClient) {
+      this.walletClient = params.walletClient as SolanaWalletState;
+    }
+  }
+
+  async initialize(walletClient?: IWalletClient): Promise<void> {
+    if (walletClient) {
+      this.walletClient = walletClient as SolanaWalletState;
+    }
+    this.service = new SolanaAirdropService({
+      projectId: this.projectId,
+      chainId: this.chainId as string,
+      walletClient: this.walletClient as any,
+      chainRpc: this.chainRpc
+    });
+  }
+
+  isInitialized(): boolean {
+    return !!this.service;
+  }
+
+  async getVersion(): Promise<string> {
+    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: any): Promise<any> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.claim(claimData);
+  }
+
+  async checkClaimed(claimData: any): Promise<boolean> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.isLeafUsed(claimData.leaf);
+  }
+
+  async batchCheckClaimed(leafs: string[]): Promise<{ result: boolean; status: string }[]> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.batchFetchClaimed(leafs);
+  }
+
+  async getClaimFee(contractAddress: string, amount: bigint): Promise<bigint> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.getClaimFee(contractAddress, amount) as unknown as bigint;
+  }
+
+  async getPaused(): Promise<boolean> {
+    if (!this.service) throw new Error('Strategy not initialized');
+    return this.service.getPaused();
+  }
+}

package/src/strategies/StrategyCache.ts

@@ -0,0 +1,34 @@
+import { IAirdropStrategy } from './IAirdropStrategy';
+
+export class StrategyCache {
+  private readOnlyStrategies: Map<string, IAirdropStrategy> = new Map();
+  private walletStrategies: Map<string, IAirdropStrategy> = new Map();
+
+  private getCacheKey(contractAddress: string, chainId: string | number, chainType: string): string {
+    return `${chainType}:${contractAddress}:${chainId}`;
+  }
+
+  getStrategy(contractAddress: string, chainId: string | number, chainType: string, hasWallet: boolean = false): IAirdropStrategy | undefined {
+    const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
+    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
+    return cache.get(cacheKey);
+  }
+
+  setStrategy(contractAddress: string, chainId: string | number, chainType: string, strategy: IAirdropStrategy, hasWallet: boolean = false): void {
+    const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
+    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
+    cache.set(cacheKey, strategy);
+  }
+
+  clearStrategy(contractAddress: string, chainId: string | number, chainType: string, hasWallet?: boolean): void {
+    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();