@sabaaa1/common 0.0.9 → 0.0.12

package/src/functions/web3/events/getInputUtxoAndBalance.ts

@@ -1,305 +0,0 @@
-import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-import { UserKeys } from '../../../data-structures/crypto-keys/keys';
-import { Utxo } from '../../../data-structures/utxo/Utxo';
-import { EncryptedOutputWithSign } from '../../../types/commitments.types';
-import { checkChainOrAddressNotUpdated } from '../../utils/upToDateState';
-import { getHinkalCache, resetCache, setHinkalCache } from '../../utils/cacheFunctions';
-import { type TokenWithId } from '../../../types/token-with-id.types';
-import { caseInsensitiveEqual } from '../../utils/caseInsensitive.utils';
-import { encodeTokenWithId } from '../../utils/encodeTokenWithId';
-import { getInputUtxosEnclave } from './getInputUtxosEnclave';
-import { Logger } from '../../../error-handling/logger';
-
-interface IGetInputUtxos {
-  hinkal: IHinkal;
-  tokenWithId?: TokenWithId | TokenWithId[];
-  minInput?: number;
-  sliceIfMore6?: boolean;
-  tokenId?: number;
-  chainId?: number;
-  passedShieldedPrivateKey?: string;
-  passedShieldedPublicKey?: string;
-  ethAddress?: string;
-  resetCacheBefore?: boolean;
-  allowRemoteDecryption?: boolean;
-  ensuredTokensWithId?: TokenWithId[];
-}
-
-const getInputUtxosLocally = async (
-  hinkal: IHinkal,
-  userKeys: UserKeys,
-  currentChainId: number,
-  ethereumAddress: string,
-  shieldedPublicKey: string,
-  hinkalOutputs: EncryptedOutputWithSign<boolean>[],
-  cachedEncryptedOutputs: EncryptedOutputWithSign<boolean>[],
-  lastOutput: string,
-  lastOutputIndex: number,
-) => {
-  lastOutputIndex += 1;
-  const outputsSlice = hinkalOutputs.slice(lastOutputIndex);
-
-  const { lastOutput: lastOutputNew, additionalEncryptedOutputs } = await hinkal.utxoUtils.batchProcess(
-    outputsSlice,
-    lastOutput,
-    userKeys,
-  );
-
-  const newEncryptedOutputs = [...cachedEncryptedOutputs, ...additionalEncryptedOutputs];
-
-  await checkChainOrAddressNotUpdated(hinkal, currentChainId, ethereumAddress);
-
-  setHinkalCache(
-    {
-      lastOutput: lastOutputNew,
-      encryptedOutputs: newEncryptedOutputs,
-    },
-    hinkal,
-    currentChainId,
-    shieldedPublicKey,
-  );
-
-  const resolvedUtxos = await hinkal.utxoUtils.buildBatchProcess(newEncryptedOutputs, userKeys);
-  return resolvedUtxos;
-};
-
-export const getInputUtxosRemotely = async (
-  hinkal: IHinkal,
-  userKeys: UserKeys,
-  currentChainId: number,
-  shieldedPublicKey: string,
-) => {
-  const {
-    utxos: resolvedUtxos,
-    encryptedOutputs: newEncryptedOutputs,
-    lastOutput,
-  } = await getInputUtxosEnclave(hinkal, currentChainId, userKeys);
-
-  setHinkalCache(
-    {
-      encryptedOutputs: newEncryptedOutputs,
-      lastOutput,
-    },
-    hinkal,
-    currentChainId,
-    shieldedPublicKey,
-  );
-
-  return resolvedUtxos;
-};
-
-export const attemptGetInputUtxosRemotely = async (
-  hinkal: IHinkal,
-  userKeys: UserKeys,
-  currentChainId: number,
-  ethereumAddress: string,
-  shieldedPublicKey: string,
-  hinkalOutputs: EncryptedOutputWithSign<boolean>[],
-  cachedEncryptedOutputs: EncryptedOutputWithSign<boolean>[],
-  lastOutput: string,
-  lastOutputIndex: number,
-) => {
-  try {
-    return await getInputUtxosRemotely(hinkal, userKeys, currentChainId, shieldedPublicKey);
-  } catch {
-    return getInputUtxosLocally(
-      hinkal,
-      userKeys,
-      currentChainId,
-      ethereumAddress,
-      shieldedPublicKey,
-      hinkalOutputs,
-      cachedEncryptedOutputs,
-      lastOutput,
-      lastOutputIndex,
-    );
-  }
-};
-
-const arraifyTokenWithId = (tokenWithId: TokenWithId | TokenWithId[] | undefined) => {
-  if (Array.isArray(tokenWithId)) return tokenWithId;
-  if (tokenWithId === undefined) return undefined;
-  return [tokenWithId];
-};
-
-const filterSpentUtxos = async (hinkal: IHinkal, allUtxos: Utxo[], nullifiers: Set<string>) => {
-  const inputUtxos = await hinkal.utxoUtils.batchFilterUtxosWithNullifier(allUtxos, nullifiers);
-  return inputUtxos;
-};
-
-const sortAndPadUtxos = (
-  inputUtxos: Utxo[],
-  minInput: number,
-  sliceIfMore6: boolean,
-  shieldedPrivateKey: string,
-  erc20TokenAddress: string,
-  tokenId: number,
-) => {
-  inputUtxos.sort((utxoOne, utxoTwo) => (utxoOne.amount <= utxoTwo.amount ? 1 : -1)); // descending order
-
-  while (inputUtxos.length < minInput || (inputUtxos.length > minInput && inputUtxos.length < 6)) {
-    inputUtxos.push(new Utxo({ amount: 0n, erc20TokenAddress, shieldedPrivateKey, tokenId }));
-
-    if (sliceIfMore6) {
-      while (inputUtxos.length > 6) {
-        inputUtxos.splice(inputUtxos.length - 1);
-      }
-    }
-  }
-};
-
-/**
- *
- * @param hinkal instance of the hinkal class
- * @param erc20TokenAddress erc20 token address
- * @param minInput min number of input UTXOs
- * @param sliceIfMore6 max upper bound on input UTXOs controller
- * @returns UTXOs for particular erc20 token address
- */
-export const getInputUtxoAndBalance = async ({
-  hinkal,
-  chainId = undefined,
-  passedShieldedPublicKey = undefined,
-  ethAddress = undefined,
-  resetCacheBefore = false,
-  allowRemoteDecryption = false,
-}: IGetInputUtxos): Promise<{ inputUtxos: Utxo[] }> => {
-  if (!hinkal.getCurrentChainId || !hinkal.getSelectedNetwork()) {
-    Logger.log('returning empty balance');
-    return { inputUtxos: [] };
-  }
-  const ethereumAddress = ethAddress ?? (await hinkal.getEthereumAddress());
-  const currentChainId = chainId ?? hinkal.getCurrentChainId();
-  const shieldedPublicKey = passedShieldedPublicKey ?? hinkal.userKeys.getShieldedPublicKey();
-  const { encryptedOutputs, nullifiers, userKeys } = hinkal;
-  const hinkalOutputs = Array.from(encryptedOutputs);
-
-  if (resetCacheBefore) {
-    resetCache(hinkal, currentChainId, shieldedPublicKey);
-  }
-
-  // eslint-disable-next-line prefer-const
-  let { encryptedOutputs: cachedEncryptedOutputs, lastOutput } = getHinkalCache(
-    hinkal,
-    currentChainId,
-    shieldedPublicKey,
-  );
-
-  await checkChainOrAddressNotUpdated(hinkal, currentChainId, ethereumAddress);
-
-  const lastOutputExist = lastOutput !== '';
-  const lastOutputIndex = hinkalOutputs.findIndex((output: EncryptedOutputWithSign) => {
-    return output.value === lastOutput;
-  });
-
-  // case 1: we already decrypted something, there may be some new outputs to decrypt
-  const case1 = lastOutputIndex > -1;
-  // case 2: we never decrypted anything
-  const case2 = !lastOutputExist && lastOutputIndex === -1;
-  // case 3: data in the cache is more up to date than last output: we do nothing
-  // const case3 = lastOutputExist && lastOutputIndex === -1;
-
-  const forceReadFromCache = hinkal.areMerkleTreeUpdatesDisabled();
-
-  const decryptLocally = !forceReadFromCache && (case1 || (!allowRemoteDecryption && case2));
-  const decryptRemotely = !forceReadFromCache && allowRemoteDecryption && case2;
-  const useCache = !decryptLocally && !decryptRemotely; // case 3 + forceReadFromCache
-
-  let allUtxos: Utxo[] = [];
-
-  // decrypt locally block
-  if (decryptLocally) {
-    allUtxos = await getInputUtxosLocally(
-      hinkal,
-      userKeys,
-      currentChainId,
-      ethereumAddress,
-      shieldedPublicKey,
-      hinkalOutputs,
-      cachedEncryptedOutputs,
-      lastOutput,
-      lastOutputIndex,
-    );
-  } else if (decryptRemotely) {
-    allUtxos = await attemptGetInputUtxosRemotely(
-      hinkal,
-      userKeys,
-      currentChainId,
-      ethereumAddress,
-      shieldedPublicKey,
-      hinkalOutputs,
-      cachedEncryptedOutputs,
-      lastOutput,
-      lastOutputIndex,
-    );
-  } else if (useCache) {
-    allUtxos = await hinkal.utxoUtils.buildBatchProcess(cachedEncryptedOutputs, userKeys);
-  }
-
-  await checkChainOrAddressNotUpdated(hinkal, currentChainId, ethereumAddress);
-
-  const inputUtxos = await filterSpentUtxos(hinkal, allUtxos, nullifiers);
-
-  return { inputUtxos };
-};
-
-export const getInputUtxoAndBalancePerToken = async ({
-  hinkal,
-  tokenWithId,
-  minInput = 2,
-  sliceIfMore6 = true,
-  chainId = undefined,
-  passedShieldedPrivateKey = undefined,
-  passedShieldedPublicKey = undefined,
-  ethAddress = undefined,
-  resetCacheBefore = false,
-  ensuredTokensWithId,
-}: IGetInputUtxos) => {
-  const shieldedPrivateKey = passedShieldedPrivateKey ?? hinkal.userKeys.getShieldedPrivateKey();
-
-  const { inputUtxos } = await getInputUtxoAndBalance({
-    hinkal,
-    minInput,
-    sliceIfMore6,
-    chainId,
-    passedShieldedPrivateKey,
-    passedShieldedPublicKey,
-    ethAddress,
-    resetCacheBefore,
-  });
-
-  const tokensWithId = arraifyTokenWithId(tokenWithId);
-
-  const inputUtxosPerToken = new Map<string, Utxo[]>();
-
-  inputUtxos.forEach((item) => {
-    if (
-      tokensWithId &&
-      !tokensWithId.some(
-        (currentTokenWithId) =>
-          caseInsensitiveEqual(currentTokenWithId.erc20TokenAddress, item.erc20TokenAddress) &&
-          currentTokenWithId.tokenId === item.tokenId,
-      )
-    )
-      return;
-
-    const utxoKey = encodeTokenWithId({ erc20TokenAddress: item.erc20TokenAddress, tokenId: item.tokenId });
-
-    const utxoArray = inputUtxosPerToken.get(utxoKey) ?? [];
-    inputUtxosPerToken.set(utxoKey, [...utxoArray, item]);
-  });
-
-  ensuredTokensWithId?.forEach((item) => {
-    const utxoKey = encodeTokenWithId({ erc20TokenAddress: item.erc20TokenAddress, tokenId: item.tokenId });
-    inputUtxosPerToken.set(utxoKey, inputUtxosPerToken.get(utxoKey) ?? []);
-  });
-
-  // eslint-disable-next-line no-restricted-syntax
-  for (const [key, value] of inputUtxosPerToken) {
-    const erc20TokenAddress = key.split('-')[0];
-    const tokenId = Number(key.split('-')[1]);
-    sortAndPadUtxos(value, minInput, sliceIfMore6, shieldedPrivateKey, erc20TokenAddress, tokenId);
-  }
-
-  return inputUtxosPerToken;
-};

