@sabaaa1/common 0.0.1

package/src/providers/WagmiProviderAdapter.ts

@@ -0,0 +1,311 @@
+import { ChainEventListener, IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+import { chainIds, localhostNetwork, networkRegistry } from '../constants/chains.constants';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../types/ethereum-network.types';
+import { transactionErrorCodes, UserFriendlyErrorCodes } from '../error-handling/error-codes.constants';
+import { ethers, providers, Signer, utils } from 'ethers';
+import { type Config, type Connector, ConnectorAlreadyConnectedError } from 'wagmi';
+import {
+  connect,
+  disconnect,
+  getAccount,
+  reconnect,
+  signMessage,
+  switchChain,
+  watchAccount,
+  watchChainId,
+} from 'wagmi/actions';
+import {
+  getContract,
+  getContractMetadata,
+  getContractWithFetcherByChainId,
+} from '../functions/web3/getContractMetadata';
+
+// Should not be reexported in index for correct work on different enviroments
+export class WagmiProviderAdapter implements IProviderAdapter<Connector> {
+  private connector: Connector | undefined;
+
+  public chainId: number | undefined;
+
+  private originalProvider: providers.Provider | undefined;
+
+  private fetchProvider: providers.Provider | undefined;
+
+  private signer: Signer | undefined;
+
+  private chainEventListener?: ChainEventListener;
+
+  private config?: Config;
+
+  private unsubscribeFns: Array<() => unknown> = [];
+
+  initConnector(connector: Connector) {
+    this.connector = connector;
+  }
+
+  getSigner(): Signer {
+    if (!this.signer) throw new Error('No Signer In Provider Adapter');
+    return this.signer;
+  }
+
+  requireConnector() {
+    if (!this.connector) throw Error('No Connector In Provider Adapter');
+  }
+
+  initConfig(config: any) {
+    this.config = config as Config;
+  }
+
+  async init(chainId?: number) {
+    this.requireConnector();
+    // init chainId
+    if (chainId) this.chainId = chainId;
+    // init providers
+    this.originalProvider = (await this.connector!.getProvider()) as providers.Provider | undefined;
+    this.fetchProvider = this.createFetchProvider() ?? this.originalProvider;
+    if (this.fetchProvider === this.originalProvider) console.warn('fetchProvider not available');
+    // init signer
+    const provider = await this.connector!.getProvider();
+    const account = await this.connector!.getAccounts();
+
+    this.signer = await this.walletClientToSigner({ transport: provider, account: account[0] }, this.chainId!);
+  }
+
+  async disconnectFromConnector() {
+    if (!this.config) throw new Error('No Config In Provider Adapter');
+
+    this.release();
+    await disconnect(this.config); // metamask does not support programmic disconnect
+  }
+
+  async connectToConnector(connector: Connector): Promise<number> {
+    if (!this.config) throw new Error('No Config In Provider Adapter');
+    // force walletconnect to always show modal
+    // wallet connect will attempt to reuse previous session
+    // this can lead to signMessage to hang and no matching key in history errors getting logged in console which can't be caught
+    // encountered this problem with safe wallet, might be problem with other wallets as well
+    if (connector.id === 'walletConnect')
+      try {
+        await reconnect(this.config, { connectors: [connector] });
+        await disconnect(this.config);
+      } catch (err) {
+        // we can ignore any errors here
+      }
+    try {
+      const connectResult = await connect(this.config, { connector });
+      return connectResult.chainId;
+    } catch (err) {
+      if (err instanceof ConnectorAlreadyConnectedError) {
+        return connector.getChainId();
+      }
+
+      let error = transactionErrorCodes.CONNECTION_FAILED;
+
+      if ((err as any)?.code === 4001) {
+        error = UserFriendlyErrorCodes.YOU_CANCELED_REQUEST;
+      }
+
+      throw new Error(error);
+    }
+  }
+
+  async waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean> {
+    const txReceipt = await this.fetchProvider?.waitForTransaction(transactionHash, confirmations);
+    if (txReceipt?.status) return true;
+    throw Error(transactionErrorCodes.TRANSACTION_NOT_CONFIRMED);
+  }
+
+  async signMessage(message: string): Promise<string> {
+    if (!this.config) throw new Error('No Config In Provider Adapter');
+
+    const signature = await signMessage(this.config, { message });
+    if (!signature) throw new Error(transactionErrorCodes.SIGNING_FAILED); // coinbase wallet returns undefined in some cases.
+    if (signature.includes('error')) throw new Error(transactionErrorCodes.SIGNATURE_UNSUPPORTED_PERSONAL_SIGN);
+    return signature;
+  }
+
+  async signTypedData(
+    domain: ethers.TypedDataDomain,
+    types: Record<string, ethers.TypedDataField[]>,
+    value: Record<string, unknown>,
+  ): Promise<string> {
+    return (this.signer as providers.JsonRpcSigner)._signTypedData(domain, types, value);
+  }
+
+  getSelectedNetwork = (): EthereumNetwork | undefined => {
+    if (!this.chainId) throw new Error('Illegal state: no chaindId');
+    return networkRegistry[this.chainId];
+  };
+
+  async switchNetwork(network: EthereumNetwork) {
+    if (!this.config) throw new Error('No Config In Provider Adapter');
+
+    return switchChain(this.config, {
+      chainId: network.chainId as 1 | 137 | 56 | 42161 | 10 | 43114 | 31337 | 5042002,
+    });
+  }
+
+  private createFetchProvider() {
+    try {
+      const network = networkRegistry[this.chainId!];
+      const fetchRpcUrl = network?.fetchRpcUrl;
+      if (!fetchRpcUrl) {
+        return undefined;
+      }
+      return fetchRpcUrl.includes('wss')
+        ? new providers.WebSocketProvider(fetchRpcUrl)
+        : new providers.StaticJsonRpcProvider(fetchRpcUrl);
+    } catch (err) {
+      console.log('create Fetch Provider error', err);
+      return undefined;
+    }
+  }
+
+  async getAddress(): Promise<string> {
+    if (!this.config) throw new Error('No Config In Provider Adapter');
+
+    const { address } = getAccount(this.config);
+    if (!address) {
+      throw new Error('IllegalState');
+    }
+    return utils.getAddress(address);
+  }
+
+  setChainEventListener(chainEventListener: ChainEventListener): void {
+    if (!this.config) throw new Error('No Config In Provider Adapter');
+
+    this.chainEventListener = chainEventListener;
+
+    if (this.chainEventListener) {
+      this.unsubscribeFns.push(
+        watchAccount(this.config, {
+          onChange: ({ address }, { address: previousAddress }) => {
+            if (!this.chainEventListener) {
+              console.warn('chainEventListener is not set');
+              return;
+            }
+            console.log('Account changed');
+            // switching chains for some reason causes change event to fire with metamask mobile
+            if (address !== previousAddress) {
+              console.log('Account changed');
+              this.chainEventListener.onAccountChanged();
+            }
+          },
+        }),
+      );
+      this.unsubscribeFns.push(
+        watchChainId(this.config, {
+          onChange: (chainId) => {
+            if (!this.chainEventListener) {
+              console.warn('chainEventListener is not set');
+              return;
+            }
+            console.log('Chain ID changed!', chainId);
+            this.chainEventListener.onChainChanged(chainId);
+          },
+        }),
+      );
+    }
+  }
+
+  onAccountChanged(): Promise<unknown> {
+    return this.init();
+  }
+
+  onChainChanged(chainId?: number): Promise<unknown> {
+    return this.init(chainId);
+  }
+
+  release(): void {
+    this.removeListeners();
+  }
+
+  private removeListeners() {
+    this.unsubscribeFns.forEach((unsubscribeFn) => unsubscribeFn());
+    this.unsubscribeFns = [];
+  }
+
+  private parseChainIdParam(chainId: number | undefined) {
+    const resultChainId = chainId ?? this.chainId;
+
+    if (!resultChainId) {
+      throw new Error('No chainId provided in context');
+    }
+    return resultChainId;
+  }
+
+  getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata {
+    const resultChainId = this.parseChainIdParam(chainId);
+
+    return getContractMetadata(contractType, resultChainId);
+  }
+
+  getContract(contractType: ContractType, contractAddress = undefined, chainId?: number): ethers.Contract {
+    const resultChainId = this.parseChainIdParam(chainId);
+
+    return getContract(contractType, resultChainId, contractAddress);
+  }
+
+  getContractWithSigner(contract: ContractType, contractAddress = undefined): ethers.Contract {
+    if (!this.signer) throw new Error('IllegalState: no signer');
+
+    return this.getContract(contract, contractAddress).connect(this.signer);
+  }
+
+  getContractWithFetcher(contract: ContractType, contractAddress = undefined): ethers.Contract {
+    if (!this.fetchProvider) throw new Error('fetchProvider not initialized');
+
+    return this.getContract(contract, contractAddress).connect(this.fetchProvider);
+  }
+
+  getContractWithFetcherForEthereum(contract: ContractType, contractAddress = undefined): ethers.Contract {
+    const chainIdForRpcUrl =
+      this.chainId === chainIds.localhost && localhostNetwork === chainIds.ethMainnet
+        ? chainIds.localhost
+        : chainIds.ethMainnet;
+
+    return getContractWithFetcherByChainId(chainIdForRpcUrl, contract, contractAddress);
+  }
+
+  async sendTransaction(tx: ethers.providers.TransactionRequest) {
+    if (!this.signer) throw new Error('IllegalState: no signer');
+
+    const resp = await this.signer.sendTransaction(tx);
+
+    return resp;
+  }
+
+  async connectAndPatchProvider(connector: Connector): Promise<number> {
+    const chainId = await this.connectToConnector(connector);
+    return chainId;
+  }
+
+  isPermitterAvailable() {
+    const network = this.getSelectedNetwork();
+    return !!network?.contractData?.permitterAddress;
+  }
+
+  async getGasPrice(): Promise<bigint> {
+    const price = await this.fetchProvider?.getGasPrice();
+    if (!price) throw Error('Could not fetch gas price in getGasPrice');
+    return price.toBigInt();
+  }
+
+  async walletClientToSigner(walletClient: any, chainId: number) {
+    const { account, transport } = walletClient;
+    const network = {
+      chainId,
+      name: '',
+    };
+    const provider = new providers.Web3Provider(transport, network);
+    const signer = provider.getSigner(account);
+    return signer;
+  }
+
+  switchAccount(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export const wagmiProviderAdapter = new WagmiProviderAdapter();
+
+export default <T = unknown>() => new WagmiProviderAdapter() as any as IProviderAdapter<T>;

package/src/providers/exportProviers.ts

@@ -0,0 +1,11 @@
+import { IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+
+export const exportWagmiProvider = async <T = unknown>(): Promise<IProviderAdapter<T>> => {
+  const Provider = (await import('./WagmiProviderAdapter')) as any;
+  return Provider.wagmiProviderAdapter as any as IProviderAdapter<T>;
+};
+
+export const exportEthersProvider = async () => {
+  const Provider = await import('./EthersProviderAdapter');
+  return Provider.ethersProvierAdapter as IProviderAdapter;
+};

package/src/providers/prepareEthersHinkal.ts

@@ -0,0 +1,18 @@
+import { type Signer } from 'ethers';
+import { Hinkal } from '../data-structures';
+import { preProcessing } from '../crypto';
+// eslint-disable-next-line import/no-named-as-default
+import EthersProviderAdapter from './EthersProviderAdapter';
+import { type HinkalConfig } from '../types/hinkal.types';
+
+export const prepareEthersHinkal = async (signer: Signer, hinkalConfig?: HinkalConfig): Promise<Hinkal<unknown>> => {
+  await preProcessing();
+  const hinkal = new Hinkal(hinkalConfig);
+  const ethersProvierAdapter = EthersProviderAdapter();
+  ethersProvierAdapter.initSigner?.(signer); // type discrepency comes from different version of ethers.js
+  await hinkal.initProviderAdapter(undefined, ethersProvierAdapter);
+  await hinkal.initUserKeys();
+  await hinkal.resetMerkle();
+
+  return hinkal;
+};

package/src/providers/prepareWagmiHinkal.ts

@@ -0,0 +1,16 @@
+import { Hinkal } from '../data-structures';
+import { preProcessing } from '../crypto';
+import { wagmiProviderAdapter } from './WagmiProviderAdapter';
+import { type Config, type Connector } from 'wagmi';
+
+export const prepareWagmiHinkal = async (connector: Connector, config: Config): Promise<Hinkal<unknown>> => {
+  await preProcessing();
+  const hinkal = new Hinkal();
+
+  wagmiProviderAdapter.initConfig(config);
+  await hinkal.initProviderAdapter(connector, wagmiProviderAdapter);
+  await hinkal.initUserKeys();
+  await hinkal.resetMerkle();
+
+  return hinkal;
+};

package/src/types/API.types.ts

@@ -0,0 +1,23 @@
+export interface ThirdPartyLeaderBoardItem {
+  nickname: string;
+  points: number;
+}
+
+interface AssetChange {
+  type: string;
+  amount: string | null;
+  raw_amount: string;
+  dollar_value: string;
+  from: string;
+  to: string;
+  token_info: { standard: string; type: string; contract_address: string };
+}
+
+export type AssetChanges = AssetChange[] | null;
+
+export interface CallInfo<T = bigint> {
+  from: string;
+  to: string;
+  calldata: string;
+  value: T;
+}

package/src/types/ICacheDevice.ts

@@ -0,0 +1,5 @@
+export interface ICacheDevice<T = string> {
+  get(key: string): T | undefined;
+  set(key: string, value: T): void;
+  serialize(): Record<string, string>;
+}

package/src/types/IMultiThreadedUtxoUtils.ts

@@ -0,0 +1,16 @@
+// importing only types prevents dependency cycles
+import { type Utxo } from '../data-structures/utxo/Utxo';
+import { type UserKeys } from '../data-structures/crypto-keys/keys';
+import { EncryptedOutputWithSign, OutputsWithSignAndLast } from './commitments.types';
+
+export interface IMultiThreadedUtxoUtils {
+  batchProcess(
+    encryptedOutputs: EncryptedOutputWithSign[],
+    lastOutput: string,
+    userKeys: UserKeys,
+  ): Promise<OutputsWithSignAndLast>;
+
+  buildBatchProcess(encryptedOutputs: EncryptedOutputWithSign[], userKeys: UserKeys): Promise<Utxo[]>;
+
+  batchFilterUtxosWithNullifier(allUtxos: Utxo[], nullifiers: Set<string>): Promise<Utxo[]>;
+}

package/src/types/RewardUserEnums.ts

@@ -0,0 +1,12 @@
+export enum MemberStatus {
+  Owner = 'Owner',
+  Member = 'Member',
+  Leader = 'Leader',
+  None = 'None',
+}
+
+export enum Rank {
+  Bronze = 'Bronze',
+  Silver = 'Silver',
+  Gold = 'Gold',
+}

package/src/types/TransactionSimulator.types.ts

@@ -0,0 +1,30 @@
+import { ethers } from 'ethers';
+import { ParsedInLogicMetadata } from './hinkal.types';
+import { TokenChanges } from './token.types';
+import { TxParametersBase } from './wc.types';
+
+export interface TransactionSimulatorMinimalResult<T = bigint> {
+  tokenChanges: TokenChanges<T>[];
+  error?: string;
+  errorReason?: string;
+}
+
+export interface TransactionSimulatorResult<T = bigint> extends TransactionSimulatorMinimalResult<T> {
+  isSameStateChanges: boolean;
+  spenderAddresses: string[];
+  parsedInLogicMetadata?: ParsedInLogicMetadata;
+}
+
+export interface ITransactionSimulator {
+  isTxStateless(
+    txParameters: TxParametersBase,
+    simulateRandomUserTx: boolean,
+    inLogicSigner?: ethers.Wallet,
+  ): Promise<TransactionSimulatorResult>;
+}
+
+export interface VolatileTokenTransferResult {
+  success: boolean;
+  balanceDifference?: bigint;
+  error?: string;
+}

package/src/types/WeeklyAnalytics.types.ts

@@ -0,0 +1,44 @@
+import { MemberStatus, Rank } from './RewardUserEnums';
+import { AllPoints } from './all-points.types';
+import { AchievementProgressItem } from './new-rewards.type';
+
+export interface WeeklyAnalyticBase extends AllPoints {
+  weekStart: Date;
+}
+
+export interface BrotherhoodUserWeeklyAnalytic extends WeeklyAnalyticBase {
+  ethereumAddress: string;
+  brotherhoodId: number;
+}
+
+export interface BrotherhoodUserWeeklyAnalyticLeaderboardEntry extends BrotherhoodUserWeeklyAnalytic {
+  profileImage?: string;
+  username?: string;
+  memberStatus?: MemberStatus;
+}
+
+export interface BrotherhoodWeeklyAnalytic extends WeeklyAnalyticBase {
+  brotherhoodId: number;
+  multiplier: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface BrotherhoodWeeklyAnalyticLeaderboardEntry extends BrotherhoodWeeklyAnalytic {
+  profileImage: string;
+  name: string;
+}
+
+export interface UserWeeklyAnalytic extends WeeklyAnalyticBase {
+  ethereumAddress: string;
+  rank: Rank;
+  multiplier: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface UserWeeklyAnalyticLeaderboardEntry extends UserWeeklyAnalytic {
+  profileImage?: string;
+  username: string;
+  achievementsProgress: AchievementProgressItem[];
+}

package/src/types/activities.types.ts

@@ -0,0 +1,90 @@
+import { IntegrationProvider } from './hinkal.types';
+import { ERC20Token } from './token.types';
+import { BigNumber } from 'ethers';
+
+export enum ActivityStatus {
+  PENDING = 'PENDING',
+  SUCCESSFUL = 'SUCCESSFUL',
+  FAILED = 'FAILED',
+}
+
+export enum ActivityTypes {
+  SHIELD = 'Shield',
+  SWAP = 'Swap',
+  BRIDGE = 'Bridge',
+  SEND = 'Send',
+  DAPP_INTERACTION = 'dApp interaction',
+  DAPP_INTERACTION_APPROVAL = 'dApp interaction approval',
+  RECIEVE = 'Receive',
+  UNSHIELD = 'Unshield',
+  ONBOARDING_DEPOSIT = 'Onboarding deposit',
+  REVOKE = 'Revoke',
+  UNKNOWN = 'Unknown transaction',
+}
+
+export enum TokenChangeType {
+  SPEND = 'SPEND',
+  RECEIVE = 'RECEIVE',
+  APPROVE = 'APPROVE',
+}
+
+export type TokenAmountInfo = {
+  token: ERC20Token;
+  amount: string;
+};
+
+export const DexProviders = [
+  IntegrationProvider.UNISWAP,
+  IntegrationProvider.ODOS,
+  IntegrationProvider.ONEINCH,
+  IntegrationProvider.LIFI,
+  IntegrationProvider.NONE,
+];
+
+export const IntegrationProviderNames = {
+  [IntegrationProvider.UNISWAP]: 'Uniswap',
+  [IntegrationProvider.ODOS]: 'Odos',
+  [IntegrationProvider.ONEINCH]: '1inch',
+  [IntegrationProvider.LIFI]: 'LI.FI',
+  [IntegrationProvider.ALL]: 'All',
+  [IntegrationProvider.NONE]: 'None',
+};
+
+export type ActivityRightSideData = {
+  rightTop?: React.ReactNode;
+  rightTopClassName?: string;
+  rightBottom?: React.ReactNode;
+  rightBottomClassName?: string;
+};
+
+export interface ActivityAddRequest {
+  activityType: ActivityTypes;
+  from?: string;
+  to?: string;
+  value?: string;
+  status?: ActivityStatus;
+  txHash?: string;
+  gas?: BigNumber;
+  gasPrice?: BigNumber;
+  gasInDollar?: string;
+  tokensReceive?: TokenAmountInfo[];
+  tokensSpend?: TokenAmountInfo[];
+  tokensApprove?: TokenAmountInfo[];
+  chainId: number;
+  ownerPublicAddress?: string;
+  activityIcon?: string;
+  dappUrl?: string;
+  dappName?: string;
+  integrationProvider?: IntegrationProvider;
+}
+
+export interface Activity extends ActivityAddRequest {
+  id: string;
+  timestamp: Date;
+  status: ActivityStatus;
+}
+
+export type MinimalActivity = Pick<
+  Activity,
+  'timestamp' | 'status' | 'activityType' | 'tokensReceive' | 'tokensSpend' | 'chainId'
+>;

package/src/types/admin.types.ts

@@ -0,0 +1,30 @@
+export interface AdminDataType {
+  hashedOwner: string;
+  chainId: number;
+  timestamp: number;
+  action: AdminTransactionType;
+  erc20TokenAddresses: string[];
+  erc20TokenAmount: string[];
+}
+
+export interface AdminInterface extends AdminDataType {
+  erc20TokenPrices: string[];
+}
+
+export enum AdminTransactionType {
+  PrivateToPrivateSend = 'private_to_private_send',
+  PrivateToPublicSend = 'private_to_public_send',
+  PublicToPublicSend = 'public_to_public_send',
+  PublicToPublicBridgeSend = 'public_to_public_bridge_send',
+  PrivateSwap = 'private_swap',
+  PublicSwap = 'public_swap',
+  PublicBridgeSwap = 'public_bridge_swap',
+  Unshield = 'unshield',
+  Shield = 'shield',
+  Onboarding = 'onboarding',
+  PaymentLink = 'payment_link',
+  FundApprove = 'fund_approve',
+  FundApproveAndTransact = 'fund_approve_and_transact',
+  PublicDappTransaction = 'public_dapp_transaction',
+  PrivateDappTransaction = 'private_dapp_transaction',
+}

package/src/types/all-points.types.ts

@@ -0,0 +1,8 @@
+export interface AllPoints {
+  aumPoints: number;
+  tradingPoints: number;
+  referralPoints: number;
+  questPoints: number;
+  totalPoints: number;
+  mysteryBoxPoints: number;
+}

package/src/types/approvals.types.ts

@@ -0,0 +1,45 @@
+import { ERC20Token } from './token.types';
+
+export interface AlchemyBatchRequest {
+  jsonrpc: '2.0';
+  id: number;
+  method: string;
+  params: any[];
+}
+
+export interface AlchemyBatchResponse {
+  jsonrpc: '2.0';
+  id: number;
+  result: string;
+  error?: { code: number; message: string };
+}
+
+export interface TokenApproval {
+  token: ERC20Token;
+  spenderAddress: string;
+  allowance: bigint;
+  tokenId?: string;
+}
+
+export interface ApprovalPair {
+  contractAddress: string;
+  spenderAddress: string;
+  tokenIds?: Set<string>;
+}
+
+export interface ApprovalsBySpender {
+  spenderAddress: string;
+  approvedAssets: TokenApproval[];
+}
+
+export enum RevokeType {
+  ERC20 = 'ERC20',
+  tokenId = 'tokenId',
+  approvedForAll = 'approvedForAll',
+}
+
+export interface ApprovalRequestMetadata {
+  pairIndex: number;
+  type: RevokeType;
+  tokenId?: string;
+}

package/src/types/balances.types.ts

@@ -0,0 +1,20 @@
+import { UserKeys } from '../data-structures/crypto-keys/keys';
+
+export enum PrivateBalanceUpdateType {
+  OnlyCache = 'ONLY_CACHE',
+  Fresh = 'FRESH',
+  FreshWithoutLoader = 'FRESH_WITHOUT_LOADER',
+}
+
+export interface BalanceChangeState {
+  chainId?: number;
+  ethereumAddress?: string;
+  userKeys?: UserKeys;
+}
+
+export type PrivateBalanceUpdateEventType = {
+  updateType?: PrivateBalanceUpdateType;
+  resetCacheBefore?: boolean;
+  balanceChangeState?: BalanceChangeState;
+  updateTokensListBefore?: boolean;
+};