@sign-global/tokentable 0.0.1

package/src/airdrop/common/projectDataForTon.ts

@@ -0,0 +1,79 @@
+export const projectDataForTon = {
+  ava: {
+    '12345': 'AD_18uwEPKbTXZo',
+    '67890': 'AD_XOPhRRGggtjK',
+    abcABC: 'AD_qKwG21hnimAB',
+    defDEF: 'AD_CfAV1GNekDAQ',
+    ghiGHI: 'AD_uwipChWywF4V',
+    jklJKL: 'AD_d3tai5RtikM2',
+    mnoMNO: 'AD_dMEF8ToRIqzY',
+    pqrPQR: 'AD_vdx6P5QHc1ES',
+    stuSTU: 'AD_2k77RlCRD1ds',
+    vwxVWX: 'AD_hiXx1hLsIkBM',
+    'yz-_YZ': 'AD_cj99f5rdUU8C'
+  },
+  dogs: {
+    '12': 'AD_P2ipWbDVrtSE',
+    '34': 'AD_cXW3IFfYHfa5',
+    '56': 'AD_NG5bNpQOHuqI',
+    '78': 'AD_KvnQeG76AgYs',
+    '90': 'AD_xlv2JO3PQdtR',
+    aA: 'AD_kc0CJE8RPvJy',
+    bB: 'AD_yRFzJyPoAOY4',
+    cC: 'AD_yN14YHi4F29p',
+    dD: 'AD_jWsTmtfnbzVn',
+    eE: 'AD_ZfFnjr06dhp7',
+    fF: 'AD_s58jwEK3EggA',
+    gG: 'AD_qKszLFxv5PDy',
+    hH: 'AD_RzefaG1fi44A',
+    iI: 'AD_LItldBE09QRn',
+    jJ: 'AD_SzKbQmVOz0S1',
+    kK: 'AD_rNrYIzCzye0W',
+    lL: 'AD_IbtlhoM0M6SZ',
+    mM: 'AD_m2NUNiwCgFES',
+    nN: 'AD_3mb6NTcYPw5y',
+    oO: 'AD_kVrO6qmmZDUK',
+    pP: 'AD_cV9g8YMQZ0iB',
+    qQ: 'AD_esdFer2shKO3',
+    rR: 'AD_BqZmJzFKapu0',
+    sS: 'AD_iOU6Rnltj3sx',
+    tT: 'AD_M8J1QU64Yuzi',
+    uU: 'AD_es9ceiuC8TXq',
+    vV: 'AD_7DXSpRcGivjO',
+    wW: 'AD_0uI9R6Sc6jY4',
+    xX: 'AD_FyrRNdtrgqKj',
+    yY: 'AD_JR0ktPVqVriT',
+    zZ: 'AD_bb9I2XdIqM6W',
+    '_-': 'AD_qaLi6r8K9BAv'
+  },
+  ava2: {
+    '1234567890_': 'AD_EZFWfhs641YQ',
+    'aAbBcCdDeE-': 'AD_jCVjsDT9g6h3',
+    fFgGhHiIjJ: 'AD_7nF9gncQeVW3',
+    kKlLmMnNoO: 'AD_RmoPsyKeIah0',
+    pPqQrRsStTZ: 'AD_zrK1RVGQ2Ogl',
+    uUvVwWxXyYz: 'AD_fKN6IcxEIdIA'
+  },
+  wat: {
+    '1234': 'AD_sMtwhyrqUFiZ',
+    '5678': 'AD_CMZVOHQjeVBp',
+    aAbB: 'AD_sdmcLLcDS59f',
+    cCdD: 'AD_M9Zyy7VaLuR1',
+    eEfF: 'AD_K4WWeUvk7aMj',
+    gGhH: 'AD_AmCnivdzxToB',
+    iIjJ: 'AD_2NgsKs5nyJhe',
+    kKlL: 'AD_IOPluo9KRSM9',
+    mMnN: 'AD_FMOlFAIOycQw',
+    oOpP: 'AD_NCW9yZdOTPQ9',
+    qQrR: 'AD_JjOkeBs0Jfsb',
+    sStT: 'AD_hUkWbwWMWUvp',
+    uUvV: 'AD_w9UAKxCxU84P',
+    wWxX: 'AD_Vwa41VRRXjpP',
+    yYzZ: 'AD_XQbS0ksJGDrB',
+    '90_-': 'AD_LhssByVDm8Q1'
+  },
+  roolz: {
+    abcdefghijklmnopqrstuvwxyz12345_: 'AD_3ZoF8wq7leAI',
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZ67890-': 'AD_HMFs2ubSrC1K'
+  }
+};

