@sabaaa1/common 0.0.1

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

@@ -0,0 +1,305 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,163 @@
+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

@@ -0,0 +1,55 @@
+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/index.ts

@@ -0,0 +1,7 @@
+export * from './getInputUtxoAndBalance';
+export * from './getShieldedBalance';
+export * from './web3RetrieveEvents';
+export * from './balanceChangedHandler';
+export * from './balanceChangedCustomHandler';
+export * from './getApprovedBalance';
+export * from './getTransactionLogEvents';

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,27 @@
+/* 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;
+};