package/src/functions/web3/events/getInputUtxosEnclave.ts

@@ -1,40 +0,0 @@
-import { ethers } from 'ethers';
-import { type IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-import { Utxo } from '../../../data-structures/utxo/Utxo';
-import { UserKeys } from '../../../data-structures/crypto-keys/keys';
-import { makeEnclaveHandshakeAndEncryptUint8Array } from '../../utils/encryptInputForEnclave';
-
-export const getInputUtxosEnclave = async (hinkal: IHinkal, chainId: number, userKeys: UserKeys) => {
-  const shieldedPrivateKey = userKeys.getShieldedPrivateKey();
-  const { privateKey, publicKey } = UserKeys.getEncryptionKeyPair(shieldedPrivateKey);
-
-  const packResult = ethers.utils.solidityPack(
-    ['uint256', 'uint256', 'uint256'],
-    [publicKey, privateKey, shieldedPrivateKey],
-  );
-
-  const data = ethers.utils.arrayify(packResult);
-
-  // encrypt data for enclave, results are in base64
-  const { keyCiphertext, inputCiphertext } = await makeEnclaveHandshakeAndEncryptUint8Array(data);
-
-  const { utxos, lastOutput, encryptedOutputs } = await hinkal
-    .getAPI()
-    .decryptUtxoEnclaveCall(chainId, keyCiphertext, inputCiphertext);
-
-  const deserializedUtxos = utxos.map(
-    (item) =>
-      new Utxo({
-        ...item,
-        amount: BigInt(item.amount),
-        randomization: item.randomization ? BigInt(item.randomization) : undefined,
-        shieldedPrivateKey,
-      }),
-  );
-
-  return {
-    utxos: deserializedUtxos,
-    encryptedOutputs,
-    lastOutput,
-  };
-};

package/src/functions/web3/events/getShieldedBalance.ts

@@ -1,163 +0,0 @@
-import { ERC20Token, TokenBalance } from '../../../types/token.types';
-import { getERC20Token, getErc20TokensForChain } from '../../utils/erc20tokenFunctions';
-import { caseInsensitiveEqual } from '../../utils/caseInsensitive.utils';
-import { Utxo } from '../../../data-structures/utxo/Utxo';
-import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-import { getAmountWithPrecision } from '../etherFunctions';
-import { ErrorWithAmount } from '../../../error-handling/customErrors';
-import { getInputUtxoAndBalance, getInputUtxoAndBalancePerToken } from './getInputUtxoAndBalance';
-import { privateTokensDB } from '../../../data-structures/TokenDBs/PrivateTokensDB';
-import { isExtension } from '../../../constants/vite.constants';
-import { encodeTokenWithId } from '../../utils/encodeTokenWithId';
-import { balanceFetchingMutex } from '../../utils/mutexes.utils';
-
-/**
- *
- * @param UserKeys to access user's encryption keys
- * @returns shielded balance
- */
-export const getShieldedBalance = async (
-  hinkal: IHinkal,
-  chainId: number,
-  passedShieldedPrivateKey: string,
-  passedShieldedPublicKey: string,
-  ethAddress: string,
-  resetCacheBefore = false,
-  allowRemoteDecryption?: boolean,
-  updateTokensListBefore = false,
-): Promise<Map<string, TokenBalance>> => {
-  return balanceFetchingMutex.runExclusive(async () => {
-    const { inputUtxos } = await getInputUtxoAndBalance({
-      hinkal,
-      sliceIfMore6: false,
-      chainId,
-      passedShieldedPrivateKey,
-      passedShieldedPublicKey,
-      ethAddress,
-      resetCacheBefore,
-      allowRemoteDecryption,
-    });
-
-    if (updateTokensListBefore && isExtension) {
-      await privateTokensDB.fetchAndUpdatePrivateTokens(
-        inputUtxos.map((utxo) => utxo.erc20TokenAddress),
-        chainId,
-        ethAddress,
-      );
-    }
-
-    const tokenRegistry = isExtension
-      ? await privateTokensDB.getPrivateTokens(chainId, ethAddress)
-      : getErc20TokensForChain(chainId);
-
-    // Handle volatile token by patching the erc20TokenAddress with approriate share token address.
-    // TODO: Refactor address patching logic into Token Modal
-
-    const balances: TokenBalance[] = tokenRegistry.map((token) => ({
-      token,
-      balance: inputUtxos.reduce((prev, currentUtxo) => {
-        // TODO: Refactor address patching logic into Token Modal
-        const tokenAddress = token.erc20TokenAddress;
-        if (caseInsensitiveEqual(tokenAddress, currentUtxo.erc20TokenAddress)) {
-          return prev + currentUtxo.amount;
-        }
-        return prev;
-      }, 0n),
-      timestamp: inputUtxos.filter((currentUtxo) =>
-        caseInsensitiveEqual(currentUtxo.erc20TokenAddress, token.erc20TokenAddress),
-      )[0]?.timeStamp,
-      nfts: inputUtxos
-        .filter(
-          (currentUtxo) =>
-            caseInsensitiveEqual(currentUtxo.erc20TokenAddress, token.erc20TokenAddress) && currentUtxo.tokenId !== 0,
-        )
-        .map((currentUtxo) => ({ tokenId: currentUtxo.tokenId, timestamp: currentUtxo.timeStamp })),
-    }));
-
-    const balancesMap = new Map<string, TokenBalance>();
-
-    balances.forEach((balance) => {
-      balancesMap.set(balance.token.erc20TokenAddress.toLowerCase(), balance);
-    });
-
-    return balancesMap;
-  });
-};
-
-/**
- *
- * @param hinkal hinkal instance to get userKeys
- * @param erc20Addresses array of erc20 tokens
- * @param amountChanges array of token amounts
- * @param maxInput to pad until maxInput number
- * @returns return padded UTXOs for every erc20 token
- */
-export const addPaddingToUtxos = async (
-  hinkal: IHinkal,
-  erc20Addresses: string[],
-  amountChanges: bigint[],
-  maxInput = 6,
-  tokenIds: number[] = erc20Addresses.map(() => 0),
-  forceEmptyUtxos = false,
-) => {
-  const { userKeys } = hinkal;
-  const inputUtxosArrayPadded: Utxo[][] = [];
-  const inputUtxosArrayToBePadded: Utxo[][] = [];
-
-  const inputUtxosPerToken = await getInputUtxoAndBalancePerToken({
-    hinkal,
-    sliceIfMore6: false,
-    ensuredTokensWithId: erc20Addresses.map((_, i) => ({ erc20TokenAddress: erc20Addresses[i], tokenId: tokenIds[i] })),
-    allowRemoteDecryption: false,
-  });
-
-  let maxUtxoNum = 0;
-  for (let i = 0; i < erc20Addresses.length; i += 1) {
-    if (forceEmptyUtxos === false) {
-      // eslint-disable-next-line no-await-in-loop
-      const inputUtxos =
-        inputUtxosPerToken.get(encodeTokenWithId({ erc20TokenAddress: erc20Addresses[i], tokenId: tokenIds[i] })) ?? [];
-      // this should never happen
-      // if it does then it is bug in the code
-      if (!inputUtxos) throw new Error('Missing utxos for token');
-      maxUtxoNum = Math.max(inputUtxos.length, maxUtxoNum);
-      inputUtxosArrayToBePadded.push(inputUtxos);
-    } else {
-      inputUtxosArrayToBePadded.push([]);
-    }
-  }
-  // Case of 2 dimesional circuit
-  if (maxUtxoNum === 2) return inputUtxosArrayToBePadded;
-
-  // Case of 6 dimensional circuit => adding empty UTXOs if needed: maxUtxoNum >= maxInput
-
-  inputUtxosArrayToBePadded.forEach((utxos: Utxo[], i) => {
-    if (utxos.length > maxInput) {
-      const firstSixUtxos = utxos.slice(0, maxInput);
-      const firstSixAmount = firstSixUtxos.reduce((prev, current) => prev + current.amount, 0n);
-      if (amountChanges[i] < 0n && firstSixAmount < -amountChanges[i]) {
-        const token = getERC20Token(erc20Addresses[i], hinkal.getCurrentChainId()) as ERC20Token;
-        const amountInToken = Number(getAmountWithPrecision(firstSixAmount, token, 2));
-        const message = `Unfortunately your transaction did not go through due to UTXOs limitations. \n Please try again with ${token.symbol}`;
-        throw new ErrorWithAmount(amountInToken, message);
-      }
-      inputUtxosArrayPadded.push(firstSixUtxos);
-    } else if (utxos.length <= maxInput) {
-      const tempUtxosStorage = [...utxos];
-      let diff = maxInput - utxos.length;
-      while (diff > 0) {
-        diff -= 1;
-        tempUtxosStorage.push(
-          new Utxo({
-            amount: 0n,
-            erc20TokenAddress: erc20Addresses[i],
-            shieldedPrivateKey: userKeys.getShieldedPrivateKey(),
-            tokenId: tokenIds[i],
-          }),
-        );
-      }
-      inputUtxosArrayPadded.push(tempUtxosStorage);
-    }
-  });
-  return inputUtxosArrayPadded;
-};

package/src/functions/web3/events/getTransactionLogEvents.ts

@@ -1,55 +0,0 @@
-import { networkRegistry } from '../../../constants';
-import { ethers } from 'ethers';
-import { Fragment, JsonFragment } from '@ethersproject/abi';
-import { createTorRpcProvider } from '../../utils';
-
-const decodeEventWithABI = (
-  log: ethers.providers.Log,
-  contractABI: string | readonly (string | Fragment | JsonFragment)[],
-) => {
-  const int = new ethers.utils.Interface(contractABI);
-  try {
-    const parsedLog = int.parseLog(log);
-    return {
-      name: parsedLog.name,
-      args: parsedLog.args,
-    };
-  } catch (error) {
-    console.warn('Could not decode log');
-    return null;
-  }
-};
-
-export async function getTransactionLogEvents(
-  chainId: number,
-  txHash: string,
-  contractAddress: string,
-  contractABI: string | readonly (string | Fragment | JsonFragment)[],
-) {
-  try {
-    const providerUrl = networkRegistry[chainId].fetchRpcUrl;
-    if (!providerUrl) throw new Error('RPC URL not found for the specified chain ID');
-    const provider = createTorRpcProvider(providerUrl);
-
-    const receipt = await provider.getTransactionReceipt(txHash);
-
-    if (!receipt) throw new Error('Transaction receipt not found');
-    if (receipt.status !== 1) throw new Error('Transaction failed');
-
-    const events = receipt.logs
-      .filter((log) => log.address.toLowerCase() === contractAddress.toLowerCase())
-      .map((log) => decodeEventWithABI(log, contractABI))
-      .filter((log): log is { name: string; args: ethers.utils.Result } => log !== null);
-
-    return {
-      transactionHash: receipt.transactionHash,
-      from: receipt.from,
-      to: receipt.to,
-      blockNumber: receipt.blockNumber,
-      events,
-    };
-  } catch (error) {
-    console.error('Error retrieving transaction events:', error);
-    throw error;
-  }
-}

package/src/functions/web3/events/web3RetrieveEvents.ts

@@ -1,33 +0,0 @@
-import { Contract, ethers } from 'ethers';
-
-/**
- * to get contract events
- * @param eventName to retrieve specific events
- * @param eventArgs event arguments
- * @returns array of the specific events
- */
-export const retrieveEvents = async (hinkalContract: ethers.Contract, eventName: string, ...eventArgs: unknown[]) => {
-  if (!hinkalContract.filters?.[eventName]) throw new Error('Contract Event not found');
-
-  // filter for events
-  const events = await hinkalContract.queryFilter(hinkalContract.filters?.[eventName](...eventArgs), 39561411);
-
-  return events;
-};
-
-/**
- *
- * @param web3Provider instance to get hinkal contract
- * @returns array of deposit timestamps in JS new Date format
- */
-export const getDepositEvents = async (hinkalContract: Contract, erc20TokenAddress: string) => {
-  const depositEvents = await retrieveEvents(hinkalContract, 'NewTransaction');
-  const tokenSpecificDeposits = depositEvents
-    .map((event) => {
-      if (event.args![1] === erc20TokenAddress && BigInt(event.args![2]) >= 0n) return new Date(event.args![0] * 1000);
-      return new Date(0);
-    })
-    .filter((e) => e.getTime() !== 0);
-
-  return tokenSpecificDeposits;
-};

package/src/functions/web3/functionCalls/accessTokenCalls.ts

@@ -1,27 +0,0 @@
-/* eslint-disable @typescript-eslint/dot-notation */
-import { ethers } from 'ethers';
-import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
-import { ContractType, SignatureData } from '../../../types';
-
-export const checkHinkalAccessToken = async (hinkal: IHinkal) => {
-  const accessToken = hinkal.getContractWithFetcher(ContractType.AccessTokenContract); // as AccessToken;
-
-  const tx = await accessToken.functions['hasToken'](hinkal.userKeys.getAccessKey());
-  return tx[0];
-};
-
-export const mintAccessToken = async (
-  hinkal: IHinkal,
-  signatureData: SignatureData,
-  fromWallet?: boolean,
-): Promise<ethers.ContractTransaction> => {
-  const accessToken = hinkal.getContractWithSigner(ContractType.AccessTokenContract); // as AccessToken;
-
-  const overrides = {
-    value: 0n,
-    ...(fromWallet && { type: 0 }),
-  };
-
-  const tx = await accessToken['addToken'](signatureData, overrides);
-  return tx;
-};