@sabaaa1/common 0.0.13 → 0.0.14

package/src/data-structures/Hinkal/hinkalActionStake.ts

@@ -1,152 +0,0 @@
-import { ownerPublicKey, zeroAddress } from '../../constants/protocol.constants';
-
-import { createStakeCommitment, encodeHStakeMetadata, encryptStake } from '../../functions/staking';
-import { getERC20Token, getHToken } from '../../functions/utils/erc20tokenFunctions';
-import { randomBigInt } from '../../functions/web3/etherFunctions';
-import { outputUtxoProcessing } from '../../functions/pre-transaction/outputUtxoProcessing';
-import { constructZkProof } from '../../functions/snarkjs/constructGeneralZkProof';
-import { addPaddingToUtxos } from '../../functions/web3/events/getShieldedBalance';
-
-import { Utxo } from '../utxo/Utxo';
-import { IHinkal } from './IHinkal';
-import { ContractType, ExternalActionId, HinkalStakeMode } from '../../types';
-import { UserKeys } from '../crypto-keys';
-import { transactCallDirect } from '../../functions/web3/functionCalls/transactCallDirect';
-import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
-
-export const hinkalActionStake = async (
-  hinkal: IHinkal,
-  erc20Addresses: string[],
-  amountChanges: bigint[],
-  stakeMode: HinkalStakeMode,
-  stakedTokenRecipient: string,
-) => {
-  const userAddress = await hinkal.getEthereumAddress();
-  const token = getERC20Token(erc20Addresses[0], hinkal.getCurrentChainId());
-  if (!token) throw Error('Deposit Action: No Token Found');
-  const isStake = stakeMode === HinkalStakeMode.Stake;
-  const isUnstake = stakeMode === HinkalStakeMode.Unstake;
-
-  const { erc20TokenAddress } = token;
-
-  const inputUtxosArray = [
-    ...(await addPaddingToUtxos(
-      hinkal,
-      erc20Addresses,
-      amountChanges,
-      2,
-      undefined,
-      stakeMode !== HinkalStakeMode.Deposit,
-    )),
-  ];
-  if (isStake || isUnstake) {
-    inputUtxosArray[0][0] = Utxo.createFrom(inputUtxosArray[0][0], {
-      amount: amountChanges[0] * (isStake ? 1n : -1n),
-      isStakeOrUnstakeInput: true,
-    });
-    for (let i = 0; i < inputUtxosArray.length; i += 1) {
-      for (let j = 0; j < inputUtxosArray[i].length; j += 1) {
-        if (!(i === 0 && j === 0)) inputUtxosArray[i][j] = Utxo.createFrom(inputUtxosArray[i][j], { amount: 0n });
-      }
-    }
-  }
-
-  const timeStamp = getCurrentTimeInSeconds().toString();
-  const { outputUtxos } = outputUtxoProcessing(hinkal.userKeys, inputUtxosArray[0], amountChanges[0], timeStamp);
-  const outputUtxosArray = [
-    outputUtxos.map((utxo) =>
-      Utxo.createFrom(utxo, {
-        isStake,
-        isUnstakeOutput: isUnstake,
-      }),
-    ),
-  ];
-
-  if (isUnstake) {
-    outputUtxosArray[0][0] = Utxo.createFrom(outputUtxosArray[0][0], {
-      amount: 0n,
-      isUnstakeOutput: isUnstake,
-    });
-  }
-  const onChainCreation = [false];
-
-  const stakeBlinding = randomBigInt(30);
-  const nonOwnerEncryptionKeyPair = UserKeys.getEncryptionKeyPair(hinkal.userKeys.getShieldedPrivateKey());
-  const encryptedContent = encryptStake(stakeBlinding, stakedTokenRecipient, ownerPublicKey);
-  const encryptedContentAlt = encryptStake(stakeBlinding, stakedTokenRecipient, nonOwnerEncryptionKeyPair.publicKey);
-  const stakeCommitment = isUnstake
-    ? 0n
-    : createStakeCommitment(
-        true,
-        stakedTokenRecipient,
-        stakeBlinding,
-        erc20TokenAddress,
-        amountChanges[0],
-        BigInt(outputUtxosArray[0][0].timeStamp),
-      );
-
-  const action = isStake ? 0 : 1;
-  const externalActionMetadata = encodeHStakeMetadata(
-    action,
-    stakeCommitment,
-    userAddress,
-    encryptedContent,
-    encryptedContentAlt,
-  );
-
-  const hinkalWrapper = hinkal.getContractWithSigner(ContractType.HinkalWrapper2);
-  const hinkalStakeExternalAction = hinkal.getContractWithSigner(ContractType.HinkalStakeExternalAction);
-
-  const { zkCallData, dimData, circomData } = await constructZkProof(
-    'v1x0',
-    hinkal.merkleTreeHinkal,
-    hinkal.merkleTreeAccessToken,
-    inputUtxosArray,
-    outputUtxosArray,
-    hinkal.userKeys,
-    'swapperME1x2x1',
-    ExternalActionId.HinkalStake,
-    hinkalStakeExternalAction.address,
-    externalActionMetadata,
-    hinkal.generateProofRemotely,
-    zeroAddress,
-    hinkal.getCurrentChainId(),
-    onChainCreation,
-    undefined,
-    undefined,
-    {
-      stakedTokenRecipient,
-      stakeBlinding,
-      mode: stakeMode,
-      depositorAddress: userAddress,
-    },
-  );
-
-  if (isUnstake) {
-    const hToken = getHToken(token, hinkal.getCurrentChainId());
-    if (!hToken) throw new Error('hToken not found');
-    const hTokenContract = hinkal.getContractWithFetcher(ContractType.HToken, hToken.erc20TokenAddress);
-    // eslint-disable-next-line @typescript-eslint/dot-notation
-    const hTokenAmount = (await hTokenContract['previewWithdraw'](-amountChanges[0])).toBigInt();
-    return transactCallDirect(
-      hinkal,
-      hTokenAmount,
-      hToken,
-      zkCallData,
-      circomData,
-      dimData,
-      hinkalStakeExternalAction,
-      hinkalWrapper,
-    );
-  }
-  return transactCallDirect(
-    hinkal,
-    amountChanges[0],
-    token,
-    zkCallData,
-    circomData,
-    dimData,
-    hinkalStakeExternalAction,
-    hinkalWrapper,
-  );
-};

