@sign-global/tokentable 0.4.0-beta.9 → 0.4.0

package/src/airdrop/SignatureAirdropClient.ts

@@ -1,46 +1,25 @@
-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';
+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?: IAirdropSignatureClaim[];
+  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 readonly LOCAL_STORAGE_SID_PREFIX = 'sid_';
-
-  private setSid(projectId: string, sid: string): void {
-    window.localStorage.setItem(`${this.LOCAL_STORAGE_SID_PREFIX}${projectId}`, sid);
+    this.projectPromise = this.initializeProjects();
   }
 
   private async fetchProjectDetails(projectId: string): Promise<void> {
@@ -55,6 +34,7 @@ export class SignatureAirdropClient {
         return;
       }
 
+      // Fetch project details
       await this.fetchProjectDetails(projectId);
     } catch (error: any) {
       throw new Error(`Failed to initialize project: ${error.message}`);
@@ -62,9 +42,7 @@ export class SignatureAirdropClient {
   }
 
   async getProjectInfo() {
-    if (this.projectPromise) {
-      await this.projectPromise;
-    }
+    await this.projectPromise;
     if (!this.project) throw new Error('Project not found');
     return this.project;
   }
@@ -73,14 +51,13 @@ export class SignatureAirdropClient {
     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 || {};
+        const { isError, code, redirectUri } = message.data.data || {};
         try {
-          const res = await connectTwitter({ code, projectId: project.id }, this.endpoint);
-
-          if (res?.sid) {
-            this.setSid(project.id, res?.sid);
-          }
+          await connectTwitter({ code, redirectUri: redirectUri }, this.endpoint);
           onSuccess();
+          if (isError) {
+            onError();
+          }
         } catch (error) {
           onError();
         } finally {
@@ -102,146 +79,37 @@ export class SignatureAirdropClient {
     onError
   }: {
     chainType: ChainType;
-    onSuccess?: () => void;
-    onError?: (error: any) => void;
+    onSuccess: () => void;
+    onError: (error: any) => void;
   }) {
     try {
       const project = await this.getProjectInfo();
       const wallet = WalletFactory.getWallet(chainType);
-      const timestamp = Date.now();
+      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 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,
+        timestamp: Date.now(),
         recipientType: recipientTypeMap[chainType]
       };
 
-      const res = await bindWallet(payload, this.endpoint);
-      if (res?.sid) {
-        this.setSid(project.id, res?.sid);
-      }
-      onSuccess?.();
+      await bindWallet(payload, this.endpoint);
+      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');
+      onError(error);
+    } finally {
+      onSuccess();
     }
-    const claimIds = this.claims?.map((it) => it.claimId);
-    return strategy.batchFetchClaimed(claimIds);
   }
 }

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

@@ -53,16 +53,13 @@ export class EvmWallet extends WalletBase<EVMStoreType> {
     };
   }
 
