@sabaaa1/common 0.0.1

package/src/data-structures/merkle-tree/MerkleTree.ts

@@ -0,0 +1,253 @@
+import { CIRCOM_MERKLE_LENGTH, MERKLE_LEVELS } from '../../constants/protocol.constants';
+import { logError } from '../../error-handling/logError';
+import { MerkleTreeIncompleteError } from './MerkleTreeIncompleteError';
+
+export type MerkleTreeJson = {
+  tree: Record<string, string>;
+  reverseTree?: Record<string, string>;
+  count: string;
+  index: string;
+};
+
+/**
+ * Merkle tree implementation that allows the user to insert in specific places in the tree
+ *
+ */
+export class MerkleTree<T> {
+  /**
+   * the map where the items are stored
+   */
+  private readonly tree;
+
+  /**
+   * amount of elements inserted inside the bottom row of the tree
+   */
+  private count: bigint;
+
+  /**
+   * the maximum index inserted into the tree
+   * used together with count to make sure that the merkle tree is complete.
+   * meaning that there aren't any missing elements between getStartIndex() and index
+   */
+  private index: bigint;
+
+  private reverseTree;
+
+  public static createWithData<T>(
+    tree: Map<bigint, T>,
+    reverseTree: Map<T, bigint> | undefined,
+    index: bigint,
+    count: bigint,
+    hashFunction: (a: T, b: T) => T,
+    levels: bigint,
+    defaultNodeValue: T,
+  ): MerkleTree<T> {
+    const merkleTree = new MerkleTree(hashFunction, levels, defaultNodeValue, tree, reverseTree, index, count);
+    return merkleTree;
+  }
+
+  /**
+   * @param hashFunction the hashFunction used to fill the upper layers of the merkle tree
+   * @param levels the amount of layers in the merkle tree
+   * @param defaultNodeValue the default value of an empty node in the merkle tree
+   */
+  public static create<T>(
+    hashFunction: (a: T, b: T) => T,
+    defaultNodeValue: T,
+    levels: bigint = MERKLE_LEVELS,
+  ): MerkleTree<T> {
+    return new MerkleTree<T>(hashFunction, levels, defaultNodeValue);
+  }
+
+  private createReverseTree() {
+    const reverseTree = new Map<T, bigint>();
+
+    for (let i = this.getStartIndex(); i < this.getStartIndex() + this.count; i += 1n) {
+      const item = this.tree.get(i);
+      if (item !== undefined) reverseTree.set(item, i);
+    }
+
+    return reverseTree;
+  }
+
+  private constructor(
+    private hashFunction: (a: T, b: T) => T,
+    private levels: bigint,
+    private defaultNodeValue: T,
+    tree?: Map<bigint, T>,
+    reverseTree?: Map<T, bigint>,
+    index?: bigint,
+    count?: bigint,
+  ) {
+    this.tree = tree ?? new Map<bigint, T>();
+    this.count = count ?? 0n;
+    this.index = index ?? 2n ** (levels - 1n);
+    if (reverseTree) this.reverseTree = reverseTree;
+    else this.reverseTree = this.createReverseTree();
+  }
+
+  /**
+   * get starting nodeIndex from which inserts are allowed
+   */
+  public getStartIndex() {
+    return 2n ** (this.levels - 1n);
+  }
+
+  /**
+   * implementation of logarithm2 function from merkle contract
+   */
+  logarithm2(a: bigint) {
+    let i = 0n;
+    while (2n ** i < a) i += 1n;
+    return i;
+  }
+
+  bigIntMax(a: bigint, b: bigint) {
+    return a > b ? a : b;
+  }
+
+  private forceInsert(value: T, nodeIndex: bigint) {
+    if (nodeIndex < this.getStartIndex()) {
+      throw new RangeError();
+    }
+
+    this.tree.set(nodeIndex, value);
+    this.reverseTree.set(value, nodeIndex);
+
+    const fullCount = this.index - this.getStartIndex();
+    const twoPower = this.logarithm2(fullCount);
+    let currentNodeIndex = nodeIndex;
+    for (let i = 1n; i <= twoPower; i += 1n) {
+      currentNodeIndex /= 2n;
+      const result = this.hashFunction(
+        this.tree.get(currentNodeIndex * 2n) || this.defaultNodeValue,
+        this.tree.get(currentNodeIndex * 2n + 1n) || this.defaultNodeValue,
+      );
+      this.tree.set(currentNodeIndex, result);
+    }
+  }
+
+  /**
+   * insert value into the merkle tree
+   * @param value the value to insert
+   * @param nodeIndex the index to insert the value, you can get starting index from getStartIndex()
+   * @return true - if added, false - if already exists
+   * @throws will throw RangeError if nodeIndex is less than getStartIndex()
+   */
+  insert(value: T, nodeIndex: bigint): boolean {
+    let hasIndex = false;
+    if (this.tree.has(nodeIndex)) {
+      hasIndex = true;
+      logError(`Editing commitment index: ${nodeIndex} `);
+    }
+    if (!hasIndex) {
+      this.count += 1n;
+    }
+    this.index = this.bigIntMax(this.index, nodeIndex + 1n); // if you plugged after index, update index, if you plugged before than keep index
+
+    this.forceInsert(value, nodeIndex);
+    return true;
+  }
+
+  remove(nodeIndex: bigint) {
+    this.forceInsert(this.defaultNodeValue, nodeIndex);
+  }
+
+  private completenessCheck() {
+    if (this.count !== this.index - this.getStartIndex()) {
+      throw new MerkleTreeIncompleteError();
+    }
+  }
+
+  /**
+   * get root hash of the merkle tree
+   * @returns the hash, if the merkle tree is empty, will return
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getRootHash() {
+    this.completenessCheck();
+    for (let i = 1n; i < 2n ** this.levels; i *= 2n) {
+      if (this.tree.get(i)) {
+        return this.tree.get(i);
+      }
+    }
+    return this.defaultNodeValue;
+  }
+
+  getMerkleData() {
+    this.completenessCheck();
+    return new Map<bigint, T>(this.tree);
+  }
+
+  getSiblingIndex(index: bigint) {
+    if (index === 1n) return 1n;
+    return index % 2n === 1n ? index - 1n : index + 1n;
+  }
+
+  /**
+   * get sibling hashes needed by main.circom
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingHashesForVerification(item: T) {
+    this.completenessCheck();
+    let index = this.reverseTree.get(item);
+
+    if (index === undefined) return new Array<bigint>(Number(CIRCOM_MERKLE_LENGTH)).fill(0n);
+
+    const hashes: T[] = [];
+
+    while (index !== 0n) {
+      hashes.push(this.tree.get(this.getSiblingIndex(index)) || this.defaultNodeValue);
+      index /= 2n;
+    }
+
+    return hashes.slice(0, CIRCOM_MERKLE_LENGTH);
+  }
+
+  /**
+   * get item's sibling hashes side
+   * @returns sibling's indexes
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingSides(item: T) {
+    this.completenessCheck();
+    let index = this.reverseTree.get(item);
+
+    if (index === undefined) return new Array<bigint>(Number(CIRCOM_MERKLE_LENGTH)).fill(0n);
+
+    const siblingSides: bigint[] = [];
+
+    while (index !== 0n) {
+      const value = index % 2n === 0n ? 0n : 1n; // left = 0, right = 1
+      siblingSides.push(value);
+      index /= 2n;
+    }
+    return siblingSides.slice(0, CIRCOM_MERKLE_LENGTH);
+  }
+
+  public toJSON(): MerkleTreeJson {
+    const { tree, reverseTree, count, index } = this;
+    return {
+      tree: Object.fromEntries(tree),
+      reverseTree: Object.fromEntries(reverseTree),
+      count: count.toString(),
+      index: index.toString(),
+    };
+  }
+
+  public clone(): MerkleTree<T> {
+    return MerkleTree.createWithData(
+      new Map(this.tree),
+      new Map(this.reverseTree),
+      this.index,
+      this.count,
+      this.hashFunction,
+      this.levels,
+      this.defaultNodeValue,
+    );
+  }
+
+  public getIndex(): bigint {
+    return this.index;
+  }
+}

package/src/data-structures/merkle-tree/MerkleTreeIncompleteError.ts

@@ -0,0 +1,6 @@
+export class MerkleTreeIncompleteError extends Error {
+  constructor() {
+    super('Merkle tree is incomplete');
+    this.name = 'MerkleTreeIncompleteError';
+  }
+}

package/src/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.ts

@@ -0,0 +1,24 @@
+import { randomBigInt } from '../../functions/web3/etherFunctions';
+import { poseidonFunction } from '../../crypto/poseidon';
+import { UserKeys } from '../crypto-keys/keys';
+import { MerkleTree } from './MerkleTree';
+
+export const getPatchedAccessTokenMerkleTree = (
+  merkleTreeAccessToken: MerkleTree<bigint>,
+  userKeys: UserKeys,
+  patchAccessTokenMerkleTree: boolean,
+  kycRequired: boolean,
+) => {
+  if (!kycRequired || patchAccessTokenMerkleTree) {
+    const tree = MerkleTree.create(poseidonFunction, 0n);
+    tree.insert(BigInt(userKeys.getAccessKey()), tree.getStartIndex());
+    // insert additional element in merkle tree to obsfucate access key
+    // if we don't do this the transaction of users can be tracked very easily
+    // this shouldn't be done if kyc is required
+    if (!kycRequired) {
+      tree.insert(randomBigInt(31), tree.getStartIndex() + 1n);
+    }
+    return tree;
+  }
+  return merkleTreeAccessToken;
+};

package/src/data-structures/merkle-tree/index.ts

@@ -0,0 +1,3 @@
+export * from './MerkleTree';
+export * from './getPatchedAccessTokenMerkleTree';
+export * from './MerkleTreeIncompleteError';

package/src/data-structures/presale/PresaleContractWrapper.ts

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/dot-notation */
+import { presaleABI, presaleContractInfoByChain } from '../../constants/presale.constants';
+import { ERC20Token } from '../../types/token.types';
+import { ethers } from 'ethers';
+
+export class PresaleContractWrapper {
+  contract: ethers.Contract;
+
+  eventsFrom: number;
+
+  constructor(signerOrProvider: ethers.Signer | ethers.providers.Provider, chainId: number) {
+    const { address, eventsFrom } = presaleContractInfoByChain[chainId];
+    this.contract = new ethers.Contract(address, presaleABI, signerOrProvider);
+    this.eventsFrom = eventsFrom;
+  }
+
+  deposit(token: ERC20Token, amount: bigint, minHINK: bigint): Promise<ethers.ContractTransaction> {
+    return this.contract['deposit'](token.erc20TokenAddress, amount, minHINK);
+  }
+
+  withdraw(token: string, amount: bigint): Promise<ethers.ContractTransaction> {
+    return this.contract['withdraw'](token, amount);
+  }
+
+  moveToNextStage(overrides?: ethers.Overrides): Promise<ethers.ContractTransaction> {
+    return this.contract['moveToNextStage'](overrides || {});
+  }
+
+  async estimateMoveToNextStageGas(): Promise<bigint> {
+    return (await this.contract.estimateGas['moveToNextStage']()).toBigInt();
+  }
+
+  async getTotalDeposit(): Promise<bigint> {
+    const result: ethers.BigNumber = await this.contract['totalDeposit']();
+    return result.toBigInt();
+  }
+
+  async getDeposits(depositor: string, token: ERC20Token): Promise<bigint> {
+    const result: ethers.BigNumber = await this.contract['deposits'](depositor, token.erc20TokenAddress);
+    return result.toBigInt();
+  }
+
+  async getTotalHINK(depositor: string): Promise<bigint> {
+    const result: ethers.BigNumber = await this.contract['totalHINK'](depositor);
+    return result.toBigInt();
+  }
+
+  async getCurrentPresaleStageIndex(): Promise<number> {
+    const presaleStageIndex = await this.contract['currentPresaleStageIndex']();
+    return Number(presaleStageIndex);
+  }
+
+  async getCurrentMaxDepositAmount(): Promise<bigint> {
+    const currentMaxDepositAmount: ethers.BigNumber = await this.contract['currentMaxDepositAmount']();
+    return currentMaxDepositAmount.toBigInt();
+  }
+
+  async currentPresaleStage(): Promise<{
+    amountToRaise: bigint;
+    priceMultiplier: bigint;
+  }> {
+    const [amountToRaiseBN, priceMultiplierBN] = await this.contract['currentPresaleStage']();
+    const [amountToRaise, priceMultiplier] = [amountToRaiseBN, priceMultiplierBN].map(BigInt);
+    return { amountToRaise, priceMultiplier };
+  }
+
+  async calculateHINK(amount: bigint): Promise<bigint> {
+    const amountHINKBN: ethers.BigNumber = await this.contract['calculateHINK'](amount);
+    const amountHINK = amountHINKBN.toBigInt();
+    return amountHINK;
+  }
+
+  async queryDeposits() {
+    return this.contract.queryFilter(this.contract.filters['Deposit'](), this.eventsFrom);
+  }
+
+  onEvent(eventName: string, handleEvent: ethers.providers.Listener) {
+    this.contract.on(eventName, handleEvent);
+  }
+}

package/src/data-structures/presale/index.ts

@@ -0,0 +1 @@
+export * from './PresaleContractWrapper';

package/src/data-structures/provider-adapter/IProviderAdapter.ts

@@ -0,0 +1,43 @@
+import { TransactionRequest, TransactionResponse } from '@ethersproject/providers';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { Contract, ethers, Signer } from 'ethers';
+
+export interface ChainEventListener {
+  onAccountChanged(): void;
+  onChainChanged(chainId?: number): void;
+}
+
+export interface IProviderAdapter<ConnectorType = unknown> {
+  chainId: number | undefined;
+  initConnector(connector: ConnectorType): void;
+  getSigner(): Signer;
+  initSigner?(signer: Signer): void;
+  init(chainId?: number): Promise<void>;
+  initConfig?(config?: any): Promise<void> | void;
+  connectToConnector(connector: ConnectorType): Promise<number>;
+  disconnectFromConnector(): Promise<void>;
+  connectAndPatchProvider(connector: ConnectorType): Promise<number>;
+  waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean>;
+  signMessage(message: string | Uint8Array): Promise<string>;
+  getAddress(): Promise<string>;
+  getSelectedNetwork(): EthereumNetwork | undefined;
+  setChainEventListener(chainEventListener: ChainEventListener): void;
+  release(): void;
+  getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+  getContract(contractType: ContractType, contractAddress?: string, chainId?: number): ethers.Contract;
+  getContractWithSigner(contract: ContractType, contractAddress?: string): Contract;
+  getContractWithFetcher(contract: ContractType, contractAddress?: string): Contract;
+  getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): Contract;
+  sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
+  switchNetwork(network: EthereumNetwork): Promise<unknown>;
+  switchAccount(signer: ethers.Signer): Promise<void>;
+  onAccountChanged(): Promise<unknown>;
+  onChainChanged(chainId?: number): Promise<unknown>;
+  isPermitterAvailable(): boolean;
+  getGasPrice(): Promise<bigint>;
+  signTypedData(
+    domain: ethers.TypedDataDomain,
+    types: Record<string, ethers.TypedDataField[]>,
+    value: Record<string, unknown>,
+  ): Promise<string>;
+}

