@reyaxyz/sdk 0.34.4 → 0.36.0

package/src/services/lp/withdrawPassivePoolAndBridge.ts

@@ -1,4 +1,4 @@
-import { ContractType } from '../../utils/contractAddresses';
+import { ContractType, getAddress } from '../../utils/contractAddresses';
 import { executeTransaction } from '../executeTransaction';
 import { signPoolRemoveLiquidity } from '../sign';
 import {
@@ -10,8 +10,7 @@ import {
   ReyaChainId,
   getCurrentTimestampInSeconds,
   getSocketConnectors,
-  getSocketController,
-  getTokenDetails,
+  getTokenInfoByAddress,
   scale,
 } from '@reyaxyz/common';
 import { BRIDGE_DEADLINE_IN_SECONDS } from '../../utils/consts';
@@ -33,18 +32,18 @@ export const withdrawPassivePoolAndBridge = async (
   const eip712Signature = await signPoolRemoveLiquidity(
     params.signer,
     reyaChainId,
+    getAddress(reyaChainId, ContractType.PERIPHERY_PROXY),
     params.owner.address,
     params.pool.id,
     sharesAmount,
     BigInt(0),
-    params.owner.poolSigNonce,
+    params.owner.poolSigNonce + 1,
     getCurrentTimestampInSeconds() + BRIDGE_DEADLINE_IN_SECONDS,
   );
 
-  const { tokenName } = getTokenDetails(params.pool.tokenAddress);
+  const tokenInfo = getTokenInfoByAddress(params.pool.tokenAddress);
 
   const { calldata: data, value } = encodeWithdrawPassivePoolAndBridge(
-    params.owner.address,
     params.pool.id,
     sharesAmount,
     BigInt(0),
@@ -52,12 +51,8 @@ export const withdrawPassivePoolAndBridge = async (
     BigInt('10000000'), //todo
     getSocketConnectors({
       moneyInOutChainId: params.moneyInOutChainId,
-      tokenName: tokenName,
+      tokenName: tokenInfo.name,
     }).withdraw,
-    getSocketController({
-      reyaChainId: reyaChainId,
-      tokenName: tokenName,
-    }),
     params.owner.address,
   );
 

package/src/services/margin-accounts/bridgeAndDepositExistingMA.ts

@@ -4,53 +4,82 @@ import {
   getSocketDepositFeesAsBigInt,
   getSocketVault,
   scale,
-  getTokenDetails,
   MoneyInOutChainId,
+  getTokenInfoByAddress,
+  getTokenInfoByName,
+  getReyaNetworkFromMoneyInOutChainId,
 } from '@reyaxyz/common';
 import { ContractType, getAddress } from '../../utils/contractAddresses';
 import { executeTransaction } from '../executeTransaction';
 import { encodeBridgeAndDepositExistingMA } from './encode';
 import {
-  BridgeAndDepositExisingMAParams,
-  BridgeAndDepositExisingMAResult,
+  BridgeAndDepositExistingMAParams,
+  BridgeAndDepositExistingMAResult,
 } from './types';
 import { signCoreCommands } from '../sign';
 import { BRIDGE_DEADLINE_IN_SECONDS } from '../../utils/consts';
-import { getReyaNetworkFromMoneyInOutChainId } from '../../utils/network';
+import { encodeSingleDeposit } from '../encode';
+import { MultiAction } from '../../utils/action';
 
-export const bridgeAndDepositExisingMA = async (
-  params: BridgeAndDepositExisingMAParams,
-): Promise<BridgeAndDepositExisingMAResult> => {
+export const bridgeAndDepositExistingMA = async (
+  params: BridgeAndDepositExistingMAParams,
+): Promise<BridgeAndDepositExistingMAResult> => {
   const network = await params.signer.provider?.getNetwork();
   const moneyInOutChainId: MoneyInOutChainId = Number(network?.chainId);
   const reyaChainId = getReyaNetworkFromMoneyInOutChainId(moneyInOutChainId);
+
+  const moneyInOutTokenInfo = getTokenInfoByAddress(
+    params.tokenAddress,
+    moneyInOutChainId,
+  );
+  const reyaPeripheryTokenInfo = getTokenInfoByName(
+    moneyInOutTokenInfo.name,
+    reyaChainId,
+  );
+  const reyaCoreTokenInfo =
+    reyaPeripheryTokenInfo.name === 'USDC'
+      ? getTokenInfoByName('RUSD', reyaChainId)
+      : reyaPeripheryTokenInfo;
+
+  const multiAction = new MultiAction();
+  encodeSingleDeposit(
+    reyaCoreTokenInfo.address,
+    scale(reyaPeripheryTokenInfo.decimals)(params.amount),
+    multiAction,
+  );
+
+  const peripheryAddress = getAddress(
+    reyaChainId,
+    ContractType.PERIPHERY_PROXY,
+  );
+
   const eip712Signature = await signCoreCommands(
     params.signer,
     reyaChainId,
+    peripheryAddress,
     params.marginAccountId,
-    params.owner.coreSigNonce,
+    multiAction.commands,
+    params.owner.coreSigNonce + 1,
     getCurrentTimestampInSeconds() + BRIDGE_DEADLINE_IN_SECONDS,
   );
 
-  const { tokenName, tokenDecimals } = getTokenDetails(params.tokenAddress);
-  const amount = scale(tokenDecimals)(params.amount);
-
   const socketConnectors = getSocketConnectors({
     moneyInOutChainId: moneyInOutChainId,
-    tokenName: tokenName,
+    tokenName: moneyInOutTokenInfo.name,
   });
 
   const { calldata: data, value } = encodeBridgeAndDepositExistingMA(
-    getAddress(reyaChainId, ContractType.PERIPHERY_PROXY),
+    peripheryAddress,
     BigInt('10000000'),
     socketConnectors.deposit,
     getSocketDepositFeesAsBigInt({
       moneyInOutChainId: moneyInOutChainId,
     }),
     params.marginAccountId,
-    params.tokenAddress,
-    amount,
+    reyaPeripheryTokenInfo.address,
+    scale(reyaPeripheryTokenInfo.decimals)(params.amount),
     eip712Signature,
+    scale(moneyInOutTokenInfo.decimals)(params.amount),
     BigInt('10000000'),
     socketConnectors.withdraw,
   );
@@ -62,7 +91,7 @@ export const bridgeAndDepositExisingMA = async (
     moneyInOutChainId,
     getSocketVault({
       moneyInOutChainId: moneyInOutChainId,
-      tokenName: tokenName,
+      tokenName: moneyInOutTokenInfo.name,
     }),
   );
 

package/src/services/margin-accounts/bridgeAndDepositNewMA.ts

@@ -3,8 +3,10 @@ import {
   getSocketDepositFeesAsBigInt,
   getSocketVault,
   scale,
-  getTokenDetails,
   MoneyInOutChainId,
+  getTokenInfoByName,
+  getTokenInfoByAddress,
+  getReyaNetworkFromMoneyInOutChainId,
 } from '@reyaxyz/common';
 import { ContractType, getAddress } from '../../utils/contractAddresses';
 import { executeTransaction } from '../executeTransaction';
@@ -13,7 +15,6 @@ import {
   BridgeAndDepositNewMAParams,
   BridgeAndDepositNewMAResult,
 } from './types';
-import { getReyaNetworkFromMoneyInOutChainId } from '../../utils/network';
 
 export const bridgeAndDepositNewMA = async (
   params: BridgeAndDepositNewMAParams,
@@ -22,12 +23,18 @@ export const bridgeAndDepositNewMA = async (
   const moneyInOutChainId: MoneyInOutChainId = Number(network?.chainId);
   const reyaChainId = getReyaNetworkFromMoneyInOutChainId(moneyInOutChainId);
 
-  const { tokenName, tokenDecimals } = getTokenDetails(params.tokenAddress);
-  const amount = scale(tokenDecimals)(params.amount);
+  const moneyInOutTokenInfo = getTokenInfoByAddress(
+    params.tokenAddress,
+    moneyInOutChainId,
+  );
+  const reyaPeripheryTokenInfo = getTokenInfoByName(
+    moneyInOutTokenInfo.name,
+    reyaChainId,
+  );
 
   const socketConnectors = getSocketConnectors({
     moneyInOutChainId: moneyInOutChainId,
-    tokenName: tokenName,
+    tokenName: moneyInOutTokenInfo.name,
   });
 
   const { calldata: data, value } = encodeBridgeAndDepositNewMA(
@@ -38,8 +45,9 @@ export const bridgeAndDepositNewMA = async (
       moneyInOutChainId: moneyInOutChainId,
     }),
     params.ownerAddress,
-    params.tokenAddress,
-    amount,
+    reyaPeripheryTokenInfo.address,
+    scale(reyaPeripheryTokenInfo.decimals)(params.amount),
+    scale(moneyInOutTokenInfo.decimals)(params.amount),
     BigInt('10000000'),
     socketConnectors.withdraw,
   );
@@ -51,7 +59,7 @@ export const bridgeAndDepositNewMA = async (
     moneyInOutChainId,
     getSocketVault({
       moneyInOutChainId: moneyInOutChainId,
-      tokenName: tokenName,
+      tokenName: moneyInOutTokenInfo.name,
     }),
   );
 

package/src/services/margin-accounts/deposit.ts

@@ -2,13 +2,13 @@ import { DepositParams, DepositResult } from './types';
 import { encodeDeposit } from './encode';
 import { executeTransaction } from '../executeTransaction';
 import { ContractType } from '../../utils/contractAddresses';
-import { scale, getTokenDetails } from '@reyaxyz/common';
+import { getTokenInfoByAddress, scale } from '@reyaxyz/common';
 
 export const deposit = async (
   params: DepositParams,
 ): Promise<DepositResult> => {
-  const { tokenDecimals } = getTokenDetails(params.tokenAddress);
-  const amount = scale(tokenDecimals)(params.amount);
+  const tokenInfo = getTokenInfoByAddress(params.tokenAddress);
+  const amount = scale(tokenInfo.decimals)(params.amount);
   const { calldata: data, value } = encodeDeposit(
     params.marginAccountId,
     params.tokenAddress,

package/src/services/margin-accounts/encode.ts

@@ -76,24 +76,22 @@ export const encodeTransferMargin = (
 
 export const encodeWithdrawMAAndBridge = (
   accountId: number,
-  token: string,
-  tokenAmount: bigint,
+  corePeripheryTokenAddress: string,
+  corePeripheryTokenAmount: bigint,
   sig: EIP712Signature,
   socketMsgGasLimit: bigint,
   socketConnector: string,
-  socketController: string,
   receiver: string,
 ): MethodParameters => {
   const functionSignature = 'withdrawMA';
   const parameters = [
     {
       accountId,
-      token,
-      tokenAmount,
+      token: corePeripheryTokenAddress,
+      tokenAmount: corePeripheryTokenAmount,
       sig,
       socketMsgGasLimit,
       socketConnector,
-      socketController,
       receiver,
     },
   ];
@@ -108,26 +106,31 @@ export const encodeBridgeAndDepositNewMA = (
   socketConnector: string,
   socketFees: bigint,
   accountOwner: string,
-  token: string,
-  tokenAmount: bigint,
+  peripheryTokenAddress: string,
+  peripheryTokenAmount: bigint,
+  moneyInOutTokenAmount: bigint,
   fallbackSocketMsgGasLimit: bigint,
   fallbackSocketConnector: string,
 ): MethodParameters => {
   const PERIPHERY_INTERFACE = new Interface(peripheryAbi);
-  const inputs = { accountOwner, token, tokenAmount };
+  const inputs = {
+    accountOwner,
+    token: peripheryTokenAddress,
+    tokenAmount: peripheryTokenAmount,
+  };
   const fallbackData = {
     socketMsgGasLimit: fallbackSocketMsgGasLimit,
     socketConnector: fallbackSocketConnector,
   };
   const peripheryCalldata = PERIPHERY_INTERFACE.encodeFunctionData(
-    'depositNewMA',
+    'depositNewMA((address,address,uint256),(uint256,address))',
     [inputs, fallbackData],
   );
 
   const functionSignature = 'depositToAppChain';
   const parameters = [
     receiver,
-    tokenAmount,
+    moneyInOutTokenAmount,
     socketMsgGasLimit,
     socketConnector,
     peripheryCalldata,
@@ -143,27 +146,33 @@ export const encodeBridgeAndDepositExistingMA = (
   socketConnector: string,
   socketFees: bigint,
   accountId: number,
-  token: string,
-  tokenAmount: bigint,
+  peripheryTokenAddress: string,
+  peripheryTokenAmount: bigint,
   sig: EIP712Signature,
+  moneyInOutTokenAmount: bigint,
   fallbackSocketMsgGasLimit: bigint,
   fallbackSocketConnector: string,
 ): MethodParameters => {
   const PERIPHERY_INTERFACE = new Interface(peripheryAbi);
-  const inputs = { accountId, token, tokenAmount, sig };
+  const inputs = {
+    accountId,
+    token: peripheryTokenAddress,
+    tokenAmount: peripheryTokenAmount,
+    sig,
+  };
   const fallbackData = {
     socketMsgGasLimit: fallbackSocketMsgGasLimit,
     socketConnector: fallbackSocketConnector,
   };
   const peripheryCalldata = PERIPHERY_INTERFACE.encodeFunctionData(
-    'depositExistingMA',
+    'depositExistingMA((uint128,address,uint256,(uint8,bytes32,bytes32,uint256)),(uint256,address))',
     [inputs, fallbackData],
   );
 
   const functionSignature = 'depositToAppChain';
   const parameters = [
     receiver,
-    tokenAmount,
+    moneyInOutTokenAmount,
     socketMsgGasLimit,
     socketConnector,
     peripheryCalldata,

package/src/services/margin-accounts/transferMarginBetweenAccounts.ts

@@ -1,4 +1,4 @@
-import { scale, getTokenDetails } from '@reyaxyz/common';
+import { scale, getTokenInfoByAddress } from '@reyaxyz/common';
 import { ContractType } from '../../utils/contractAddresses';
 import { executeTransaction } from '../executeTransaction';
 import { encodeTransferMargin } from './encode';
@@ -10,8 +10,8 @@ import {
 export const transferMarginBetweenAccounts = async (
   params: TransferMarginBetweenAccountsParams,
 ): Promise<TransferMarginBetweenAccountsResult> => {
-  const { tokenDecimals } = getTokenDetails(params.tokenAddress);
-  const amount = scale(tokenDecimals)(params.amount);
+  const tokenInfo = getTokenInfoByAddress(params.tokenAddress);
+  const amount = scale(tokenInfo.decimals)(params.amount);
   const { calldata: data, value } = encodeTransferMargin(
     params.fromMarginAccountId,
     params.toMarginAccountId,

package/src/services/margin-accounts/types.ts

@@ -105,7 +105,7 @@ export type BridgeAndDepositNewMAResult = {
   transactionHash: string | null;
 };
 
-export type BridgeAndDepositExisingMAParams = {
+export type BridgeAndDepositExistingMAParams = {
   signer: Signer | JsonRpcSigner;
   owner: Pick<OwnerMetadataEntity, 'address' | 'coreSigNonce'>;
   marginAccountId: MarginAccountEntity['id'];
@@ -113,7 +113,7 @@ export type BridgeAndDepositExisingMAParams = {
   amount: number;
 };
 
-export type BridgeAndDepositExisingMAResult = {
+export type BridgeAndDepositExistingMAResult = {
   transactionHash: string | null;
 };
 

package/src/services/margin-accounts/withdraw.ts

@@ -2,13 +2,13 @@ import { WithdrawParams, WithdrawResult } from './types';
 import { encodeWithdraw } from './encode';
 import { executeTransaction } from '../executeTransaction';
 import { ContractType } from '../../utils/contractAddresses';
-import { scale, getTokenDetails } from '@reyaxyz/common';
+import { getTokenInfoByAddress, scale } from '@reyaxyz/common';
 
 export const withdraw = async (
   params: WithdrawParams,
 ): Promise<WithdrawResult> => {
-  const { tokenDecimals } = getTokenDetails(params.tokenAddress);
-  const amount = scale(tokenDecimals)(params.amount);
+  const tokenInfo = getTokenInfoByAddress(params.tokenAddress);
+  const amount = scale(tokenInfo.decimals)(params.amount);
 
   const { calldata: data, value } = encodeWithdraw(
     params.marginAccountId,

package/src/services/margin-accounts/withdrawMAAndBridge.ts

@@ -1,12 +1,12 @@
 import {
   getCurrentTimestampInSeconds,
   getSocketConnectors,
-  getSocketController,
   scale,
-  getTokenDetails,
   ReyaChainId,
+  getTokenInfoByAddress,
+  getTokenInfoByName,
 } from '@reyaxyz/common';
-import { ContractType } from '../../utils/contractAddresses';
+import { ContractType, getAddress } from '../../utils/contractAddresses';
 import { executeTransaction } from '../executeTransaction';
 import { signCoreCommands } from '../sign';
 import { encodeWithdrawMAAndBridge } from './encode';
@@ -15,45 +15,55 @@ import {
   WithdrawMAAndBridgeParamsResult,
 } from './types';
 import { BRIDGE_DEADLINE_IN_SECONDS } from '../../utils/consts';
+import { encodeSingleWithdraw } from '../encode';
+import { MultiAction } from '../../utils/action';
 
 export const withdrawMAAndBridge = async ({
   signer,
   moneyInOutChainId,
   marginAccountId,
   owner,
-  amount,
+  amount: unscaledAmount,
   tokenAddress,
   receiverAddress = owner.address,
 }: WithdrawMAAndBridgeParams): Promise<WithdrawMAAndBridgeParamsResult> => {
   const network = await signer.provider?.getNetwork();
   const reyaChainId: ReyaChainId = Number(network?.chainId);
+
+  const bridgeTokenInfo = getTokenInfoByAddress(tokenAddress);
+  const corePeripheryTokenInfo =
+    bridgeTokenInfo.name === 'USDC'
+      ? getTokenInfoByName('RUSD', reyaChainId)
+      : bridgeTokenInfo;
+
+  const multiAction = new MultiAction();
+  encodeSingleWithdraw(
+    corePeripheryTokenInfo.address,
+    scale(corePeripheryTokenInfo.decimals)(unscaledAmount),
+    multiAction,
+  );
   const eip712Signature = await signCoreCommands(
     signer,
     reyaChainId,
+    getAddress(reyaChainId, ContractType.PERIPHERY_PROXY),
     marginAccountId,
-    owner.coreSigNonce,
+    multiAction.commands,
+    owner.coreSigNonce + 1,
     getCurrentTimestampInSeconds() + BRIDGE_DEADLINE_IN_SECONDS,
   );
 
-  const { tokenName, tokenDecimals } = getTokenDetails(tokenAddress);
-  const scaledAmount = scale(tokenDecimals)(amount);
-
   const socketConnectors = getSocketConnectors({
     moneyInOutChainId: moneyInOutChainId,
-    tokenName: tokenName,
+    tokenName: bridgeTokenInfo.name,
   });
 
   const { calldata: data, value } = encodeWithdrawMAAndBridge(
     marginAccountId,
-    tokenAddress,
-    scaledAmount,
+    corePeripheryTokenInfo.address,
+    scale(corePeripheryTokenInfo.decimals)(unscaledAmount),
     eip712Signature,
     BigInt('10000000'),
     socketConnectors.deposit,
-    getSocketController({
-      reyaChainId: reyaChainId,
-      tokenName: tokenName,
-    }),
     receiverAddress,
   );
 

package/src/services/sign.ts

@@ -1,5 +1,7 @@
 import { JsonRpcSigner, Signature, Signer, TypedDataField } from 'ethers';
 import { ContractType, getAddress } from '../utils/contractAddresses';
+import { Address, ReyaChainId } from '@reyaxyz/common';
+import { Command } from '../utils/action';
 
 export type EIP712Signature = {
   v: number;
@@ -22,25 +24,37 @@ function convertEthersSignatureToEIP712Signature(
 
 export async function signCoreCommands(
   signer: Signer | JsonRpcSigner,
-  chainId: number,
+  reyaChainId: ReyaChainId,
+  caller: Address,
   accountId: number,
+  commands: Command[],
   nonce: number,
   deadline: number,
-  // todo: add caller/commands/both once smart contracts are fixed
 ): Promise<EIP712Signature> {
   const signature = await signReyaTypedData(
     signer,
-    chainId,
-    getAddress(chainId, ContractType.CORE_PROXY),
+    getAddress(reyaChainId, ContractType.CORE_PROXY),
     {
       ExecuteBySig: [
+        { name: 'verifyingChainId', type: 'uint256' },
+        { name: 'caller', type: 'address' },
         { name: 'accountId', type: 'uint128' },
+        { name: 'commands', type: 'Command[]' },
         { name: 'nonce', type: 'uint256' },
         { name: 'deadline', type: 'uint256' },
       ],
+      Command: [
+        { name: 'commandType', type: 'uint8' },
+        { name: 'inputs', type: 'bytes' },
+        { name: 'marketId', type: 'uint128' },
+        { name: 'exchangeId', type: 'uint128' },
+      ],
     },
     {
+      verifyingChainId: reyaChainId,
+      caller: caller,
       accountId: accountId,
+      commands: commands,
       nonce: nonce,
       deadline: deadline,
     },
@@ -51,21 +65,22 @@ export async function signCoreCommands(
 
 export async function signPoolRemoveLiquidity(
   signer: Signer | JsonRpcSigner,
-  chainId: number,
-  owner: string,
+  reyaChainId: ReyaChainId,
+  caller: Address,
+  owner: Address,
   poolId: number,
   sharesAmount: bigint,
   minOut: bigint,
   nonce: number,
   deadline: number,
-  // todo: add caller once smart contracts are fixed
 ): Promise<EIP712Signature> {
   const signature = await signReyaTypedData(
     signer,
-    chainId,
-    getAddress(chainId, ContractType.PASSIVE_POOL_PROXY),
+    getAddress(reyaChainId, ContractType.PASSIVE_POOL_PROXY),
     {
       RemoveLiquidityBySig: [
+        { name: 'verifyingChainId', type: 'uint256' },
+        { name: 'caller', type: 'address' },
         { name: 'owner', type: 'address' },
         { name: 'poolId', type: 'uint128' },
         { name: 'sharesAmount', type: 'uint256' },
@@ -75,6 +90,8 @@ export async function signPoolRemoveLiquidity(
       ],
     },
     {
+      verifyingChainId: reyaChainId,
+      caller: caller,
       owner: owner,
       poolId: poolId,
       sharesAmount: sharesAmount,
@@ -89,22 +106,18 @@ export async function signPoolRemoveLiquidity(
 
 async function signReyaTypedData(
   signer: Signer | JsonRpcSigner,
-  chainId: number,
   verifyingContract: string,
   types: Record<string, Array<TypedDataField>>,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   value: Record<string, any>,
 ): Promise<Signature> {
-  const signatureString = await signer.signTypedData(
-    {
-      name: 'Reya',
-      version: '1',
-      chainId: chainId,
-      verifyingContract: verifyingContract,
-    },
-    types,
-    value,
-  );
+  const domain = {
+    name: 'Reya',
+    version: '1',
+    verifyingContract: verifyingContract,
+  };
+
+  const signatureString = await signer.signTypedData(domain, types, value);
 
   return Signature.from(signatureString);
 }

package/src/services/token/approve.ts

@@ -1,5 +1,11 @@
 import { ApprovalType, ApproveTokenParams } from './types';
-import { getERC20Allowance, getERC20TokenContract } from '@reyaxyz/common';
+import {
+  getERC20Allowance,
+  getERC20TokenContract,
+  getSocketVault,
+  GetSocketVaultParams,
+  getTokenInfoByAddress,
+} from '@reyaxyz/common';
 import { ContractType, getAddress } from '../../utils/contractAddresses';
 
 export const approveTokenSpending = async (
@@ -15,10 +21,28 @@ export const approveTokenSpending = async (
     params.signer,
   );
 
-  const contractProxyAddress =
-    params.type === ApprovalType.DEPOSIT
-      ? getAddress(chainId, ContractType.CORE_PROXY)
-      : getAddress(chainId, ContractType.PASSIVE_POOL_PROXY);
+  const tokenInfo = getTokenInfoByAddress(underLyingTokenAddress);
+
+  let contractProxyAddress;
+  switch (params.type) {
+    case ApprovalType.DEPOSIT:
+      contractProxyAddress = getAddress(chainId, ContractType.CORE_PROXY);
+      break;
+    case ApprovalType.LP:
+      contractProxyAddress = getAddress(
+        chainId,
+        ContractType.PASSIVE_POOL_PROXY,
+      );
+      break;
+    case ApprovalType.BRIDGE:
+      contractProxyAddress = getSocketVault({
+        moneyInOutChainId: chainId,
+        tokenName: tokenInfo.name,
+      } as GetSocketVaultParams);
+      break;
+    default:
+      throw new Error('Unexpected approval type in approveTokenSpending');
+  }
 
   // @todo validate if maxAllowance should be passed from UI
   const maxUint256Bn = BigInt(
@@ -32,7 +56,6 @@ export const approveTokenSpending = async (
       console.error(error);
       throw new Error('Transaction Confirmation Error');
     });
-
   try {
     await approvalTransaction.wait();
   } catch (error) {