package/src/data-structures/Hinkal/hinkalApprove.ts

@@ -1,170 +0,0 @@
-import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
-import { constructZkProof } from '../../functions/snarkjs/constructGeneralZkProof';
-import { addPaddingToUtxos } from '../../functions/web3/events/getShieldedBalance';
-import { estimateGasRelayer } from '../../functions/web3/functionCalls/estimateGasRelayer';
-import { transactCallRelayer } from '../../functions/web3/functionCalls/transactCallRelayer';
-import { ExternalActionData, ExternalActionId } from '../../types/external-action.types';
-import { Utxo } from '../utxo/Utxo';
-import { IHinkal } from './IHinkal';
-import { ERC20ABI } from '../../externalABIs';
-import { ethers } from 'ethers';
-import { defaultUseApprovalUTXOData, FeeStructure, HinkalLogicAction, HinkalLogicArgs } from '../../types/hinkal.types';
-import { outputUtxoProcessing } from '../../functions/pre-transaction/outputUtxoProcessing';
-import {
-  outputApprovalDataProcessing,
-  outputApprovalDataProcessingForHinkalApprove,
-} from '../../functions/pre-transaction/outputApprovalDataProcessing';
-import { getFeeStructure } from '../../functions/pre-transaction/getFeeStructure';
-import { mergeWithFeeStructure } from '../../functions/pre-transaction/merge-with-fee-structure';
-import { ContractType } from '../../types/ethereum-network.types';
-import { APPROVED_UTXO_CONVERSION_COUNT } from '../../constants/conversion.constants';
-import { shouldPatchAccessTokenMerkleTree } from '../../functions/pre-transaction/shouldPatchAccessTokenMerkleTree';
-import { getSignatureDataForTransact } from '../../functions/pre-transaction/getSignatureDataForTransact';
-import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
-
-export const hinkalApprove = async (
-  hinkal: IHinkal,
-  erc20Addresses: string[],
-  approvalAmount: bigint,
-  approvedTo: string,
-  feeToken?: string,
-  feeStructureOverride?: FeeStructure,
-  onlyGasEstimate = false,
-) => {
-  const normalizedApproveTo = ethers.utils.getAddress(approvedTo);
-  const ERC20Contract = new ethers.Contract(erc20Addresses[0], ERC20ABI);
-
-  const inHinkalAddress = hinkal.userKeys.getInHinkalAddress(normalizedApproveTo);
-  const userExistingApproval = hinkal.getMyApprovalAmountForInteraction(approvedTo, erc20Addresses[0]);
-
-  const amountDif = userExistingApproval - approvalAmount;
-
-  const deltaAmounts = [amountDif]; // adding to needed approval amount
-
-  const hinkalContract = hinkal.getContractWithFetcher(ContractType.HinkalContract);
-
-  const feeStructure =
-    feeStructureOverride ??
-    (await getFeeStructure(
-      hinkal.getCurrentChainId(),
-      feeToken,
-      erc20Addresses,
-      ExternalActionId.Wallet,
-      // we don't need exact amounts, just need to result in the same amount of gas
-      [0n, 1n].map((approveAmount) => ({
-        to: ERC20Contract.address,
-        from: hinkalContract.address,
-        value: 0n,
-        calldata: ERC20Contract.interface.encodeFunctionData('approve', [approvedTo, approveAmount]),
-      })),
-    ));
-
-  mergeWithFeeStructure(hinkal.getCurrentChainId(), erc20Addresses, deltaAmounts, feeStructure);
-
-  // at these point, amountChanges (may) incudes fee
-
-  const inputUtxosArray = [...(await addPaddingToUtxos(hinkal, erc20Addresses, deltaAmounts))];
-  const circuitName = `swapperMHA${deltaAmounts.length.toString()}x${inputUtxosArray[0].length}x1`;
-
-  const onChainCreation = deltaAmounts.map(() => false);
-  // 2) get output utxos
-  const outputUtxosArray: Utxo[][] = [];
-
-  const hinkalLogicArgs: HinkalLogicArgs = {
-    doPreTxApproval: true,
-    hinkalLogicAction: HinkalLogicAction.APPROVE,
-    executeApprovalChanges: erc20Addresses.map(() => 0n), // this should not matter
-    inHinkalAddress, // as well
-    useApprovalUtxoData: [],
-  };
-
-  const { patchAccessTokenMerkleTree, kycRequired, hasAccessToken } = await shouldPatchAccessTokenMerkleTree(
-    hinkal,
-    erc20Addresses,
-    deltaAmounts,
-  );
-
-  const signatureData = await getSignatureDataForTransact(
-    hinkal.getCurrentChainId(),
-    await hinkal.getEthereumAddress(),
-    hinkal.userKeys,
-    kycRequired,
-    hasAccessToken,
-  );
-
-  const timeStamp = getCurrentTimeInSeconds().toString();
-  for (let i = 0; i < erc20Addresses.length; i += 1) {
-    if (i === 0) {
-      const { useApprovalUtxoData, deltaAmountOverride } = outputApprovalDataProcessingForHinkalApprove(
-        hinkal,
-        inputUtxosArray[i],
-        approvedTo,
-        approvalAmount,
-        deltaAmounts[i],
-      );
-      deltaAmounts[i] = deltaAmountOverride;
-      hinkalLogicArgs.useApprovalUtxoData.push(useApprovalUtxoData);
-    } else {
-      const { useApprovalUtxoData } = outputApprovalDataProcessing(hinkal, inputUtxosArray[i], deltaAmounts[i]);
-      hinkalLogicArgs.useApprovalUtxoData.push(
-        useApprovalUtxoData ?? defaultUseApprovalUTXOData(APPROVED_UTXO_CONVERSION_COUNT, 0n),
-      );
-    }
-
-    const { outputUtxos } = outputUtxoProcessing(
-      hinkal.userKeys,
-      inputUtxosArray[i],
-      deltaAmounts[i],
-      timeStamp,
-      undefined,
-      false,
-    );
-    outputUtxosArray.push(outputUtxos);
-  }
-
-  const relay = await hinkal.getRandomRelay(!onlyGasEstimate);
-  if (!relay) throw Error(transactionErrorCodes.RELAYER_NOT_AVAILABLE);
-
-  const externalActionData: ExternalActionData = {
-    externalActionId: ExternalActionId.Wallet,
-    externalAddress: normalizedApproveTo,
-    externalActionMetadata: '0x',
-  };
-
-  // 3) generating proof and publicSignals from circom
-  const { zkCallData, circomData, dimData } = await constructZkProof(
-    'v1x1',
-    hinkal.merkleTreeHinkal,
-    hinkal.merkleTreeAccessToken,
-    inputUtxosArray,
-    outputUtxosArray,
-    hinkal.userKeys,
-    circuitName,
-    externalActionData.externalActionId,
-    externalActionData.externalAddress,
-    externalActionData.externalActionMetadata,
-    hinkal.generateProofRemotely,
-    relay,
-    hinkal.getCurrentChainId(),
-    onChainCreation,
-    undefined,
-    undefined,
-    undefined,
-    patchAccessTokenMerkleTree,
-    hinkalLogicArgs,
-    undefined,
-    feeStructure,
-    hinkal.getContractWithFetcher(ContractType.HinkalHelperContract),
-    signatureData,
-  );
-
-  // 4) Transaction Part
-  if (onlyGasEstimate) {
-    const gasEstimate = await estimateGasRelayer(hinkal, zkCallData, dimData, circomData);
-    return gasEstimate;
-  }
-
-  const tx = await transactCallRelayer(hinkal.getCurrentChainId(), zkCallData, dimData, circomData);
-
-  return tx;
-};