package/src/data-structures/snapshot/ClientAccessTokenSnapshotService.ts

@@ -0,0 +1,41 @@
+import {
+  AbstractAccessTokenSnapshotService,
+  AccessTokenSerializedSnapshot,
+  BlockchainEventEmitter,
+} from '../event-service';
+import { SnapshotFetcherService } from './SnapshotFetcherService';
+
+export class ClientAccessTokenSnapshotService extends AbstractAccessTokenSnapshotService {
+  private snapshotsService: SnapshotFetcherService;
+
+  constructor(accessTokenEventFetcher: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService) {
+    super(accessTokenEventFetcher);
+    this.snapshotsService = snapshotFetcher;
+  }
+
+  protected async fetchSnapshot(): Promise<AccessTokenSerializedSnapshot> {
+    const { contract } = this.blockchainEventEmitter;
+    const { chainId } = await contract.provider.getNetwork();
+    if (!this.snapshotsService) {
+      this.snapshotsService = new SnapshotFetcherService(chainId, contract.address);
+    }
+
+    const accessTokenSnapshotData = await this.snapshotsService.getAccessTokens();
+    if (
+      accessTokenSnapshotData.accessTokenContractAddress !== contract.address ||
+      accessTokenSnapshotData.chainId !== chainId
+    )
+      throw Error('Commitment Snapshot: incorrect contract or chain id');
+    return {
+      latestBlockNumber: accessTokenSnapshotData.latestBlockNumber,
+      merkleTree: accessTokenSnapshotData.merkleTree,
+      senderAddresses: accessTokenSnapshotData.senderAddresses,
+      senderAddressIndexMap: accessTokenSnapshotData.senderAddressIndexMap,
+    };
+  }
+
+  protected persistSnapshot(_serializedSnapshot: AccessTokenSerializedSnapshot): Promise<unknown> {
+    // Do nothing
+    return Promise.resolve();
+  }
+}

