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

package/src/airdrop/AirdropClient.ts

@@ -0,0 +1,301 @@
+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;
+    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();
+  }
+}

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 & { project?: IProject }) {
+    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/chain-config.ts

@@ -19,7 +19,7 @@ import { mevmDevNet, tonMainNet, tonTestNet } from './network';
 export const ChainConfig = {
   [mainnet.id]: {
     contractAddress: '0x0993Dd5384BcD116A3543889BC6ffA6C98948631',
-    rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/mlrnZeejmrnDOGPX1Fwp7lG3PscFwMgy'
+    rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/udrqNPSB6i5n5L6QSM31Ng72h_hFOrVT'
   },
   [bsc.id]: {
     contractAddress: '0x6c241FF6d5c3f074b49aC10872770529d9e27BA4',

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/useWeb3ConnectWallet/WalletBase.ts

@@ -0,0 +1,92 @@
+import { ISignResult } from './types';
+import { prepareSignMessage } from './utils';
+
+export abstract class WalletBase<S> {
+  type: string;
+  provider: any;
+  address?: string;
+  publicKey?: string;
+  chainId?: number | string;
+  protocolTag?: string;
+  authType: string;
+  userAddress?: string;
+  network?: string;
+
+  constructor(type: string, userAddress?: string) {
+    this.type = type;
+    this.provider = null;
+    this.address = '';
+    this.chainId = 1;
+    this.authType = '';
+    this.userAddress = userAddress || '';
+    // this.init();
+  }
+
+  // abstract init(): void;
+
+  // abstract init(): void;
+  protected get isConnected(): boolean {
+    throw new Error('Not implemented');
+  }
+
+  abstract connect(_?: string): void;
+
+  // common sign
+  abstract sign(_: string, _1?: string): Promise<ISignResult>;
+
+  // checkAddressValidity(): boolean {
+  //     console.log(this.userAddress, this.address);
+  //     if (!this.address) {
+  //         // 兼容ton的情况，ton只有sign之后才有地址
+  //         return true;
+  //     }
+  //     if (this.userAddress && this.address !== this.userAddress) {
+  //         console.error('Wallet address and user address do not match.');
+  //         globalVm.toggleAccountChangedModal(true);
+  //         return false;
+  //     }
+  //     return true;
+  // }
+
+  async safeSign(_: string, _1?: string): Promise<ISignResult> {
+    // if (!this.checkAddressValidity()) {
+    //     throw new Error('Wallet address and user address do not match.');
+    // }
+    return this.sign(_, _1);
+  }
+
+  async signin(statement?: string): Promise<ISignResult> {
+    const msgRes = prepareSignMessage({ statement, chainId: this.chainId!, address: this.address! });
+    return this.sign(JSON.stringify(msgRes, null, '  '));
+  }
+
+  // for metamask sign of EIP-712
+  signByEIP712(_: string): Promise<ISignResult> {
+    throw new Error(`received message:${_},Method not implemented.`);
+  }
+
+  getSignEIP712Message(_: { chainId: number | string; info: string; hash: string }): string {
+    throw new Error(`received message:${JSON.stringify(_)},Method not implemented.`);
+  }
+
+  getWallet(): {
+    address?: string;
+    isConnected: boolean;
+    publicKey: string | undefined;
+    type: string;
+    network: string | undefined;
+  } {
+    // 获取钱包信息
+    return {
+      type: this.type,
+      isConnected: this.isConnected,
+      address: this.address,
+      publicKey: this.publicKey,
+      network: this.network
+    };
+  }
+
+  abstract getStore(): S;
+
+  // abstract decrypt(message: string, address: string): Promise<string>;
+}

package/src/airdrop/core/useWeb3ConnectWallet/WalletFactory.tsx

@@ -0,0 +1,35 @@
+import { EvmWallet } from './providers/evm';
+import { ChainType } from './types';
+import { TonWallet } from './providers/ton';
+import { SolWallet } from './providers/solana';
+
+export abstract class WalletFactory {
+  private static instances: Record<string, EvmWallet | TonWallet | SolWallet> = {};
+  static getWallet(type: ChainType, userAddress?: string): EvmWallet | TonWallet | SolWallet {
+    if (!this.instances[type]) {
+      let WalletClass;
+      switch (type) {
+        case ChainType.Evm:
+          WalletClass = EvmWallet;
+          break;
+        case ChainType.Ton:
+          WalletClass = TonWallet;
+          break;
+        // case ChainType.Starknet:
+        //   WalletClass = StarknetWallet;
+        //   break;
+        case ChainType.Solana:
+          WalletClass = SolWallet;
+          break;
+        default:
+          throw new Error('Unsupported wallet type');
+      }
+
+      if (!WalletClass) {
+        throw new Error('Unsupported wallet type');
+      }
+      this.instances[type] = new WalletClass(type, userAddress);
+    }
+    return this.instances[type];
+  }
+}

package/src/airdrop/core/useWeb3ConnectWallet/index.ts

@@ -0,0 +1,3 @@
+export { WalletFactory } from './WalletFactory';
+
+export * from './providers';

package/src/airdrop/core/useWeb3ConnectWallet/providers/evm/EvmWallet.ts

@@ -0,0 +1,90 @@
+import { useConnectModal } from '@rainbow-me/rainbowkit';
+import { ResolvedRegister, useAccount, useWalletClient } from 'wagmi';
+import { WalletBase } from '../../WalletBase';
+import { disconnect, getAccount, signMessage } from 'wagmi/actions';
+import { EventEmitter } from 'events';
+import { ISignResult } from '../../types';
+import { get4361Message, prepareSignMessage } from '../../utils';
+
+export const eventBus = new EventEmitter();
+
+const EVM_EVENT_KEY = 'evm_signin';
+
+export interface EVMStoreType {
+  account: ReturnType<typeof useAccount> | null;
+  connectModal: ReturnType<typeof useConnectModal> | undefined;
+  walletClient: ReturnType<typeof useWalletClient> | undefined;
+  config: ResolvedRegister['config'] | undefined;
+  counter: number;
+}
+
+export const evmStore: EVMStoreType = {
+  account: null,
+  connectModal: undefined,
+  walletClient: undefined,
+  config: undefined,
+  counter: 0
+};
+
+export const getEventKey = () => {
+  return `${EVM_EVENT_KEY}_${evmStore.counter}`;
+};
+
+export class EvmWallet extends WalletBase<EVMStoreType> {
+  get isConnected() {
+    return !!(evmStore.account?.address && evmStore.account?.isConnected);
+  }
+
+  connect() {
+    evmStore?.connectModal?.openConnectModal?.();
+  }
+
+  async disconnect() {
+    await disconnect(evmStore.config!);
+  }
+
+  async sign(_message: string) {
+    const sign = await signMessage(evmStore.config!, {
+      message: _message
+    });
+    return {
+      message: _message,
+      signature: sign
+    };
+  }
+
+  override async signin(statement?: string): Promise<ISignResult> {
+    return new Promise((resolve) => {
+      const signCallback = (data: ReturnType<typeof useAccount>) => {
+        this.address = data.address;
+        this.chainId = data.chainId;
+        const msg = prepareSignMessage({ statement, chainId: data.chainId!, address: data.address! });
+        const fullMessage = get4361Message(msg);
+
+        const res = this.sign(fullMessage);
+
+        resolve(res);
+      };
+
+      const account = getAccount(evmStore.config!);
+      this.provider = evmStore.walletClient;
+
+      if (this.isConnected) {
+        signCallback(account);
+        return;
+      }
+
+      evmStore.counter++;
+      this.connect();
+      const eventKey = getEventKey();
+      eventBus.once(eventKey, (data) => {
+        console.log('listen event key success, event key = %s, data = %j', eventKey, data);
+        signCallback(data);
+      });
+    });
+  }
+
+  getStore(): EVMStoreType {
+    return evmStore;
+  }
+}

package/src/airdrop/core/useWeb3ConnectWallet/providers/evm/index.tsx

@@ -0,0 +1,43 @@
+import '@rainbow-me/rainbowkit/styles.css';
+import { RainbowKitProvider, lightTheme, useConnectModal } from '@rainbow-me/rainbowkit';
+import { ResolvedRegister, WagmiProvider, useAccount, useWalletClient } from 'wagmi';
+import { ReactNode, useEffect } from 'react';
+
+import { evmStore, getEventKey, eventBus } from './EvmWallet';
+
+export { EvmWallet } from './EvmWallet';
+
+export const EVMConnector = () => {
+  const connectModal = useConnectModal();
+  const walletClient = useWalletClient();
+  const account = useAccount();
+
+  evmStore.connectModal = connectModal;
+  evmStore.walletClient = walletClient;
+  evmStore.account = account;
+
+  useEffect(() => {
+    if (account.isConnected) {
+      const eventKey = getEventKey();
+      eventBus.emit(eventKey, account);
+    }
+  }, [account]);
+
+  return null;
+};
+
+export const EvmProvider = ({ children, config }: { children: ReactNode; config: ResolvedRegister['config'] }) => {
+  evmStore.config = config;
+  return (
+    <WagmiProvider config={config}>
+      <RainbowKitProvider
+        theme={lightTheme({
+          accentColor: '#DD8D58'
+        })}
+      >
+        {children}
+        <EVMConnector />
+      </RainbowKitProvider>
+    </WagmiProvider>
+  );
+};