package/src/data-structures/Hinkal/hinkalCheckTokenRegistry.ts

@@ -1,26 +0,0 @@
-import { createTorRpcProvider } from '../../functions/utils';
-import { networkRegistry } from '../../constants/chains.constants';
-import { ethers } from 'ethers';
-
-export const hinkalCheckTokenRegistry = async (
-  hinkalHelper: ethers.Contract,
-  erc20Addresses: string[],
-  amountChanges: bigint[],
-): Promise<boolean> => {
-  const limitHit = await hinkalHelper['checkTokenRegistry'](erc20Addresses, amountChanges);
-  return limitHit;
-};
-
-export const createHinkalHelperFromData = (chainId: number) => {
-  const data = networkRegistry[chainId].contractData;
-  const { fetchRpcUrl } = networkRegistry[chainId];
-  if (!fetchRpcUrl) throw new Error('RPC URL not found for the specified chain ID');
-
-  const provider = createTorRpcProvider(fetchRpcUrl);
-
-  if (!data.hinkalHelperAddress || !data.hinkalHelperABI) {
-    throw Error('hinkal helpercontract data not found');
-  }
-
-  return new ethers.Contract(data.hinkalHelperAddress, data.hinkalHelperABI, provider);
-};

package/src/data-structures/Hinkal/hinkalDeposit.ts

