@sabaaa1/common 0.0.1

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+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;
+};