@sign-global/tokentable 0.4.0-beta.3 → 0.4.0-beta.4

package/src/airdrop/SignatureAirdropClient.ts

@@ -1,11 +1,11 @@
 import { CONST } from './constants';
+import { SignatureAirdropService } from './core/evm/SignatureAirdropService';
 import { WalletFactory } from './core/useWeb3ConnectWallet';
 import { ChainType } from './core/useWeb3ConnectWallet/types';
-import { bindWallet, connectTwitter, getAirdropProject } from './services';
-import { AirdropSigIdentityTypeEnum, IAirdropOptions, IProject } from './types';
+import { bindWallet, checkEligibility, connectTwitter, getAirdropProject } from './services';
+import { AirdropSigIdentityTypeEnum, ChainId, IAirdropOptions, IProject, IWalletClient } from './types';
 
 export class SignatureAirdropClient {
-  private slug?: string;
   private projectId?: string;
   private endpoint?: string;
   private project: IProject | undefined;
@@ -14,9 +14,9 @@ export class SignatureAirdropClient {
   private claimHook: ((v: any) => any) | undefined;
   //   private contractConfig: IContractConfig | null = null;
   constructor(params: IAirdropOptions) {
-    if ('slug' in params) {
-      this.slug = params.slug;
-    }
+    // if ('slug' in params) {
+    //   this.slug = params.slug;
+    // }
     this.projectId = params.projectId;
     this.endpoint = params.endpoint;
     if (this.project) {
@@ -56,13 +56,12 @@ 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 { isError, code, redirectUri } = message.data.data || {};
+        const { code } = message.data.data || {};
         try {
-          await connectTwitter({ code, redirectUri: redirectUri }, this.endpoint);
+          const res = await connectTwitter({ code, projectId: project.id }, this.endpoint);
+
+          if (res?.sid) window.localStorage.setItem('sid_' + project.id, res?.sid);
           onSuccess();
-          if (isError) {
-            onError();
-          }
         } catch (error) {
           onError();
         } finally {
@@ -110,10 +109,68 @@ export class SignatureAirdropClient {
         recipientType: recipientTypeMap[chainType]
       };
 
-      await bindWallet(payload, this.endpoint);
+      const res = await bindWallet(payload, this.endpoint);
+      if (res?.sid) window.localStorage.setItem('sid_' + 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 this.claims;
+  }
+
+  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 getClaimFee(amount?: bigint): Promise<bigint> {
+    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)) as unknown as bigint;
+  }
+
+  async claimAirdrop({ claimIds, walletClient }: { claimIds: string[]; walletClient: IWalletClient }) {
+    const service = await this.getStrategy(walletClient);
+    const claimData = this.claims?.filter((it) => claimIds.includes(it.claimId)) || [];
+    let delegateMode = false;
+    claimData.forEach((it) => {
+      if (it.recipient !== walletClient.account?.address) {
+        delegateMode = true;
+      }
+    });
+    const feeData = await this.getClaimFee(1n);
+    const hash = (await service!.claim(
+      claimData,
+      delegateMode ? feeData * BigInt(claimData.length) : feeData
+    )) as unknown as `0x${string}`;
+    return hash;
+  }
+
+  async batchCheckClaimed(): Promise<boolean[]> {
+    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);
+    if (!claimIds) return [];
+    return strategy.batchFetchClaimed(claimIds);
+  }
 }

package/src/airdrop/core/evm/SignatureAirdropService.ts

@@ -0,0 +1,86 @@
+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();
+  }
+
+  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);
+    return fee;
+  }
+
+  async batchFetchClaimed(userClaimIds: string[]): Promise<boolean[]> {
+    const res = await this.airdropClient.batchFetchClaimed(userClaimIds);
+    return res;
+  }
+
+  async claim(
+    data: {
+      recipient: string;
+      group: string;
+      data: string;
+      signature: string;
+      extraData: string;
+    }[],
+    value?: bigint
+  ) {
+    return this.airdropClient.claim(data, value);
+  }
+}

package/src/airdrop/core/evm/contracts/AirdropSignatureClient.ts

