@sign-global/tokentable 0.4.2-beta.2 → 0.4.2-beta.4

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

@@ -1,181 +0,0 @@
-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();
-
-    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, 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);
-    const version = await this.getVersion();
-    if (version === AirdropVersionEnum.V3) {
-      const threshold = await this.getFeelessThreshold();
-      if (BigNumber(Number(amount)).gt(BigNumber(Number(threshold)))) {
-        return fee;
-      } else {
-        return undefined;
-      }
-    }
-    return fee;
-  }
-
-  async getKycThreshold() {
-    const kycClient = await this.getKycClient();
-    return kycClient.kycThreshold();
-  }
-}

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

@@ -1,114 +0,0 @@
-import { getAddress } from 'viem';
-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';
-import { AirdropSignatureFeeClient } from './contracts/AirdropSignatureFeeClient';
-
-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);
-  }
-  private get airdropWithFeeClient(): AirdropSignatureFeeClient {
-    if (!this.options) {
-      throw new Error('options is empty');
-    }
-
-    return new AirdropSignatureFeeClient(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 getPaused() {
-    return this.airdropClient.getPaused();
-  }
-
-  async claim(
-    data: {
-      recipient: string;
-      claimId: string;
-      data: string;
-      signature: string;
-      fees?: string;
-      extraData?: string;
-    }[],
-    recipient?: string
-  ) {
-    const version = await this.getVersion();
-
-    if (version.includes('FungibleTokenWithFeesECDSADistributor')) {
-      const totalFees = data.map((item) => BigInt(item.fees || '0')).reduce((sum, fee) => sum + fee, BigInt(0));
-      return this.airdropWithFeeClient.claim(data, totalFees);
-    }
-    const defaultRecipient = this.options.walletClient?.account?.address;
-    const delegateMode = recipient ? getAddress(recipient) !== defaultRecipient : false;
-    const feeData = (await this.getClaimFee(this.options.contractAddress, 1n)) || 0n;
-    const value = delegateMode ? feeData * BigInt(data.length) : feeData;
-    return this.airdropClient.claim(data, value);
-  }
-}

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

@@ -1,63 +0,0 @@
-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]] || ''));
-
-    console.log('params', [recipients, userClaimIds, datas, signatures, extraDatas], value);
-
-    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];
-  }
-
-  async getPaused() {
-    const res = (await this.readContract({ functionName: 'getStorage' })) as any[];
-    return res?.[2] as boolean;
-  }
-}

package/src/airdrop/contracts/evm/contracts/AirdropSignatureFeeClient.ts

@@ -1,61 +0,0 @@
-import { EvmContractClientOption } from '../../../types';
-import ABI from './abis/FungibleTokenWithFeesECDSADistributor.json';
-import { ContractBaseClient } from './ContractBaseClient';
-
-export class AirdropSignatureFeeClient 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];
-  }
-
-  async getPaused() {
-    const res = (await this.readContract({ functionName: 'getStorage' })) as any[];
-    return res?.[2] as boolean;
-  }
-}

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

@@ -1,37 +0,0 @@
-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/contracts/evm/contracts/AirdropV3Client.ts

@@ -1,49 +0,0 @@
-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/contracts/evm/contracts/AirdropV3FeeClient.ts

@@ -1,16 +0,0 @@
-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/contracts/evm/contracts/AirdropV4Client.ts

@@ -1,36 +0,0 @@
-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/contracts/evm/contracts/ContractBaseClient.ts

@@ -1,85 +0,0 @@
-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.connector ||
-      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);
-  }
-}

package/src/airdrop/contracts/evm/contracts/DeployClient.ts

@@ -1,35 +0,0 @@
-import { EvmContractClientOption } from '../../../types';
-import TTUDeployerContractABI from './abis/Deployer.json';
-import { ContractBaseClient } from './ContractBaseClient';
-
-export class DeployerClient extends ContractBaseClient {
-  constructor(options: EvmContractClientOption) {
-    const address = options.contractAddress;
-
-    if (!address) {
-      throw new Error(`TTDeployerContract address not found on chain ${options.chainId}`);
-    }
-    super({
-      abi: TTUDeployerContractABI.abi,
-      contractAddress: address,
-      chainId: options.chainId,
-      walletClient: options.walletClient
-    });
-  }
-
-  async feeCollectors(address: string) {
-    const result = await this.readContract({
-      functionName: 'feeCollectors',
-      args: [address]
-    });
-    return result;
-  }
-
-  async feeTokens(address: string) {
-    const result = await this.readContract({
-      functionName: 'feeTokens',
-      args: [address]
-    });
-    return result;
-  }
-}

package/src/airdrop/contracts/evm/contracts/FeeCollectorClient.ts

@@ -1,21 +0,0 @@
-import { EvmContractClientOption } from '../../../types';
-import FeeCollectorABI from './abis/FeeCollector.json';
-import { ContractBaseClient } from './ContractBaseClient';
-
-export class FeeCollectorClient extends ContractBaseClient {
-  constructor(options: EvmContractClientOption) {
-    const address = options.contractAddress;
-    if (!address) {
-      throw new Error(`FeeCollectorService address not found on chain ${options.chainId}`);
-    }
-    super({
-      ...options,
-      contractAddress: address,
-      abi: FeeCollectorABI
-    });
-  }
-
-  async getFee(address: string, tokenTransferred: bigint): Promise<bigint> {
-    return (await this.readContract({ functionName: 'getFee', args: [address, tokenTransferred] })) as bigint;
-  }
-}