package/src/airdrop/constants/chain-config.ts

@@ -0,0 +1,102 @@
+import { CHAIN } from '@tonconnect/ui-react';
+import {
+  base,
+  baseSepolia,
+  cyber,
+  mainnet,
+  mantaTestnet,
+  polygonMumbai,
+  polygonAmoy,
+  sepolia,
+  zetachain,
+  zetachainAthensTestnet,
+  zkSync,
+  bsc,
+  berachainTestnet
+} from 'viem/chains';
+import { mevmDevNet, tonMainNet, tonTestNet } from './network';
+
+export const ChainConfig = {
+  [mainnet.id]: {
+    contractAddress: '0x0993Dd5384BcD116A3543889BC6ffA6C98948631',
+    rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/udrqNPSB6i5n5L6QSM31Ng72h_hFOrVT'
+  },
+  [bsc.id]: {
+    contractAddress: '0x6c241FF6d5c3f074b49aC10872770529d9e27BA4',
+    rpcUrl: 'https://bnb-mainnet.g.alchemy.com/v2/udrqNPSB6i5n5L6QSM31Ng72h_hFOrVT'
+  },
+  [base.id]: {
+    contractAddress: '0x3d1abcD56d53f7C8b04A753C6AF397903DC0f0F2',
+    rpcUrl: base.rpcUrls.default.http[0]
+  },
+  [cyber.id]: {
+    contractAddress: '0x7915dA247674E430b2a4Dcf01e4471f709428Bc0',
+    rpcUrl: cyber.rpcUrls.default.http[0]
+  },
+  [sepolia.id]: {
+    contractAddress: '0xf3f5243B35376c6dea04169983A8c853c8BE6d69',
+    rpcUrl: 'https://eth-sepolia.public.blastapi.io'
+  },
+  [baseSepolia.id]: {
+    contractAddress: '0x66c9fe5c76672B06Bf497eFfdaAfDf897D1e68d8',
+    rpcUrl: baseSepolia.rpcUrls.default.http[0]
+  },
+  [zetachainAthensTestnet.id]: {
+    contractAddress: '0x63aE2f2260DEfc11932d22410B976Ec29F54498B',
+    rpcUrl: zetachainAthensTestnet.rpcUrls.default.http[0]
+  },
+  [zetachain.id]: {
+    contractAddress: '0x00aFD4466E4Afa4F43cCd414b1BC65e574ACA2f5',
+    rpcUrl: 'https://zetachain-mainnet.g.alchemy.com/v2/1tmk0FrhwTJHXh0XIyae7_SXw1lDCjgs'
+  },
+  [berachainTestnet.id]: {
+    contractAddress: '',
+    rpcUrl: '',
+    availableSolutions: []
+  },
+  [polygonMumbai.id]: {
+    contractAddress: '',
+    rpcUrl: '',
+    availableSolutions: []
+  },
+  [polygonAmoy.id]: {
+    contractAddress: '',
+    rpcUrl: '',
+    availableSolutions: []
+  },
+  [mevmDevNet.id]: {
+    contractAddress: '0x8D92827CdB67A503e9FB21B28a58F9dAb36B4973',
+    rpcUrl: mevmDevNet.rpcUrls.default.http[0]
+  },
+  [CHAIN.TESTNET]: {
+    name: 'TestNet',
+    contractAddress: '',
+    rpcUrl: 'https://testnet.toncenter.com/api/v2/jsonRPC', //https://toncenter.com/api/v2/jsonRPC
+    tonApiPrefix: 'https://testnet.tonapi.io',
+    blockExplorer: 'https://testnet.tonviewer.com'
+  },
+  [CHAIN.MAINNET]: {
+    name: 'MainNet',
+    contractAddress: '',
+    rpcUrl: 'https://toncenter.com/api/v2/jsonRPC',
+    tonApiPrefix: 'https://tonapi.io',
+    blockExplorer: 'https://tonviewer.com'
+  }
+};
+
+export const SupportedChains = [
+  mainnet,
+  bsc,
+  base,
+  cyber,
+  sepolia,
+  baseSepolia,
+  zetachain,
+  zetachainAthensTestnet,
+  berachainTestnet,
+  polygonMumbai,
+  polygonAmoy,
+  mevmDevNet,
+  tonTestNet,
+  tonMainNet
+];