@@ -1,199 +0,0 @@
-import { zeroAddress } from '../../constants/protocol.constants';
-
-import { outputUtxoProcessing } from '../../functions/pre-transaction/outputUtxoProcessing';
-import { constructZkProof } from '../../functions/snarkjs/constructGeneralZkProof';
-import { addPaddingToUtxos } from '../../functions/web3/events/getShieldedBalance';
-import { transactCallDirect } from '../../functions/web3/functionCalls/transactCallDirect';
-
-import { Utxo } from '../utxo/Utxo';
-import { IHinkal } from './IHinkal';
-import { transactionErrorCodes } from '../../error-handling/error-codes.constants';
-import { AdminTransactionType, ContractType, ERC20Token } from '../../types';
-import { getSignatureDataForTransact } from '../../functions/pre-transaction/getSignatureDataForTransact';
-import { isValidPrivateAddress } from '../../functions/utils/addresses';
-import { shouldPatchAccessTokenMerkleTree } from '../../functions/pre-transaction/shouldPatchAccessTokenMerkleTree';
-import { getCurrentTimeInSeconds } from '../../functions/utils/time.utils';
-import { emitTxPublicData } from '../../API/admin-calls';
-import { constructAdminData } from '../../functions/pre-transaction/constructAdminData';
-
-const getTransactionParameters = async (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[]) => {
-  const { patchAccessTokenMerkleTree, kycRequired, hasAccessToken } = await shouldPatchAccessTokenMerkleTree(
-    hinkal,
-    erc20Addresses,
-    amountChanges,
-  );
-
-  const contractTransaction = undefined;
-
-  const ethereumAddress = await hinkal.getEthereumAddress();
-
-  const signatureData = await getSignatureDataForTransact(
-    hinkal.getCurrentChainId(),
-    ethereumAddress,
-    hinkal.userKeys,
-    kycRequired,
-    hasAccessToken,
-  );
-
-  const externalActionData = {
-    externalActionId: 0n as const,
-    externalAddress: await hinkal.getEthereumAddress(),
-    externalActionMetadata: '0x00',
-  };
-  return {
-    signatureData,
-    externalActionData,
-    contractTransaction,
-    contractToApprove: contractTransaction,
-    patchAccessTokenMerkleTree,
-  };
-};
-
-export const hinkalDeposit = async (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[]) => {
-  const erc20Addresses = erc20Tokens.map((token) => token.erc20TokenAddress);
-  const { externalActionData, contractTransaction, contractToApprove, patchAccessTokenMerkleTree, signatureData } =
-    await getTransactionParameters(hinkal, erc20Addresses, amountChanges);
-
-  // Compose UTXOs
-  const inputUtxosArray = [...(await addPaddingToUtxos(hinkal, erc20Addresses, amountChanges))];
-  const circuitName = `swapperM${amountChanges.length.toString()}x${inputUtxosArray[0].length}x1`;
-  const outputUtxosArray: Utxo[][] = [];
-
-  const timeStamp = getCurrentTimeInSeconds().toString();
-  for (let i = 0; i < erc20Addresses.length; i += 1) {
-    const { outputUtxos } = outputUtxoProcessing(hinkal.userKeys, inputUtxosArray[i], amountChanges[i], timeStamp);
-    outputUtxosArray.push(outputUtxos);
-  }
-
-  // 3) generating proof and publicSignals from circom
-  const { zkCallData, circomData, dimData } = await constructZkProof(
-    'v1x1',
-    hinkal.merkleTreeHinkal,
-    hinkal.merkleTreeAccessToken,
-    inputUtxosArray,
-    outputUtxosArray,
-    hinkal.userKeys,
-    circuitName,
-    externalActionData.externalActionId,
-    externalActionData.externalAddress,
-    externalActionData.externalActionMetadata,
-    hinkal.generateProofRemotely,
-    zeroAddress,
-    hinkal.getCurrentChainId(),
-    undefined,
-    undefined,
-    undefined,
-    undefined,
-    patchAccessTokenMerkleTree,
-    undefined,
-    undefined,
-    undefined,
-    hinkal.getContractWithFetcher(ContractType.HinkalHelperContract),
-    signatureData,
-  );
-
-  // 4) calling ERC20 token registry contract and Hinkal
-
-  const tx = await transactCallDirect(
-    hinkal,
-    amountChanges, // for volotile tokens: amountChanges != amountOfTokenToApprove
-    erc20Tokens,
-    zkCallData,
-    circomData,
-    dimData,
-    contractToApprove,
-    contractTransaction,
-  );
-
-  const adminData = constructAdminData(
-    AdminTransactionType.Onboarding,
-    hinkal.getCurrentChainId(),
-    erc20Addresses,
-    amountChanges,
-    await hinkal.getEthereumAddress(),
-  );
-
-  emitTxPublicData(hinkal.getCurrentChainId(), adminData);
-  return tx;
-};
-
-export const hinkalDepositForOther = async (
-  hinkal: IHinkal,
-  erc20Tokens: ERC20Token[],
-  amountChanges: bigint[],
-  recipinetInfo: string,
-) => {
-  const erc20Addresses = erc20Tokens.map((token) => token.erc20TokenAddress);
-  const [randomization, stealthAddress, encryptionKey] = recipinetInfo.split(',');
-
-  if (!isValidPrivateAddress(recipinetInfo)) {
-    throw Error(transactionErrorCodes.RECIPIENT_FORMAT_INCORRECT);
-  }
-
-  const inputUtxosArray = erc20Addresses.map((erc20TokenAddress) => [
-    new Utxo({ amount: 0n, erc20TokenAddress, shieldedPrivateKey: hinkal.userKeys.getShieldedPrivateKey() }),
-    new Utxo({ amount: 0n, erc20TokenAddress, shieldedPrivateKey: hinkal.userKeys.getShieldedPrivateKey() }),
-  ]);
-  const circuitName = `swapperM${amountChanges.length.toString()}x${inputUtxosArray[0].length}x1`;
-
-  const outputUtxosArray = erc20Addresses.map((erc20TokenAddress, index) => [
-    new Utxo({
-      amount: amountChanges[index],
-      erc20TokenAddress,
-      randomization: BigInt(randomization),
-      stealthAddress,
-      encryptionKey,
-    }),
-  ]);
-
-  const { externalActionData, contractTransaction, contractToApprove, patchAccessTokenMerkleTree } =
-    await getTransactionParameters(hinkal, erc20Addresses, amountChanges);
-
-  const { zkCallData, circomData, dimData } = await constructZkProof(
-    'v1x1',
-    hinkal.merkleTreeHinkal,
-    hinkal.merkleTreeAccessToken,
-    inputUtxosArray,
-    outputUtxosArray,
-    hinkal.userKeys,
-    circuitName,
-    externalActionData.externalActionId,
-    externalActionData.externalAddress,
-    externalActionData.externalActionMetadata,
-    hinkal.generateProofRemotely,
-    zeroAddress,
-    hinkal.getCurrentChainId(),
-    undefined,
-    undefined,
-    undefined,
-    undefined,
-    patchAccessTokenMerkleTree,
-    undefined,
-    undefined,
-    undefined,
-    hinkal.getContractWithFetcher(ContractType.HinkalHelperContract),
-  );
-
-  const tx = await transactCallDirect(
-    hinkal,
-    amountChanges,
-    erc20Tokens,
-    zkCallData,
-    circomData,
-    dimData,
-    contractToApprove,
-    contractTransaction,
-  );
-
-  const adminData = constructAdminData(
-    AdminTransactionType.PaymentLink,
-    hinkal.getCurrentChainId(),
-    erc20Addresses,
-    amountChanges,
-    await hinkal.getEthereumAddress(),
-  );
-
-  emitTxPublicData(hinkal.getCurrentChainId(), adminData);
-
-  return tx;
-};