package/src/data-structures/snapshot/ClientApprovalsSnapshotService.ts

@@ -0,0 +1,36 @@
+import {
+  AbstractApprovalsSnapshotService,
+  ApprovalsSerializedSnapshot,
+} from '../event-service/AbstractApprovalsSnapshotService';
+import { BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../event-service';
+import { SnapshotFetcherService } from './SnapshotFetcherService';
+
+export class ClientApprovalsSnapshotService extends AbstractApprovalsSnapshotService {
+  private snapshotsService: SnapshotFetcherService;
+
+  constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService) {
+    super(hinkalEventEmitter);
+    this.snapshotsService = snapshotFetcher;
+  }
+
+  protected async fetchSnapshot(): Promise<ApprovalsSerializedSnapshot> {
+    const { contract } = this.blockchainEventEmitter;
+    const { chainId } = await contract.provider.getNetwork();
+
+    const approvalsSnapshotData = await this.snapshotsService.getApprovals();
+    if (approvalsSnapshotData.hinkalAddress !== contract.address || approvalsSnapshotData.chainId !== chainId) {
+      throw Error('approvalsSnapshotData Snapshot: incorrect contract or chain id');
+    }
+
+    return {
+      latestBlockNumber: approvalsSnapshotData.latestBlockNumber,
+      approvals: approvalsSnapshotData.approvals,
+      events: approvalsSnapshotData.events,
+    };
+  }
+
+  protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown> {
+    // Do nothing
+    return Promise.resolve();
+  }
+}