package/src/airdrop/constants/index.ts

@@ -0,0 +1,3 @@
+export * from './chain-config';
+
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';

package/src/airdrop/constants/network.ts

@@ -0,0 +1,78 @@
+import { CHAIN } from '@tonconnect/ui-react';
+import { defineChain } from 'viem';
+
+export const mevmDevNet = defineChain({
+  id: 30732,
+  name: 'Movement M1 Devnet',
+  network: 'mevm',
+  nativeCurrency: { name: 'Move', symbol: 'MOVE', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://mevm.devnet.imola.movementlabs.xyz']
+    },
+    public: {
+      http: ['https://mevm.devnet.imola.movementlabs.xyz']
+    }
+  },
+  blockExplorers: {
+    etherscan: { name: 'Arbiscan', url: 'https://explorer.devnet.imola.movementlabs.xyz/' },
+    default: { name: 'Arbiscan', url: 'https://explorer.devnet.imola.movementlabs.xyz/' }
+  },
+  contracts: {
+    multicall3: {
+      address: '0xD67Eca381AAbd0c049554f5714E7d8C21864c560',
+      blockCreated: 500
+    }
+  }
+});
+
+export const tonTestNet = {
+  id: CHAIN.TESTNET,
+  name: 'TON Testnet',
+  network: 'TON_TESTNET',
+  nativeCurrency: {
+    decimals: 9,
+    name: 'TON',
+    symbol: 'TON'
+  },
+  rpcUrls: {
+    public: {
+      http: []
+    },
+    default: {
+      http: []
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: 'tonviewer',
+      url: 'https://testnet.tonviewer.com'
+    }
+  },
+  testnet: true
+};
+
+export const tonMainNet = {
+  id: CHAIN.MAINNET,
+  name: 'TON Mainnet',
+  network: 'TON_MAINNET',
+  nativeCurrency: {
+    decimals: 9,
+    name: 'TON',
+    symbol: 'TON'
+  },
+  rpcUrls: {
+    public: {
+      http: []
+    },
+    default: {
+      http: []
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: 'tonviwer',
+      url: 'https://tonviewer.com'
+    }
+  }
+};

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