package/src/data-structures/Hinkal/hinkalGetRecipientInfo.ts

@@ -1,12 +0,0 @@
-import { IHinkal } from './IHinkal';
-import {
-  getExtendedRecipientInfoFromUserKeys,
-  getRecipientInfoFromUserKeys,
-} from '../../functions/utils/getRecipientInfoFromUserKeys';
-
-export const getRecipientInfo = (hinkal: IHinkal, extendedInfo = false): string => {
-  if (!hinkal) throw Error('No hinkal provided');
-
-  const { userKeys } = hinkal;
-  return extendedInfo ? getExtendedRecipientInfoFromUserKeys(userKeys) : getRecipientInfoFromUserKeys(userKeys);
-};

package/src/data-structures/Hinkal/hinkalGetZkMeProvider.ts

@@ -1,31 +0,0 @@
-import { type Provider } from '@zkmelabs/widget';
-import { API } from '../../API/API';
-import { IHinkal } from './IHinkal';
-
-export const getHinkalZkMeProvider = (hinkal: IHinkal) => {
-  const provider: Provider = {
-    async getAccessToken() {
-      const chainId = hinkal.getCurrentChainId();
-      return API.getZkMeAccessToken(chainId);
-    },
-    async getUserAccounts() {
-      const ethereumAddress = await hinkal.getEthereumAddress();
-      return [ethereumAddress];
-    },
-    async delegateTransaction(tx) {
-      const providerAdapter = await hinkal.getProviderAdapter();
-
-      const ethersTxReq = {
-        ...tx,
-        chainId: Number(tx.chainId),
-        type: tx.type ? tx.type : undefined,
-        maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? tx.maxPriorityFeePerGas : undefined,
-        maxFeePerGas: tx.maxFeePerGas ? tx.maxFeePerGas : undefined,
-      };
-      const txResponse = await providerAdapter.sendTransaction(ethersTxReq);
-      return txResponse.hash;
-    },
-  };
-
-  return provider;
-};