package/src/data-structures/snapshot/ClientCommitmentsSnapshotService.ts

@@ -0,0 +1,30 @@
+import {
+  AbstractCommitmentsSnapshotService,
+  BlockchainEventEmitter,
+  CommitmentsSerializedSnapshot,
+} from '../event-service';
+import { SnapshotFetcherService } from './SnapshotFetcherService';
+
+export class ClientCommitmentsSnapshotService extends AbstractCommitmentsSnapshotService {
+  private snapshotsService: SnapshotFetcherService;
+
+  constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService) {
+    super(hinkalEventEmitter);
+    this.snapshotsService = snapshotsFetcher;
+  }
+
+  protected async fetchSnapshot(): Promise<CommitmentsSerializedSnapshot> {
+    const commitmentsSnapshotData = await this.snapshotsService.getCommitments();
+
+    return {
+      latestBlockNumber: commitmentsSnapshotData.latestBlockNumber,
+      merkleTree: commitmentsSnapshotData.merkleTree,
+      encryptedOutputs: commitmentsSnapshotData.encryptedOutputs,
+    };
+  }
+
+  protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown> {
+    // Do nothing
+    return Promise.resolve();
+  }
+}

package/src/data-structures/snapshot/ClientNullifierSnapshotService.ts

@@ -0,0 +1,28 @@
+import {
+  AbstractNullifierSnapshotService,
+  BlockchainEventEmitter,
+  NullifierSerializedSnapshot,
+} from '../event-service';
+import { SnapshotFetcherService } from './SnapshotFetcherService';
+
+export class ClientNullifierSnapshotService extends AbstractNullifierSnapshotService {
+  private snapshotsService: SnapshotFetcherService;
+
+  constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService) {
+    super(hinkalEventEmitter);
+    this.snapshotsService = snapshotsFetcher;
+  }
+
+  protected async fetchSnapshot(): Promise<NullifierSerializedSnapshot> {
+    const nullifiersSnapshotData = await this.snapshotsService.getNullifiers();
+    return {
+      latestBlockNumber: nullifiersSnapshotData.latestBlockNumber,
+      nullifiers: nullifiersSnapshotData.nullifiers,
+    };
+  }
+
+  protected persistSnapshot(_serializedSnapshot: NullifierSerializedSnapshot): Promise<unknown> {
+    // Do nothing
+    return Promise.resolve();
+  }
+}