@@ -0,0 +1,182 @@
+import { AirdropV3Client } from './contracts/AirdropV3Client';
+import { FeeCollectorClient } from './contracts/FeeCollectorClient';
+import { DeployerClient } from './contracts/DeployClient';
+import { AirdropV3FeeClient } from './contracts/AirdropV3FeeClient';
+import { BigNumber } from 'bignumber.js';
+import { AirdropV4Client } from './contracts/AirdropV4Client';
+import { encodeAbiParameters } from 'viem';
+import { KycClientClient } from './contracts/KycClient';
+import { ZERO_ADDRESS } from '../../constants';
+import { EvmAirdropVersionEnum as AirdropVersionEnum, ChainId, EvmContractClientOption } from '../../types';
+
+export class AirdropService {
+  options: EvmContractClientOption;
+  constructor(options: EvmContractClientOption) {
+    this.options = options;
+  }
+
+  private get airdropV3Client(): AirdropV3Client {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new AirdropV3Client(this.options);
+  }
+
+  private get airdropV3FeeClient(): AirdropV3FeeClient {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new AirdropV3FeeClient(this.options);
+  }
+
+  private get airdropV4Client(): AirdropV4Client {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new AirdropV4Client(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 getKycClient() {
+    const claimHook = await this.airdropV4Client.getClaimHook();
+
+    return new KycClientClient({
+      ...this.options,
+      contractAddress: claimHook
+    });
+  }
+
+  async isLeafUsed(leaf: string): Promise<boolean> {
+    return this.airdropV3Client.isLeafUsed(leaf) as Promise<boolean>;
+  }
+
+  async batchFetchClaimed(leafs: string[]) {
+    return this.airdropV3Client.batchFetchClaimed(leafs) as Promise<{ result: boolean; status: string }[]>;
+  }
+
+  async claim({
+    proof,
+    group,
+    data,
+    value,
+    extraData
+  }: {
+    proof: string[];
+    group: string;
+    data: string;
+    value?: bigint;
+    extraData?: {
+      isLegacy: boolean;
+      attestationId: bigint;
+    };
+  }) {
+    const version = await this.getVersion();
+
+    console.log(version, 'version');
+    if (version === AirdropVersionEnum.V4) {
+      const encodeData = encodeAbiParameters(
+        [
+          {
+            type: 'tuple',
+            components: [
+              {
+                name: 'isLegacy',
+                type: 'bool'
+              },
+              {
+                name: 'attestationId',
+                type: 'uint'
+              }
+            ]
+          }
+        ],
+        [extraData!]
+      );
+      return this.airdropV4Client.claim({
+        proof,
+        group,
+        data,
+        value,
+        extraData: encodeData
+      });
+    }
+    return this.airdropV3Client.claim({
+      proof,
+      group,
+      data,
+      value
+    });
+  }
+
+  async getNFT() {
+    return this.airdropV3Client.getNFT();
+  }
+
+  async getVersion() {
+    return this.airdropV3Client.version();
+  }
+
+  async getDeployer() {
+    return this.airdropV3Client.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.airdropV3FeeClient.getFeelessThreshold();
+  }
+
+  async getClaimFee(address: string, tokenTransferred: 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, tokenTransferred);
+    const version = await this.getVersion();
+    if (version === AirdropVersionEnum.V3) {
+      const threshold = await this.getFeelessThreshold();
+      if (BigNumber(Number(tokenTransferred)).gt(BigNumber(Number(threshold)))) {
+        return fee;
+      } else {
+        return undefined;
+      }
+    }
+    return fee;
+  }
+
+  async getKycThreshold() {
+    const kycClient = await this.getKycClient();
+    return kycClient.kycThreshold();
+  }
+}

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

@@ -0,0 +1,37 @@
+import { EvmContractClientOption } from '../../../types';
+import AirdropAbi from './abis/AirdropV2.json';
+import { ContractBaseClient } from './ContractBaseClient';
+
+export class AirdropV2Client extends ContractBaseClient {
+  constructor(options: EvmContractClientOption) {
+    super({
+      ...options,
+      abi: AirdropAbi
+    });
+  }
+
+  async isLeafUsed(leaf: string) {
+    return this.readContract({ functionName: 'isLeafUsed', args: ['0x' + leaf] });
+  }
+
+  async claim(proof: string[], group: string, data: string, value?: bigint) {
+    return this.writeContract({
+      functionName: 'claim',
+      args: [proof, group, data],
+      value: value || 0n
+    });
+  }
+
+  async batchFetchClaimed(leafs: string[]) {
+    return this.multiCall({
+      contracts: leafs?.map((leaf) => {
+        return {
+          address: this.contractAddress,
+          abi: this.abi,
+          functionName: 'isLeafUsed',
+          args: ['0x' + leaf]
+        };
+      })
+    });
+  }
+}

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

@@ -0,0 +1,49 @@
+import { EvmContractClientOption } from '../../../types';
+import AirdropAbi from './abis/AirdropV3.json';
+import { ContractBaseClient } from './ContractBaseClient';
+
+export class AirdropV3Client extends ContractBaseClient {
+  constructor(options: EvmContractClientOption) {
+    super({
+      ...options,
+      abi: options.abi || AirdropAbi
+    });
+  }
+
+  async isLeafUsed(leaf: string) {
+    return this.readContract({ functionName: 'isLeafUsed', args: ['0x' + leaf] });
+  }
+
+  async claim({ proof, group, data, value }: { proof: string[]; group: string; data: string; value?: bigint }) {
+    return this.writeContract({
+      functionName: 'claim',
+      args: [proof, group, data],
+      value: value || 0n
+    });
+  }
+
+  async batchFetchClaimed(leafs: string[]) {
+    return this.multiCall({
+      contracts: leafs?.map((leaf) => {
+        return {
+          address: this.contractAddress,
+          abi: this.abi,
+          functionName: 'isLeafUsed',
+          args: ['0x' + leaf]
+        };
+      })
+    });
+  }
+
+  async getNFT() {
+    return this.readContract({ functionName: 'getNFT' });
+  }
+
+  async version() {
+    return this.readContract({ functionName: 'version' }) as Promise<string>;
+  }
+
+  async getDeployer() {
+    return this.readContract({ functionName: 'getDeployer' }) as Promise<string>;
+  }
+}

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

@@ -0,0 +1,16 @@
+import { EvmContractClientOption } from '../../../types';
+import AirdropAbi from './abis/AirdropV3_Fee.json';
+import { ContractBaseClient } from './ContractBaseClient';
+
+export class AirdropV3FeeClient extends ContractBaseClient {
+  constructor(options: EvmContractClientOption) {
+    super({
+      ...options,
+      abi: options.abi || AirdropAbi
+    });
+  }
+
+  async getFeelessThreshold() {
+    return this.readContract({ functionName: 'getFeelessThreshold' });
+  }
+}

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

@@ -0,0 +1,36 @@
+import { EvmContractClientOption } from '../../../types';
+import AirdropAbi from './abis/CustomFeeNativeAirdropV4.json';
+import { AirdropV3Client } from './AirdropV3Client';
+
+export class AirdropV4Client extends AirdropV3Client {
+  constructor(options: EvmContractClientOption) {
+    super({
+      ...options,
+      abi: options.abi || AirdropAbi
+    });
+  }
+
+  async claim({
+    proof,
+    group,
+    data,
+    value,
+    extraData
+  }: {
+    proof: string[];
+    group: string;
+    data: string;
+    value?: bigint;
+    extraData?: string;
+  }) {
+    return this.writeContract({
+      functionName: 'claim',
+      args: [proof, group, data, extraData],
+      value: value || 0n
+    });
+  }
+
+  async getClaimHook() {
+    return this.readContract({ functionName: 'getClaimHook' }) as Promise<string>;
+  }
+}

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

@@ -0,0 +1,85 @@
+import {
+  Chain,
+  createPublicClient,
+  http,
+  PublicClient,
+  WalletClient,
+  createWalletClient,
+  MulticallParameters
+} from 'viem';
+import { getChainById, getChainRpc } from '../../../common';
+import { ChainId } from '../../../types';
+
+export class ContractBaseClient {
+  contractAddress: string;
+  chainId: ChainId;
+  connector?: WalletClient;
+  abi: any;
+  chain: Chain;
+  chainRpc: string;
+
+  constructor({
+    contractAddress,
+    chainId,
+    walletClient,
+    abi
+  }: {
+    contractAddress: string;
+    chainId: ChainId;
+    walletClient?: WalletClient;
+    abi: any;
+  }) {
+    this.contractAddress = contractAddress;
+    this.chainId = chainId;
+    this.connector = walletClient;
+    this.abi = abi;
+    this.chain = getChainById(chainId) as any;
+    this.chainRpc = getChainRpc(chainId);
+  }
+
+  protected get publicClient(): PublicClient {
+    return createPublicClient({
+      chain: this.chain,
+      transport: http(this.chainRpc)
+    }) as any;
+  }
+
+  protected get walletClient(): WalletClient {
+    return (
+      this.walletClient ||
+      createWalletClient({
+        chain: this.chain,
+        transport: http(this.chainRpc)
+      })
+    );
+  }
+
+  async readContract({ functionName, args }: { functionName: string; args?: any }) {
+    const result = await this.publicClient.readContract({
+      abi: this.abi,
+      address: this.contractAddress as `0x${string}`,
+      functionName: functionName,
+      args: args
+    });
+
+    return result;
+  }
+
+  async writeContract({ functionName, args, value }: { functionName: string; args?: any; value?: bigint }) {
+    const { request } = await this.publicClient.simulateContract({
+      abi: this.abi,
+      address: this.contractAddress as `0x${string}`,
+      functionName: functionName,
+      args: args,
+      account: this.walletClient?.account,
+      value: value
+    });
+    const result = await this.walletClient.writeContract(request);
+
+    return result;
+  }
+
+  async multiCall(parameters: MulticallParameters<any[], boolean>) {
+    return await this.publicClient.multicall(parameters);
+  }
+}