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

package/src/airdrop/SignatureAirdropClient.ts

@@ -1,22 +1,33 @@
+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, connectTwitter, getAirdropProject } from './services';
-import { AirdropSigIdentityTypeEnum, IAirdropOptions, IProject } from './types';
+import {
+  bindWallet,
+  checkEligibility,
+  checkGetSignatures,
+  connectTwitter,
+  disconnectRecipient,
+  getAirdropProject
+} from './services';
+import {
+  AirdropSigIdentityTypeEnum,
+  ChainId,
+  IAirdropOptions,
+  IAirdropSignatureClaim,
+  IClaimSignature,
+  IProject,
+  IWalletClient
+} from './types';
 
 export class SignatureAirdropClient {
-  private slug?: string;
   private projectId?: string;
   private endpoint?: string;
   private project: IProject | undefined;
-  protected claims?: any[];
+  protected claims?: IAirdropSignatureClaim[];
   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;
-    }
+  constructor(params: IAirdropOptions) {
     this.projectId = params.projectId;
     this.endpoint = params.endpoint;
     if (this.project) {
@@ -26,6 +37,12 @@ export class SignatureAirdropClient {
     }
   }
 
+  private readonly LOCAL_STORAGE_SID_PREFIX = 'sid_';
+
+  private setSid(projectId: string, sid: string): void {
+    window.localStorage.setItem(`${this.LOCAL_STORAGE_SID_PREFIX}${projectId}`, sid);
+  }
+
   private async fetchProjectDetails(projectId: string): Promise<void> {
     this.project = await getAirdropProject(projectId, this.endpoint);
   }
@@ -56,13 +73,14 @@ 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);
-          onSuccess();
-          if (isError) {
-            onError();
+          const res = await connectTwitter({ code, projectId: project.id }, this.endpoint);
+
+          if (res?.sid) {
+            this.setSid(project.id, res?.sid);
           }
+          onSuccess();
         } catch (error) {
           onError();
         } finally {
@@ -84,37 +102,147 @@ 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 signResult = await wallet.signin(CONST.WELCOME_SIGNATURE_STATEMENT);
-
-      const { message, signature } = signResult || {};
-
+      await wallet.disconnect();
+      const timestamp = Date.now();
       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: Date.now(),
+        timestamp: timestamp,
         recipientType: recipientTypeMap[chainType]
       };
 
-      await bindWallet(payload, this.endpoint);
-      onSuccess();
+      const res = await bindWallet(payload, this.endpoint);
+      if (res?.sid) {
+        this.setSid(project.id, res?.sid);
+      }
+      onSuccess?.();
     } catch (error) {
-      onError(error);
-    } finally {
-      onSuccess();
+      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');
     }
+    const claimIds = this.claims?.map((it) => it.claimId);
+    return strategy.batchFetchClaimed(claimIds);
   }
 }

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

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

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

@@ -0,0 +1,56 @@
+import { EvmContractClientOption } from '../../../types';
+import ABI from './abis/FungibleTokenECDSADistributor.json';
+import { ContractBaseClient } from './ContractBaseClient';
+
+export class AirdropSignatureClient extends ContractBaseClient {
+  constructor(options: EvmContractClientOption) {
+    super({
+      ...options,
+      abi: ABI
+    });
+  }
+
+  async getClaimStatus(userClaimId: string) {
+    return this.readContract({ functionName: 'getClaimStatus', args: [userClaimId] });
+  }
+
+  async claim(
+    data: {
+      recipient: string;
+      data: string;
+      claimId: string;
+      signature: string;
+      extraData?: string;
+    }[],
+    value?: bigint
+  ) {
+    const [recipients = [], userClaimIds = [], datas = [], signatures = [], extraDatas = []] = [
+      'recipient',
+      'claimId',
+      'data',
+      'signature',
+      'extraData'
+    ].map((key) => data.map((item) => item[key as keyof (typeof data)[0]] || ''));
+
+    return this.writeContract({
+      functionName: 'claim',
+      args: [recipients, userClaimIds, datas, signatures, extraDatas],
+      value: value || 0n
+    });
+  }
+
+  async batchFetchClaimed(userClaimIds: string[]) {
+    const res = (await this.readContract({ functionName: 'getClaimStatus', args: [userClaimIds] })) as boolean[];
+    return res;
+  }
+
+  async getDeployer() {
+    const res = (await this.readContract({ functionName: 'getStorage' })) as any[];
+    return res?.[3] as string;
+  }
+
+  async getVersion() {
+    const res = (await this.readContract({ functionName: 'getStorage' })) as any[];
+    return res?.[0];
+  }
+}