@townsq/mm-sdk 1.0.1

package/src/chains/evm/spoke/modules/ts-evm-loan.ts

@@ -0,0 +1,1032 @@
+import { multicall, waitForTransactionReceipt } from 'viem/actions';
+
+import { ChainType } from '../../../../common/types/chain.js';
+import { TokenType } from '../../../../common/types/token.js';
+import { convertFromGenericAddress } from '../../../../common/utils/address.js';
+import {
+  calcNextPeriodReset,
+  calcPeriodNumber,
+} from '../../../../common/utils/formulae.js';
+import { GAS_LIMIT_ESTIMATE_INCREASE } from '../../common/constant/contract.js';
+import { getEvmSignerAccount } from '../../common/utils/chain.js';
+import { sendERC20Approve } from '../../common/utils/contract.js';
+import { getAllowanceStateOverride } from '../../common/utils/tokens.js';
+import { getHubTokenData } from '../../hub/utils/chain.js';
+import {
+  getSpokeMessageDispatcherContract,
+  getSpokeOperationContract,
+  getSpokeTokenContract,
+} from '../utils/contract.js';
+
+import type { EvmAddress } from '../../../../common/types/address.js';
+import type {
+  TSChainId,
+  NetworkType,
+  SpokeChain,
+} from '../../../../common/types/chain.js';
+import type {
+  AccountId,
+  LoanId,
+  LoanName,
+  LoanTypeId,
+  Nonce,
+} from '../../../../common/types/lending.js';
+import type { MessageToSend } from '../../../../common/types/message.js';
+import type {
+  TSTokenId,
+  SpokeTokenData,
+} from '../../../../common/types/token.js';
+import type {
+  PrepareBorrowCall,
+  PrepareCreateLoanAndDepositCall,
+  PrepareCreateLoanCall,
+  PrepareDeleteLoanCall,
+  PrepareDepositCall,
+  PrepareRepayCall,
+  PrepareRepayWithCollateralCall,
+  PrepareSwitchBorrowTypeCall,
+  PrepareWithdrawCall,
+} from '../../common/types/module.js';
+import type { TokenRateLimit } from '../types/pool.js';
+import type { Client, EstimateGasParameters, WalletClient } from 'viem';
+
+export const prepare = {
+  async createLoan(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    nonce: Nonce,
+    loanTypeId: LoanTypeId,
+    loanName: LoanName,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareCreateLoanCall> {
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fees
+    const msgValue = await bridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.createLoan(
+      [messageToSend.params, accountId, nonce, loanTypeId, loanName],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+
+  async deleteLoan(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    loanId: LoanId,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareDeleteLoanCall> {
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fees
+    const msgValue = await bridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.deleteLoan(
+      [messageToSend.params, accountId, loanId],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+
+  async createLoanAndDeposit(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    nonce: Nonce,
+    loanTypeId: LoanTypeId,
+    loanName: LoanName,
+    amount: bigint,
+    spokeChain: SpokeChain,
+    spokeTokenData: SpokeTokenData,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ) {
+    const spokeToken = getSpokeTokenContract(
+      provider,
+      spokeTokenData.spokeAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    const spender = convertFromGenericAddress(
+      spokeTokenData.spokeAddress,
+      ChainType.EVM
+    );
+
+    // get state override
+    let stateOverride;
+    if (
+      spokeTokenData.token.type === TokenType.ERC20 ||
+      spokeTokenData.token.type === TokenType.CROSS_CHAIN
+    ) {
+      const erc20Address = convertFromGenericAddress(
+        spokeTokenData.token.address,
+        ChainType.EVM
+      );
+      stateOverride = getAllowanceStateOverride([
+        {
+          erc20Address,
+          stateDiff: [
+            {
+              owner: sender,
+              spender,
+              tsChainId: spokeChain.tsChainId,
+              tsTokenId: spokeTokenData.TsTokenId,
+              tokenType: spokeTokenData.token.type,
+              amount,
+            },
+          ],
+        },
+      ]);
+    }
+
+    // get adapter fees
+    const adapterFees = await bridgeRouter.read.getSendFee([messageToSend]);
+    const value =
+      spokeTokenData.token.type === TokenType.NATIVE ? amount : BigInt(0);
+    const msgValue = adapterFees + value;
+
+    // get gas limits
+    const gasLimit =
+      await spokeToken.estimateGas.initiateLoanAccountWithDeposit(
+        [messageToSend.params, accountId, nonce, amount, loanTypeId, loanName],
+        {
+          value: msgValue,
+          ...transactionOptions,
+          stateOverride,
+        }
+      );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeTokenData: spokeTokenData,
+    };
+  },
+
+  async deposit(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    loanId: LoanId,
+    amount: bigint,
+    spokeChain: SpokeChain,
+    spokeTokenData: SpokeTokenData,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareDepositCall> {
+    const spokeToken = getSpokeTokenContract(
+      provider,
+      spokeTokenData.spokeAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    const spender = convertFromGenericAddress(
+      spokeTokenData.spokeAddress,
+      ChainType.EVM
+    );
+
+    // get state override
+    let stateOverride;
+    if (
+      spokeTokenData.token.type === TokenType.ERC20 ||
+      spokeTokenData.token.type === TokenType.CROSS_CHAIN
+    ) {
+      const erc20Address = convertFromGenericAddress(
+        spokeTokenData.token.address,
+        ChainType.EVM
+      );
+      stateOverride = getAllowanceStateOverride([
+        {
+          erc20Address,
+          stateDiff: [
+            {
+              owner: sender,
+              spender,
+              tsChainId: spokeChain.tsChainId,
+              tsTokenId: spokeTokenData.TsTokenId,
+              tokenType: spokeTokenData.token.type,
+              amount,
+            },
+          ],
+        },
+      ]);
+    }
+
+    // get adapter fees
+    const adapterFees = await bridgeRouter.read.getSendFee([messageToSend]);
+    const value =
+      spokeTokenData.token.type === TokenType.NATIVE ? amount : BigInt(0);
+    const msgValue = adapterFees + value;
+
+    // get gas limits
+    const gasLimit = await spokeToken.estimateGas.topup(
+      [messageToSend.params, accountId, loanId, amount],
+      {
+        value: msgValue,
+        ...transactionOptions,
+        stateOverride,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeTokenData: spokeTokenData,
+    };
+  },
+
+  async withdraw(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    network: NetworkType,
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    isTAmount: boolean,
+    receiverTsChainId: TSChainId,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareWithdrawCall> {
+    const hubTokenData = getHubTokenData(tsTokenId, network);
+
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const spokeBridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fee
+    const msgValue = await spokeBridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.withdraw(
+      [
+        messageToSend.params,
+        accountId,
+        loanId,
+        hubTokenData.poolId,
+        receiverTsChainId,
+        amount,
+        isTAmount,
+      ],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+
+  async borrow(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    network: NetworkType,
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    maxStableRate: bigint,
+    receiverTSChainId: TSChainId,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareBorrowCall> {
+    const hubTokenData = getHubTokenData(tsTokenId, network);
+
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const spokeBridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fee
+    const msgValue = await spokeBridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.borrow(
+      [
+        messageToSend.params,
+        accountId,
+        loanId,
+        hubTokenData.poolId,
+        receiverTSChainId,
+        amount,
+        maxStableRate,
+      ],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+
+  async repay(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    loanId: LoanId,
+    amount: bigint,
+    maxOverRepayment: bigint,
+    spokeChain: SpokeChain,
+    spokeTokenData: SpokeTokenData,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareRepayCall> {
+    const spokeToken = getSpokeTokenContract(
+      provider,
+      spokeTokenData.spokeAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    const spender = convertFromGenericAddress(
+      spokeTokenData.spokeAddress,
+      ChainType.EVM
+    );
+
+    // get state override
+    let stateOverride;
+    if (
+      spokeTokenData.token.type === TokenType.ERC20 ||
+      spokeTokenData.token.type === TokenType.CROSS_CHAIN
+    ) {
+      const erc20Address = convertFromGenericAddress(
+        spokeTokenData.token.address,
+        ChainType.EVM
+      );
+      stateOverride = getAllowanceStateOverride([
+        {
+          erc20Address,
+          stateDiff: [
+            {
+              owner: sender,
+              spender,
+              tsChainId: spokeChain.tsChainId,
+              tsTokenId: spokeTokenData.TsTokenId,
+              tokenType: spokeTokenData.token.type,
+              amount,
+            },
+          ],
+        },
+      ]);
+    }
+
+    // get adapter fees
+    const adapterFees = await bridgeRouter.read.getSendFee([messageToSend]);
+    const value =
+      spokeTokenData.token.type === TokenType.NATIVE ? amount : BigInt(0);
+    const msgValue = adapterFees + value;
+
+    // get gas limits
+    const gasLimit = await spokeToken.estimateGas.repay(
+      [messageToSend.params, accountId, loanId, amount, maxOverRepayment],
+      {
+        value: msgValue,
+        ...transactionOptions,
+        stateOverride,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeTokenData: spokeTokenData,
+    };
+  },
+
+  async repayWithCollateral(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    network: NetworkType,
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareRepayWithCollateralCall> {
+    const hubTokenData = getHubTokenData(tsTokenId, network);
+
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fees
+    const msgValue = await bridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.repayWithCollateral(
+      [messageToSend.params, accountId, loanId, hubTokenData.poolId, amount],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+
+  async switchBorrowType(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    network: NetworkType,
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    maxStableRate: bigint,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareSwitchBorrowTypeCall> {
+    const hubTokenData = getHubTokenData(tsTokenId, network);
+
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fees
+    const msgValue = await bridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.changeBorrowMode(
+      [
+        messageToSend.params,
+        accountId,
+        loanId,
+        hubTokenData.poolId,
+        maxStableRate,
+      ],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+};
+
+export const write = {
+  async createLoan(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    nonce: Nonce,
+    loanTypeId: LoanTypeId,
+    loanName: LoanName,
+    prepareCall: PrepareCreateLoanCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.createLoan(
+      [messageParams, accountId, nonce, loanTypeId, loanName],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async deleteLoan(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    loanId: LoanId,
+    prepareCall: PrepareDeleteLoanCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.deleteLoan(
+      [messageParams, accountId, loanId],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async createLoanAndDeposit(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    nonce: Nonce,
+    loanTypeId: LoanTypeId,
+    loanName: LoanName,
+    amount: bigint,
+    includeApprove = true,
+    prepareCall: PrepareCreateLoanAndDepositCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeTokenData,
+    } = prepareCall;
+    const { token } = spokeTokenData;
+
+    const spokeToken = getSpokeTokenContract(
+      provider,
+      spokeTokenData.spokeAddress,
+      signer
+    );
+
+    if (
+      includeApprove &&
+      (token.type === TokenType.CROSS_CHAIN || token.type === TokenType.ERC20)
+    ) {
+      const approveTxId = await sendERC20Approve(
+        provider,
+        token.address,
+        signer,
+        convertFromGenericAddress(spokeTokenData.spokeAddress, ChainType.EVM),
+        amount
+      );
+      if (approveTxId !== null)
+        await waitForTransactionReceipt(provider, { hash: approveTxId });
+    }
+
+    return await spokeToken.write.initiateLoanAccountWithDeposit(
+      [messageParams, accountId, nonce, amount, loanTypeId, loanName],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async deposit(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    loanId: LoanId,
+    amount: bigint,
+    includeApprove = true,
+    prepareCall: PrepareDepositCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeTokenData,
+    } = prepareCall;
+    const { token } = spokeTokenData;
+
+    const spokeToken = getSpokeTokenContract(
+      provider,
+      spokeTokenData.spokeAddress,
+      signer
+    );
+
+    if (
+      includeApprove &&
+      (token.type === TokenType.CROSS_CHAIN || token.type === TokenType.ERC20)
+    ) {
+      const approveTxId = await sendERC20Approve(
+        provider,
+        token.address,
+        signer,
+        convertFromGenericAddress(spokeTokenData.spokeAddress, ChainType.EVM),
+        amount
+      );
+      if (approveTxId !== null)
+        await waitForTransactionReceipt(provider, { hash: approveTxId });
+    }
+
+    return await spokeToken.write.topup(
+      [messageParams, accountId, loanId, amount],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async withdraw(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    loanId: LoanId,
+    poolId: number,
+    amount: bigint,
+    isTAmount: boolean,
+    receiverChainId: TSChainId,
+    prepareCall: PrepareWithdrawCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.withdraw(
+      [
+        messageParams,
+        accountId,
+        loanId,
+        poolId,
+        receiverChainId,
+        amount,
+        isTAmount,
+      ],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async borrow(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    loanId: LoanId,
+    poolId: number,
+    amount: bigint,
+    maxStableRate: bigint,
+    receiverChainId: TSChainId,
+    prepareCall: PrepareBorrowCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.borrow(
+      [
+        messageParams,
+        accountId,
+        loanId,
+        poolId,
+        receiverChainId,
+        amount,
+        maxStableRate,
+      ],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async repay(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    loanId: LoanId,
+    amount: bigint,
+    maxOverRepayment: bigint,
+    includeApprove = true,
+    prepareCall: PrepareRepayCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeTokenData,
+    } = prepareCall;
+    const { token } = spokeTokenData;
+
+    const spokeToken = getSpokeTokenContract(
+      provider,
+      spokeTokenData.spokeAddress,
+      signer
+    );
+
+    if (
+      includeApprove &&
+      (token.type === TokenType.CROSS_CHAIN || token.type === TokenType.ERC20)
+    ) {
+      const approveTxId = await sendERC20Approve(
+        provider,
+        token.address,
+        signer,
+        convertFromGenericAddress(spokeTokenData.spokeAddress, ChainType.EVM),
+        amount
+      );
+      if (approveTxId !== null)
+        await waitForTransactionReceipt(provider, { hash: approveTxId });
+    }
+
+    return await spokeToken.write.repay(
+      [messageParams, accountId, loanId, amount, maxOverRepayment],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async repayWithCollateral(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    loanId: LoanId,
+    poolId: number,
+    amount: bigint,
+    prepareCall: PrepareRepayWithCollateralCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.repayWithCollateral(
+      [messageParams, accountId, loanId, poolId, amount],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async switchBorrowType(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    loanId: LoanId,
+    poolId: number,
+    maxStableRate: bigint,
+    prepareCall: PrepareSwitchBorrowTypeCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.changeBorrowMode(
+      [messageParams, accountId, loanId, poolId, maxStableRate],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+};
+
+export const read = {
+  async rateLimitInfo(
+    provider: Client,
+    token: SpokeTokenData
+  ): Promise<TokenRateLimit> {
+    const spokeToken = getSpokeTokenContract(provider, token.spokeAddress);
+
+    // get rate limit data
+    const [bucketConfig, oldPeriodNumber, oldCurrentCapacity] = await multicall(
+      provider,
+      {
+        contracts: [
+          {
+            address: spokeToken.address,
+            abi: spokeToken.abi,
+            functionName: 'bucketConfig',
+          },
+          {
+            address: spokeToken.address,
+            abi: spokeToken.abi,
+            functionName: 'currentPeriodNumber',
+          },
+          {
+            address: spokeToken.address,
+            abi: spokeToken.abi,
+            functionName: 'currentCapacity',
+          },
+        ],
+        allowFailure: false,
+      }
+    );
+
+    // TODO consider min limit
+    const [periodLength, periodOffset, periodLimit] = bucketConfig;
+    const newPeriodNumber = calcPeriodNumber(
+      BigInt(periodOffset),
+      BigInt(periodLength)
+    );
+    const isNewPeriod = newPeriodNumber !== BigInt(oldPeriodNumber);
+    const currentCapacity = isNewPeriod ? periodLimit : oldCurrentCapacity;
+    const nextPeriodReset = calcNextPeriodReset(
+      newPeriodNumber,
+      BigInt(periodOffset),
+      BigInt(periodLength)
+    );
+
+    // build rate limit info
+    return {
+      periodLength: BigInt(periodLength),
+      periodOffset: BigInt(periodOffset),
+      periodLimit: BigInt(periodLimit),
+      currentCapacity,
+      nextPeriodReset,
+    };
+  },
+};