package/src/data-structures/snapshot/SnapshotFetcherService.ts

@@ -0,0 +1,68 @@
+import { caseInsensitiveEqual } from '../../functions/utils/caseInsensitive.utils';
+import { fetchSnapshots, ISnapshotsResponse } from '../../API/fetchCommitmentsCache';
+
+const FIVE_MINUTES_IN_MILLISECONDS = 5 * 60 * 1000;
+
+export class SnapshotFetcherService {
+  private chainId: number;
+
+  private contractAddress: string;
+
+  private snapshotsPromise: Promise<ISnapshotsResponse> | undefined;
+
+  private lastFetchedAt: number | undefined;
+
+  private readonly cacheDurationMs: number;
+
+  constructor(chainId: number, contractAddress: string, cacheDurationMs = FIVE_MINUTES_IN_MILLISECONDS) {
+    this.chainId = chainId;
+    this.contractAddress = contractAddress;
+    this.cacheDurationMs = cacheDurationMs;
+  }
+
+  private async fetchSnapshots() {
+    this.lastFetchedAt = Date.now();
+    return fetchSnapshots(this.chainId);
+  }
+
+  private async ensureSnapshots(forceRefresh = false): Promise<ISnapshotsResponse> {
+    const now = Date.now();
+
+    const isExpired = !this.lastFetchedAt || now - this.lastFetchedAt > this.cacheDurationMs;
+
+    if (forceRefresh || !this.snapshotsPromise || isExpired) {
+      this.snapshotsPromise = this.fetchSnapshots();
+    }
+
+    const snapshots = await this.snapshotsPromise;
+
+    if (
+      !caseInsensitiveEqual(snapshots.commitments.hinkalAddress, this.contractAddress) ||
+      snapshots.commitments.chainId !== this.chainId
+    ) {
+      throw Error('Snapshots: incorrect contract or chain id');
+    }
+
+    return snapshots;
+  }
+
+  public async getAll(forceRefresh = false): Promise<ISnapshotsResponse> {
+    return this.ensureSnapshots(forceRefresh);
+  }
+
+  public async getCommitments(forceRefresh = false) {
+    return (await this.ensureSnapshots(forceRefresh)).commitments;
+  }
+
+  public async getAccessTokens(forceRefresh = false) {
+    return (await this.ensureSnapshots(forceRefresh)).accessTokens;
+  }
+
+  public async getNullifiers(forceRefresh = false) {
+    return (await this.ensureSnapshots(forceRefresh)).nullifiers;
+  }
+
+  public async getApprovals(forceRefresh = false) {
+    return (await this.ensureSnapshots(forceRefresh)).approvals;
+  }
+}

