@sign-global/tokentable 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sign-global/tokentable",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "publishConfig": {
     "access": "public"
   },
@@ -11,7 +11,8 @@
   "scripts": {
     "build-cjs": "tsc -m commonjs --outDir dist/cjs",
     "build-esm": "tsc -m esnext --outDir dist/esm",
-    "build": "pnpm run build-cjs && pnpm run build-esm"
+    "build": "pnpm run build-cjs && pnpm run build-esm",
+    "test": "jest"
   },
   "author": "Evan",
   "license": "ISC",
@@ -20,10 +21,13 @@
     "@ton/core": "^0.59.0",
     "@ton/ton": "^15.1.0",
     "@tonconnect/ui-react": "^2.0.9",
+    "@types/jest": "^29.5.14",
     "bignumber.js": "^9.1.2",
     "dayjs": "^1.11.13",
+    "jest": "^29.7.0",
     "tonapi-sdk-js": "^2.0.3",
     "tonweb": "^0.0.66",
+    "ts-jest": "^29.2.5",
     "viem": "^2.21.49",
     "wagmi": "^2.13.0"
   },

package/src/airdrop/common/index.ts

@@ -31,7 +31,7 @@ export const getTonProjectIdByAddress = ({
   slug,
   data
 }: {
-  address: string;
+  address?: string;
   slug: string;
   data: Record<string, string>;
 }): string | undefined => {
@@ -39,6 +39,11 @@ export const getTonProjectIdByAddress = ({
   if (!project) {
     project = data;
   }
+
+  if (!address) {
+    const firstProject = Object.values(project)[0];
+    return firstProject;
+  }
   const lastText = address[address.length - 1];
 
   const group = Object.keys(project || {}).find((key) => key.includes(lastText));

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

@@ -94,7 +94,6 @@ export class AirdropService {
   }) {
     const version = await this.getVersion();
 
-    console.log(version, 'version');
     if (version === AirdropVersionEnum.V4) {
       const encodeData = encodeAbiParameters(
         [

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

@@ -46,7 +46,7 @@ export class ContractBaseClient {
 
   protected get walletClient(): WalletClient {
     return (
-      this.walletClient ||
+      this.connector ||
       createWalletClient({
         chain: this.chain,
         transport: http(this.chainRpc)

package/src/airdrop/core/ton/AirdropClientV2.ts

@@ -64,7 +64,7 @@ export class TonAirdropClientV2 extends TonContractBaseClient {
     };
   }
 
-  claim = async (claimData: IAirdropClaim, options: { onLoading?: () => void }) => {
+  claim = async (claimData: IAirdropClaim, options?: { onLoading?: () => void }) => {
     const provider = await this.getTonClient();
     const airdropContract = await this.getAirdropContract();
     const index = BigInt(claimData.index);
@@ -84,7 +84,7 @@ export class TonAirdropClientV2 extends TonContractBaseClient {
     );
 
     leaf.sendClaim(this.connection.senderDeploy, proof, index, claimFee);
-    const res = await this.waitForTransaction(options.onLoading);
+    const res = await this.waitForTransaction(options?.onLoading);
     if (res) {
       console.log(res, res.event_id, 'res');
     }

package/src/airdrop/core/ton/AirdropClientV3.ts

@@ -65,7 +65,7 @@ export class TonAirdropClientV3 extends TonContractBaseClient {
     };
   }
 
-  claim = async (claimData: IAirdropClaim, options: { onLoading?: () => void }) => {
+  claim = async (claimData: IAirdropClaim, options?: { onLoading?: () => void }) => {
     // const { provider, airdropContract, claimFee, leafAddress } = prepreData;
     const provider = await this.getTonClient();
     const airdropContract = await this.getAirdropContract();
@@ -87,7 +87,7 @@ export class TonAirdropClientV3 extends TonContractBaseClient {
     );
 
     leaf.sendClaim(this.connection.senderDeploy, proof, index, claimFee);
-    const res = await this.waitForTransaction(options.onLoading);
+    const res = await this.waitForTransaction(options?.onLoading);
 
     // while (!(await provider.isContractDeployed(leafAddress))) {
     //   console.log('waiting for leaf to deploy');

package/src/airdrop/core/ton/AirdropService.ts

@@ -86,7 +86,7 @@ export class AirdropService {
     return client.getAirdropContract();
   }
 
-  async claim(claimData: IAirdropClaim, options: { onLoading?: () => void }) {
+  async claim(claimData: IAirdropClaim, options?: { onLoading?: () => void }) {
     const client = await this.getClient();
     return client.claim(claimData, options);
   }

package/src/airdrop/index.ts

@@ -3,7 +3,16 @@ import { TonConnectUI } from '@tonconnect/ui-react';
 import { AirdropService as TonAirdropService } from './core/ton/AirdropService';
 import { AirdropService as EvmAirdropService } from './core/evm/AirdropService';
 import { getAirdropPro, getAirdropProject, getAirdropQuery } from './services';
-import { ChainId, ChainType, IAirdropClaim, IAirdropOptions, IProject, IWalletClient } from './types';
+import {
+  ChainId,
+  ChainType,
+  ETokenType,
+  EvmAirdropVersionEnum,
+  IAirdropClaim,
+  IAirdropOptions,
+  IProject,
+  IWalletClient
+} from './types';
 import { getTonProjectIdByAddress } from './common';
 import { WalletClient as ViemWalletClient } from 'viem';
 
@@ -14,8 +23,11 @@ export class AirdropClient {
   private endpoint?: string;
   private project: IProject | undefined;
   protected claims?: IAirdropClaim[];
-  private contractInstance: TonAirdropService | EvmAirdropService | undefined;
+  private contractInstanceWithWallet: TonAirdropService | EvmAirdropService | undefined;
+  private contractInstanceWithoutWallet: TonAirdropService | EvmAirdropService | undefined;
   private projectPromise: Promise<void> | undefined;
+  private claimHook: ((v: any) => any) | undefined;
+  private cachedVersion: string | null = null;
 
   constructor(params: IAirdropOptions) {
     if ('slug' in params) {
@@ -31,14 +43,10 @@ export class AirdropClient {
     let projectId: string | undefined = this.projectId;
     if (this.slug) {
       const res = await getAirdropPro(this.slug, this.endpoint);
-      const projectMap = res?.childProjectMapping;
+      const projectMap = res?.childProjectMapping || {};
 
       let legacyProjectId: string | undefined;
-      if (!address) {
-        legacyProjectId = Object.values(projectMap)[0];
-      } else {
-        legacyProjectId = getTonProjectIdByAddress({ address, slug: this.slug, data: projectMap });
-      }
+      legacyProjectId = getTonProjectIdByAddress({ address, slug: this.slug, data: projectMap });
 
       if (legacyProjectId) {
         projectId = legacyProjectId;
@@ -49,7 +57,6 @@ export class AirdropClient {
   }
 
   async getProjectInfo() {
-    console.log(this.projectPromise);
     await this.projectPromise;
     if (!this.project) throw new Error('Project not found');
     return this.project;
@@ -75,30 +82,46 @@ export class AirdropClient {
     return this.claims;
   }
 
-  async getAirdropContractWrapper(options: {
+  async getAirdropContractWrapper(options?: {
     walletClient?: IWalletClient;
-    tonClient?: TonClient;
   }): Promise<TonAirdropService | EvmAirdropService> {
-    if (!this.contractInstance) {
-      const project = await this.getProjectInfo();
-
-      const instance =
-        project.chainType === ChainType.Evm
-          ? new EvmAirdropService({
-              contractAddress: project.contractAddress,
-              chainId: Number(project.chainId) as ChainId,
-              walletClient: options.walletClient as ViemWalletClient
-            })
-          : new TonAirdropService({
-              chainId: project.chainId.toString(),
-              address: project.contractAddress,
-              walletClient: options.walletClient as TonConnectUI,
-              tonClient: this.tonClient
-            });
-      this.contractInstance = instance;
-    }
+    const project = await this.getProjectInfo();
 
-    return this.contractInstance!;
+    if (options?.walletClient) {
+      if (!this.contractInstanceWithWallet) {
+        const instance =
+          project.chainType === ChainType.Evm
+            ? new EvmAirdropService({
+                contractAddress: project.contractAddress,
+                chainId: Number(project.chainId) as ChainId,
+                walletClient: options.walletClient as ViemWalletClient
+              })
+            : new TonAirdropService({
+                chainId: project.chainId.toString(),
+                address: project.contractAddress,
+                walletClient: options.walletClient as TonConnectUI,
+                tonClient: this.tonClient
+              });
+        this.contractInstanceWithWallet = instance;
+      }
+      return this.contractInstanceWithWallet;
+    } else {
+      if (!this.contractInstanceWithoutWallet) {
+        const instance =
+          project.chainType === ChainType.Evm
+            ? new EvmAirdropService({
+                contractAddress: project.contractAddress,
+                chainId: Number(project.chainId) as ChainId
+              })
+            : new TonAirdropService({
+                chainId: project.chainId.toString(),
+                address: project.contractAddress,
+                tonClient: this.tonClient
+              });
+        this.contractInstanceWithoutWallet = instance;
+      }
+      return this.contractInstanceWithoutWallet;
+    }
   }
 
   private getClaimDataById(claimId: string) {
@@ -107,26 +130,55 @@ export class AirdropClient {
     return claimData;
   }
 
+  setClaimHook(fn: (v: any) => any) {
+    this.claimHook = fn;
+  }
+
   async claimAirdrop(
     { claimId, walletClient }: { claimId: string; walletClient: IWalletClient },
-    options: { onLoading?: () => void }
+    options?: { onLoading?: () => void }
   ) {
     const claimData = this.getClaimDataById(claimId);
+    const project = await this.getProjectInfo();
 
     const contractWrapper = await this.getAirdropContractWrapper({
       walletClient
     });
 
-    return contractWrapper.claim(claimData, options);
+    if (project.chainType === ChainType.Evm) {
+      const version = await contractWrapper.getVersion();
+      const needsFeeData = !(
+        project.tokenType === ETokenType.Native &&
+        [EvmAirdropVersionEnum.V3, EvmAirdropVersionEnum.V4].includes(version as EvmAirdropVersionEnum)
+      );
+
+      const value = needsFeeData ? await this.getClaimFee(BigInt(claimData.amount)) : undefined;
+
+      let extraData = {
+        isLegacy: true,
+        attestationId: BigInt(1)
+      };
+      if (this.claimHook) {
+        extraData = this.claimHook(claimData);
+      }
+
+      return (contractWrapper as EvmAirdropService).claim({
+        proof: claimData.proof,
+        group: claimData.group,
+        data: claimData.data,
+        value: value as bigint | undefined,
+        extraData: extraData
+      });
+    }
+
+    return (contractWrapper as TonAirdropService).claim(claimData, options);
   }
 
   async checkClaimed(claimId: string): Promise<boolean> {
     const claimData = this.getClaimDataById(claimId);
     const project = await this.getProjectInfo();
 
-    const contractWrapper = await this.getAirdropContractWrapper({
-      tonClient: this.tonClient
-    });
+    const contractWrapper = await this.getAirdropContractWrapper();
 
     if (project.chainType === ChainType.Evm) {
       return (contractWrapper as EvmAirdropService).isLeafUsed(claimData.leaf);
@@ -137,9 +189,7 @@ export class AirdropClient {
 
   async getPaused() {
     const project = await this.getProjectInfo();
-    const contractWrapper = await this.getAirdropContractWrapper({
-      tonClient: this.tonClient
-    });
+    const contractWrapper = await this.getAirdropContractWrapper();
     if (project.chainType === ChainType.Evm) {
       throw new Error('EVM chain is not supported');
     }
@@ -147,29 +197,57 @@ export class AirdropClient {
   }
 
   async getVersion() {
-    const contractWrapper = await this.getAirdropContractWrapper({
-      tonClient: this.tonClient
-    });
-    return contractWrapper?.getVersion();
+    if (this.cachedVersion) {
+      return this.cachedVersion;
+    }
+    const contractWrapper = await this.getAirdropContractWrapper();
+
+    this.cachedVersion = await contractWrapper?.getVersion();
+    return this.cachedVersion;
   }
 
-  async batchFetchClaimed(leafs: string[]) {
+  async batchCheckClaimed() {
     const project = await this.getProjectInfo();
 
     if (project.chainType === ChainType.Ton) {
       throw new Error('TON chain is not supported');
     }
 
-    const contractWrapper = await this.getAirdropContractWrapper({});
+    const contractWrapper = await this.getAirdropContractWrapper();
+    const leafs = this.claims?.map((it) => it.leaf);
+
+    if (!leafs) return [];
 
     return (contractWrapper as EvmAirdropService).batchFetchClaimed(leafs);
   }
 
-  async getClaimFee(amount: bigint) {
+  async getNFT() {
+    const project = await this.getProjectInfo();
+
+    if (project.chainType === ChainType.Ton) {
+      throw new Error('TON chain is not supported');
+    }
+
+    const contractWrapper = await this.getAirdropContractWrapper();
+
+    return (contractWrapper as EvmAirdropService).getNFT();
+  }
+
+  async getKycThreshold() {
+    const project = await this.getProjectInfo();
+
+    if (project.chainType === ChainType.Ton) {
+      throw new Error('TON chain is not supported');
+    }
+    const contractWrapper = await this.getAirdropContractWrapper();
+    return (contractWrapper as EvmAirdropService).getKycThreshold();
+  }
+
+  async getClaimFee(amount?: bigint) {
     const project = await this.getProjectInfo();
 
     const contractWrapper = await this.getAirdropContractWrapper({});
 
-    return contractWrapper.getClaimFee(project.contractAddress, amount);
+    return contractWrapper.getClaimFee(project.contractAddress, amount || BigInt(1));
   }
 }

package/src/airdrop/tests/index.test.ts

@@ -0,0 +1,95 @@
+import { AirdropClient } from '../index';
+import { TonClient } from '@ton/ton';
+
+describe('AirdropClient', () => {
+  let client: AirdropClient;
+  const mockTonClient = new TonClient({
+    endpoint: 'https://testnet.toncenter.com/api/v2/jsonRPC'
+  });
+  const mockEndpoint = 'http://ec2-3-89-178-45.compute-1.amazonaws.com:3030/api';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('initialize', () => {
+    it('should use projectId correctly', async () => {
+      client = new AirdropClient({
+        projectId: 'AD_TEV94wvkxkvn',
+        endpoint: mockEndpoint
+      });
+
+      const projectInfo = await client.getProjectInfo();
+      expect(projectInfo).toBeDefined();
+    });
+
+    it('should use slug correctly', async () => {
+      client = new AirdropClient({
+        slug: 'wat',
+        tonClient: mockTonClient
+      });
+
+      const projectInfo = await client.getProjectInfo();
+      expect(projectInfo).toBeTruthy();
+    });
+  });
+
+  describe('test main features', () => {
+    beforeEach(async () => {
+      client = new AirdropClient({
+        projectId: 'AD_TEV94wvkxkvn',
+        endpoint: mockEndpoint
+      });
+    });
+
+    it('should get version', async () => {
+      const version = await client.getVersion();
+      console.log(version);
+      expect(version).toBeDefined();
+    });
+
+    it('should get claim fee', async () => {
+      const client = new AirdropClient({
+        projectId: 'AD_50lczFu9Yhvq',
+        endpoint: mockEndpoint
+      });
+      const fee = await client.getClaimFee();
+      console.log(fee);
+      expect(fee).toBeDefined();
+    });
+
+    it('should get airdrop claims', async () => {
+      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
+      expect(claims).toBeTruthy();
+      expect(claims?.length).toBe(1);
+    });
+
+    it('should check claimed', async () => {
+      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
+
+      const claimed = await client.checkClaimed(claims?.[0].claimId as string);
+      expect(claimed).toBeDefined();
+    });
+  });
+
+  //   describe('catch error', () => {
+  //     it('throw error when projectId is not provided', async () => {
+  //       client = new AirdropClient({
+  //         tonClient: mockTonClient,
+  //         endpoint: mockEndpoint
+  //       });
+
+  //       await expect(client.getProjectInfo()).rejects.toThrow('Project ID is required');
+  //     });
+
+  //     it('throw error when claim data not found', async () => {
+  //       client = new AirdropClient({
+  //         projectId: 'project-1',
+  //         tonClient: mockTonClient,
+  //         endpoint: mockEndpoint
+  //       });
+
+  //       await expect(client.checkClaimed('invalid-claim-id')).rejects.toThrow('Claim data not found');
+  //     });
+  //   });
+});

package/src/airdrop/types/index.ts

@@ -19,6 +19,32 @@ export enum ChainType {
   Ton = 'ton'
 }
 
+export type ThemeConfig = {
+  logo: string;
+  title: string;
+  description: string;
+  coverImage: string;
+  subTitle: string;
+  primaryColor: string;
+  secondaryColor: string;
+  buttonPrimaryHover: string;
+  buttonSecondaryHover: string;
+  buttonPrimaryForeground: string;
+  buttonSecondaryForeground: string;
+  welcomeModalText: string;
+  welcomeModalTitle: string;
+  isShowWelcomeModal: boolean;
+  blockCountries: string;
+  termsOfUse: string;
+  successModalPrimaryBtnText: string;
+  successModalUrl: string;
+  successModalTitle: string;
+  successModalDesc: string;
+  successModalShareTexts: string;
+  isUnAvailable: boolean;
+  privacyPolicy: string;
+};
+
 export interface IProject {
   id: string;
   name: string;
@@ -33,7 +59,7 @@ export interface IProject {
   merkleRoot: string;
   ownerAddress: string;
   blockCountries: Record<string, string>;
-  themeConf: Record<string, any>;
+  themeConf: ThemeConfig | null;
   version: string;
   extra?: {
     kyc: boolean;
@@ -41,6 +67,12 @@ export interface IProject {
   };
 }
 
+export enum ETokenType {
+  Erc20 = 'ERC20',
+  Native = 'NATIVE_TOKEN',
+  NFT = 'ERC721'
+}
+
 export type IAirdropClaim = {
   index: number;
   recipient: string;

package/src/index.ts

@@ -1 +1,2 @@
 export { AirdropClient } from './airdrop';
+export * from './airdrop/types';