-  override async signin(statement: string, prepare = true): Promise<ISignResult> {
+  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;
-        let fullMessage = statement;
-        if (prepare) {
-          const msg = prepareSignMessage({ statement, chainId: data.chainId!, address: data.address! });
-          fullMessage = get4361Message(msg);
-        }
+        const msg = prepareSignMessage({ statement, chainId: data.chainId!, address: data.address! });
+        const fullMessage = get4361Message(msg);
 
         const res = this.sign(fullMessage);
 

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

@@ -1,5 +1,5 @@
 import '@rainbow-me/rainbowkit/styles.css';
-import { RainbowKitProvider, darkTheme, useConnectModal } from '@rainbow-me/rainbowkit';
+import { RainbowKitProvider, lightTheme, useConnectModal } from '@rainbow-me/rainbowkit';
 import { ResolvedRegister, WagmiProvider, useAccount, useWalletClient } from 'wagmi';
 import { ReactNode, useEffect } from 'react';
 
@@ -26,27 +26,14 @@ export const EVMConnector = () => {
   return null;
 };
 
-export const EvmProvider = ({
-  children,
-  config,
-  theme
-}: {
-  children: ReactNode;
-  config: ResolvedRegister['config'];
-  theme?: any;
-}) => {
+export const EvmProvider = ({ children, config }: { children: ReactNode; config: ResolvedRegister['config'] }) => {
   evmStore.config = config;
   return (
     <WagmiProvider config={config}>
       <RainbowKitProvider
-        locale="en-US"
-        theme={
-          theme ||
-          darkTheme({
-            accentColor: 'var(--t-primary)',
-            accentColorForeground: 'var(--t-button-primary-foreground)'
-          })
-        }
+        theme={lightTheme({
+          accentColor: '#DD8D58'
+        })}
       >
         {children}
         <EVMConnector />

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

@@ -63,17 +63,14 @@ export class SolWallet extends WalletBase<SolStoreType> {
     }
   }
 
-  signin(statement: string, prepare = true): Promise<ISignResult> {
+  signin(statement?: string): Promise<ISignResult> {
     return new Promise((resolve) => {
       const signCallback = (data: ReturnType<typeof useWallet>) => {
         this.publicKey = data.publicKey?.toString();
         this.address = this.publicKey;
         this.chainId = 1;
-        let fullMessage = statement;
-        if (prepare) {
-          const msg = prepareSignMessage({ statement, chainId: '1', address: this.address! });
-          fullMessage = get4361Message(msg);
-        }
+        const msg = prepareSignMessage({ statement, chainId: '1', address: this.address! });
+        const fullMessage = get4361Message(msg);
 
         const res = this.sign(fullMessage);
 

package/src/airdrop/core/useWeb3ConnectWallet/providers/ton/TonWallet.ts

@@ -57,11 +57,11 @@ export class TonWallet extends WalletBase<TonStoreType> {
 
   async sign(originMsg: string): Promise<ISignResult> {
     const message = await hashSha256(originMsg);
-    const tonConnectUI = tonStore.walletClient as any;
+    const tonConnectUI = tonStore.walletClient as TonConnectUI;
     // const walletInfo = tonConnectUI?.wallet;
     const authType = '';
     // if (walletInfo?.jsBridgeKey && walletInfo?.openMethod !== 'qrcode') {
-    //     authType = walletInfo.jsBridgeKey;
+    //     authType = walletInfo.jsBridgeKey; 
     // }
 
     console.log(this.isConnected, tonConnectUI, 'connected');
@@ -72,10 +72,12 @@ export class TonWallet extends WalletBase<TonStoreType> {
     if (authType) {
       const wallets = await tonConnectUI.getWallets();
 
-      const currentWallet = wallets.find((wallet: any) =>
+      const currentWallet = wallets.find((wallet) =>
         [wallet.name, wallet.appName].includes(authType)
       ) as WalletInfoRemote;
 
+      console.log(wallets, currentWallet, 'ww');
+
       const link = tonConnectUI.connector.connect(
         {
           bridgeUrl: currentWallet.bridgeUrl,
@@ -131,19 +133,13 @@ export class TonWallet extends WalletBase<TonStoreType> {
     };
   }
 
-  override async signin(statement: string, prepare = true): Promise<ISignResult> {
-    const fullMessage = prepare
-      ? JSON.stringify(
-          {
-            statement: statement || 'Welcome to EthSign',
-            issuedAt: new Date().toISOString(),
-            nonce: getCustomNaNoId()
-          },
-          null,
-          '  '
-        )
-      : statement;
-    const signRes = await this.sign(fullMessage);
+  override async signin(statement?: string): Promise<ISignResult> {
+    const fullMessage = {
+      statement: statement || 'Welcome to EthSign',
+      issuedAt: new Date().toISOString(),
+      nonce: getCustomNaNoId()
+    };
+    const signRes = await this.sign(JSON.stringify(fullMessage, null, '  '));
     return signRes;
   }
 

package/src/airdrop/services/index.ts

@@ -1,13 +1,6 @@
 import { apiClient } from '../../utils/api-client';
 import { safeParseJSON } from '../../utils/utils';
-import {
-  AirdropSigIdentityTypeEnum,
-  IAirdropData,
-  IAirdropSignatureData,
-  IClaimSignature,
-  IContractConfig,
-  IProject
-} from '../types';
+import { IAirdropData, IContractConfig, IProject } from '../types';
 
 export { TonWalletService } from './wallet-service/ton';
 
@@ -18,7 +11,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 is null
+  if (!res) return res; // res为null
   const projectConfig = res?.themeConf;
   const blockCountries = safeParseJSON(projectConfig?.blockCountries);
   return {
@@ -77,81 +70,27 @@ export const getJettonInfo = async (
   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: []
-    };
+export const connectTwitter = async (data: { code: string; redirectUri: string }, baseURL?: string) => {
   const client = createApiClient(baseURL);
-
-  return client.post('/airdrop-open/check-eligibility', data, {
-    headers: headers
-  });
+  return client.post('/airdrop-open/connect-twitter', data);
 };
 
-export const bindWallet = async (data: WalletBindParams, baseURL?: string): Promise<SidResponse> => {
+export const checkEligibility = async (data: { projectId: string }, baseURL?: string) => {
   const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/connect-wallet', data, {
-    headers: getSidHeader(data.projectId)
-  });
+  return client.post('/airdrop-open/check-eligibility', data);
 };
 
-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 (
+export const bindWallet = async (
   data: {
     projectId: string;
-    claimIds: string[];
+    key: string;
+    signature: string;
+    message: string;
+    timestamp: number;
+    recipientType: string;
   },
   baseURL?: string
-): Promise<{ signatures: IClaimSignature[] }> => {
+) => {
   const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/check-get-signatures', data, {
-    headers: getSidHeader(data.projectId)
-  });
+  return client.post('/airdrop-open/connect-wallet', data);
 };

package/src/airdrop/types/index.ts

@@ -1,6 +1,7 @@
 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';
 
@@ -62,7 +63,6 @@ export interface IProject {
   version: string;
   extra?: IProjectExtra;
   identities: Identity[];
-  projectTag: string;
 }
 
 export interface Identity {
@@ -113,39 +113,10 @@ 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',
@@ -165,7 +136,6 @@ export type IAirdropService = TonAirdropService | EvmAirdropService;
 
 type BaseAirdropOptions = {
   endpoint?: string;
-  project?: IProject;
 };
 
 type ProjectIdOptions = BaseAirdropOptions & {

package/src/index.ts

@@ -1,10 +1,2 @@
-export {
-  AirdropClient,
-  SignatureAirdropClient,
-  CONST,
-  WalletFactory,
-  EvmProvider,
-  SolanaProvider,
-  TonProvider
-} from './airdrop';
+export { AirdropClient } from './airdrop';
 export * from './airdrop/types';

package/src/utils/api-client.ts

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

package/dist/cjs/airdrop/core/evm/SignatureAirdropService.d.ts

@@ -1,23 +0,0 @@
-import { EvmContractClientOption } from '../../types';
-import { DeployerClient } from './contracts/DeployClient';
-export declare class SignatureAirdropService {
-    options: EvmContractClientOption;
-    constructor(options: EvmContractClientOption);
-    private get airdropClient();
-    getDeployerClient(): Promise<DeployerClient>;
-    private getFeeClient;
-    getDeployer(): Promise<string>;
-    getVersion(): Promise<any>;
-    feeCollectors: (address: string) => Promise<unknown>;
-    feeTokens: (address: string) => Promise<unknown>;
-    getFeelessThreshold(): Promise<void>;
-    getClaimFee(address: string, amount: bigint): Promise<bigint | undefined>;
-    batchFetchClaimed(userClaimIds: string[]): Promise<boolean[]>;
-    claim(data: {
-        recipient: string;
-        claimId: string;
-        data: string;
-        signature: string;
-        extraData?: string;
-    }[], value?: bigint): Promise<`0x${string}`>;
-}