package/src/data-structures/snapshot/index.ts

@@ -0,0 +1 @@
+export * from './SnapshotFetcherService';

package/src/data-structures/token-price-fetcher/TokenChecker.ts

@@ -0,0 +1,45 @@
+import { ERC20Token } from '../../types/token.types';
+import { zeroAddress } from '../../constants/protocol.constants';
+
+export class TokenChecker {
+  public static isBeefyStakeToken = (token: ERC20Token) => {
+    return token.name.includes('-Boost') && token.symbol.includes('-Boost');
+  };
+
+  public static isStakeToken = (token: ERC20Token) => {
+    return this.isBeefyStakeToken(token);
+  };
+
+  public static isAaveToken = (token: ERC20Token) => {
+    return token.aaveToken;
+  };
+
+  public static isKinzaToken = (token: ERC20Token) => token.name.startsWith('Kinza');
+
+  public static isPotentiallyVolatile = (token: ERC20Token) => {
+    if (token.erc20TokenAddress === zeroAddress) return false;
+    return token.isVolatile || token.balanceStorageOffset === undefined || token.allowanceStorageOffset === undefined;
+  };
+
+  public static isPotentiallySpamToken(token: ERC20Token): boolean {
+    const { name, symbol } = token;
+    const combined = `${name} ${symbol}`;
+
+    const URL_REGEX = /(?:https?:\/\/|www\.)/i;
+    const TLD_REGEX =
+      /\.(?:com|io|app|org|net|co|xyz|link|site|top|in|ru|cn|me|biz|info|online|club|tech|to|cloud)(?=[^\w]|$)/i;
+    const SOCIAL_HOSTS_REGEX = /\b(?:t\.me|discord\.(?:gg|com)|twitter\.com|x\.com|telegram\.(?:me|org))\b/i;
+    const EMAIL_REGEX = /@[^\s]+\.[^\s]+/i;
+    const EMOJI_PICTO = /\p{Extended_Pictographic}/u;
+    const EMOJI_FLAG = /[\u{1F1E6}-\u{1F1FF}]{2}/u;
+    const EMOJI_KEYCAP = /[#*0-9]\uFE0F?\u20E3/u;
+
+    const isUrl = URL_REGEX.test(combined);
+    const isTld = TLD_REGEX.test(combined);
+    const isSocialHost = SOCIAL_HOSTS_REGEX.test(combined);
+    const isEmail = EMAIL_REGEX.test(combined);
+    const isEmoji = EMOJI_PICTO.test(combined) || EMOJI_FLAG.test(combined) || EMOJI_KEYCAP.test(combined);
+
+    return isUrl || isTld || isSocialHost || isEmail || isEmoji;
+  }
+}

package/src/data-structures/token-price-fetcher/index.ts

@@ -0,0 +1 @@
+export * from './TokenChecker';