@@ -40,20 +40,12 @@ export class AirdropSignatureClient extends ContractBaseClient {
   }
 
   async batchFetchClaimed(userClaimIds: string[]) {
-    // return this.multiCall({
-    //   chainId: this.chainId as any,
-    //   contracts: userClaimIds?.map((userClaimId) => {
-    //     return {
-    //       address: this.contractAddress,
-    //       abi: this.abi,
-    //       functionName: 'getClaimStatus',
-    //       args: [userClaimId]
-    //     };
-    //   })
-    // });
+    const res: any = await this.readContract({ functionName: 'getClaimStatus', args: [userClaimIds] });
+    return res;
   }
 
   async getDeployer() {
-    return this.readContract({ functionName: 'getDeployer' }) as Promise<string>;
+    const res: any = await this.readContract({ functionName: 'getStorage' });
+    return res?.[3];
   }
 }

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

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

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

@@ -63,14 +63,17 @@ export class SolWallet extends WalletBase<SolStoreType> {
     }
   }
 
-  signin(statement?: string): Promise<ISignResult> {
+  signin(statement: string, prepare = true): Promise<ISignResult> {
     return new Promise((resolve) => {
       const signCallback = (data: ReturnType<typeof useWallet>) => {
         this.publicKey = data.publicKey?.toString();
         this.address = this.publicKey;
         this.chainId = 1;
-        const msg = prepareSignMessage({ statement, chainId: '1', address: this.address! });
-        const fullMessage = get4361Message(msg);
+        let fullMessage = statement;
+        if (prepare) {
+          const msg = prepareSignMessage({ statement, chainId: '1', address: this.address! });
+          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 TonConnectUI;
+    const tonConnectUI = tonStore.walletClient as any;
     // 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,12 +72,10 @@ export class TonWallet extends WalletBase<TonStoreType> {
     if (authType) {
       const wallets = await tonConnectUI.getWallets();
 
-      const currentWallet = wallets.find((wallet) =>
+      const currentWallet = wallets.find((wallet: any) =>
         [wallet.name, wallet.appName].includes(authType)
       ) as WalletInfoRemote;
 
-      console.log(wallets, currentWallet, 'ww');
-
       const link = tonConnectUI.connector.connect(
         {
           bridgeUrl: currentWallet.bridgeUrl,
@@ -133,13 +131,19 @@ export class TonWallet extends WalletBase<TonStoreType> {
     };
   }
 
-  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, '  '));
+  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);
     return signRes;
   }
 

package/src/airdrop/services/index.ts

@@ -70,14 +70,25 @@ export const getJettonInfo = async (
   return client.get(`/airdrop-open/jetton/${data.address}?isTestnet=${data.isTestnet}`);
 };
 
-export const connectTwitter = async (data: { code: string; redirectUri: string }, baseURL?: string) => {
+export const connectTwitter = async (
+  data: { code: string; projectId: string },
+  baseURL?: string
+): Promise<{ sid: string }> => {
   const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/connect-twitter', data);
+  return client.post('/airdrop-open/connect-twitter', data, {
+    headers: {
+      sid: window.localStorage.getItem('sid_' + data.projectId) || ''
+    }
+  });
 };
-
-export const checkEligibility = async (data: { projectId: string }, baseURL?: string) => {
+//{{ttApi}}/airdrop-open/check-eligibility
+export const checkEligibility = async (data: { projectId: string }, baseURL?: string): Promise<any> => {
   const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/check-eligibility', data);
+  return client.post('/airdrop-open/check-eligibility', data, {
+    headers: {
+      sid: window.localStorage.getItem('sid_' + data.projectId) || ''
+    }
+  });
 };
 
 export const bindWallet = async (
@@ -90,7 +101,11 @@ export const bindWallet = async (
     recipientType: string;
   },
   baseURL?: string
-) => {
+): Promise<{ sid: string }> => {
   const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/connect-wallet', data);
+  return client.post('/airdrop-open/connect-wallet', data, {
+    headers: {
+      sid: window.localStorage.getItem('sid_' + data.projectId) || ''
+    }
+  });
 };

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;
     }