@townsq/mm-sdk 1.0.1

package/src/lifeline/modules/ts-loan.ts

@@ -0,0 +1,1268 @@
+import { SEND_TOKEN_ACTION_RETURN_GAS_LIMIT } from '../../chains/evm/common/constant/contract.js';
+import { TsHubLoan } from '../../chains/evm/hub/modules/index.js';
+import {
+  assertLoanTypeSupported,
+  getHubChain,
+  getHubTokenData,
+  getHubTokensData,
+} from '../../chains/evm/hub/utils/chain.js';
+import { TSEvmLoan } from '../../chains/evm/spoke/modules/index.js';
+import { ChainType } from '../../common/types/chain.js';
+import { MessageDirection } from '../../common/types/gmp.js';
+import { Action } from '../../common/types/message.js';
+import { TokenType } from '../../common/types/token.js';
+import {
+  assertAdapterSupportsCrossChainToken,
+  assertAdapterSupportsDataMessage,
+} from '../../common/utils/adapter.js';
+import { convertFromGenericAddress } from '../../common/utils/address.js';
+import {
+  assertHubChainSelected,
+  assertSpokeChainSupportTsToken,
+  assertSpokeChainSupported,
+  getTsChain,
+  getSignerGenericAddress,
+  getSpokeChain,
+  getSpokeTokenData,
+} from '../../common/utils/chain.js';
+import {
+  buildMessageToSend,
+  estimateAdapterReceiveGasLimit,
+} from '../../common/utils/messages.js';
+import { exhaustiveCheck } from '../../utils/exhaustive-check.js';
+import { TSCore } from '../core/ts-core.js';
+
+import type {
+  AssetsAdditionalInterest,
+  LoanChange,
+  LoanControllerUserLoan,
+  LoanTypeInfo,
+  UserLoanInfo,
+  UserPoints,
+} from '../../chains/evm/hub/types/loan.js';
+import type {
+  OraclePrice,
+  OraclePrices,
+} from '../../chains/evm/hub/types/oracle.js';
+import type { PoolInfo } from '../../chains/evm/hub/types/pool.js';
+import type { TokenRateLimit } from '../../chains/evm/spoke/types/pool.js';
+import type { TSChainId } from '../../common/types/chain.js';
+import type {
+  AccountId,
+  LoanId,
+  LoanName,
+  LoanTypeId,
+  Nonce,
+} from '../../common/types/lending.js';
+import type {
+  BorrowMessageData,
+  CreateLoanAndDepositMessageData,
+  CreateLoanMessageData,
+  DeleteLoanMessageData,
+  DepositExtraArgs,
+  DepositMessageData,
+  LiquidateMessageData,
+  MessageAdapters,
+  MessageBuilderParams,
+  OptionalFeeParams,
+  OverrideTokenData,
+  RepayExtraArgs,
+  RepayMessageData,
+  RepayWithCollateralMessageData,
+  SendTokenExtraArgs,
+  SendTokenMessageData,
+  SwitchBorrowTypeMessageData,
+  WithdrawMessageData,
+} from '../../common/types/message.js';
+import type {
+  PrepareBorrowCall,
+  PrepareCreateLoanAndDepositCall,
+  PrepareCreateLoanCall,
+  PrepareDepositCall,
+  PrepareLiquidateCall,
+  PrepareRepayCall,
+  PrepareRepayWithCollateralCall,
+  PrepareSwitchBorrowTypeCall,
+  PrepareUpdateUserPointsInLoansCall,
+  PrepareWithdrawCall,
+} from '../../common/types/module.js';
+import type { TSTokenId } from '../../common/types/token.js';
+import type { Dnum } from 'dnum';
+import { GenericAddress } from '../../common/types/address.js';
+
+export const prepare = {
+  async createLoan(
+    accountId: AccountId,
+    nonce: Nonce,
+    loanTypeId: LoanTypeId,
+    loanName: LoanName,
+    adapters: MessageAdapters
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const data: CreateLoanMessageData = {
+      nonce,
+      loanTypeId,
+      loanName,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.CreateLoan,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: '0x',
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.prepare.createLoan(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          nonce,
+          loanTypeId,
+          loanName,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async liquidate(
+    accountId: AccountId,
+    liquidatorLoanId: LoanId,
+    violatorLoanId: LoanId,
+    tsTokenIdToLiq: TSTokenId,
+    tsTokenIdToSeize: TSTokenId,
+    repayingAmount: bigint,
+    minSeizedAmount: bigint,
+    liquidatorAddress: GenericAddress
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+    assertHubChainSelected(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const hubTokenToLiquidateData = getHubTokenData(
+      tsTokenIdToLiq,
+      tsChain.network
+    );
+    const hubTokenToSeizeData = getHubTokenData(
+      tsTokenIdToSeize,
+      tsChain.network
+    );
+
+    // const userAddress = getSignerGenericAddress({
+    //   signer: TSCore.getTSSigner().signer,
+    //   chainType: tsChain.chainType,
+    // });
+
+    const data: LiquidateMessageData = {
+      liquidatorLoanId,
+      violatorLoanId,
+      colPoolId: hubTokenToSeizeData.poolId,
+      borPoolId: hubTokenToLiquidateData.poolId,
+      repayingAmount,
+      minSeizedAmount,
+    };
+
+    return await TsHubLoan.prepare.liquidate(
+      TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+      convertFromGenericAddress(liquidatorAddress, tsChain.chainType),
+      data,
+      accountId,
+      hubChain
+    );
+  },
+
+  async repayWithCollateral(
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    adapters: MessageAdapters
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+    const network = tsChain.network;
+
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+
+    const hubChain = getHubChain(network);
+    const hubTokenData = getHubTokenData(tsTokenId, network);
+
+    const spokeChain = getSpokeChain(tsChain.tsChainId, network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+    const data: RepayWithCollateralMessageData = {
+      loanId,
+      poolId: hubTokenData.poolId,
+      amount,
+    };
+
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.RepayWithCollateral,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: '0x',
+    };
+    const feeParams: OptionalFeeParams = {
+      returnGasLimit: 0n,
+      gasLimit: 0n,
+    };
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.prepare.repayWithCollateral(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          network,
+          accountId,
+          loanId,
+          tsTokenId,
+          amount,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async deleteLoan(
+    accountId: AccountId,
+    loanId: LoanId,
+    adapters: MessageAdapters
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const data: DeleteLoanMessageData = {
+      accountId,
+      loanId,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.DeleteLoan,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: '0x',
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.prepare.deleteLoan(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          loanId,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async createLoanAndDeposit(
+    accountId: AccountId,
+    nonce: Nonce,
+    loanTypeId: LoanTypeId,
+    loanName: LoanName,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    adapters: MessageAdapters
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupportTsToken(
+      tsChain.tsChainId,
+      tsTokenId,
+      tsChain.network
+    );
+    assertLoanTypeSupported(loanTypeId, tsTokenId, tsChain.network);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const spokeTokenData = getSpokeTokenData(spokeChain, tsTokenId);
+    const hubTokenData = getHubTokenData(tsTokenId, tsChain.network);
+
+    if (spokeTokenData.token.type === TokenType.CROSS_CHAIN)
+      assertAdapterSupportsCrossChainToken(
+        tsChain.tsChainId,
+        spokeTokenData.token,
+        adapters.adapterId
+      );
+    else
+      assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const data: CreateLoanAndDepositMessageData = {
+      nonce,
+      poolId: hubTokenData.poolId,
+      amount,
+      loanTypeId,
+      loanName,
+    };
+    const extraArgs: DepositExtraArgs = {
+      token: spokeTokenData.token,
+      recipient: hubTokenData.poolAddress,
+      amount,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.InitiateLoanAccountWithDeposit,
+      sender: getSpokeTokenData(spokeChain, tsTokenId).spokeAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs,
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+    feeParams.returnGasLimit = SEND_TOKEN_ACTION_RETURN_GAS_LIMIT;
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.prepare.createLoanAndDeposit(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          nonce,
+          loanTypeId,
+          loanName,
+          amount,
+          spokeChain,
+          spokeTokenData
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async deposit(
+    accountId: AccountId,
+    loanId: LoanId,
+    loanTypeId: LoanTypeId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    adapters: MessageAdapters
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupportTsToken(
+      tsChain.tsChainId,
+      tsTokenId,
+      tsChain.network
+    );
+    assertLoanTypeSupported(loanTypeId, tsTokenId, tsChain.network);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const spokeTokenData = getSpokeTokenData(spokeChain, tsTokenId);
+    const hubTokenData = getHubTokenData(tsTokenId, tsChain.network);
+
+    if (spokeTokenData.token.type === TokenType.CROSS_CHAIN)
+      assertAdapterSupportsCrossChainToken(
+        tsChain.tsChainId,
+        spokeTokenData.token,
+        adapters.adapterId
+      );
+    else
+      assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const data: DepositMessageData = {
+      loanId,
+      poolId: hubTokenData.poolId,
+      amount,
+    };
+    const extraArgs: DepositExtraArgs = {
+      token: spokeTokenData.token,
+      recipient: hubTokenData.poolAddress,
+      amount,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.Deposit,
+      sender: getSpokeTokenData(spokeChain, tsTokenId).spokeAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs,
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+    feeParams.returnGasLimit = SEND_TOKEN_ACTION_RETURN_GAS_LIMIT;
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.prepare.deposit(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          loanId,
+          amount,
+          spokeChain,
+          spokeTokenData
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async withdraw(
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    isTAmount: boolean,
+    receiverTsChainId: TSChainId,
+    adapters: MessageAdapters
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+    const network = tsChain.network;
+    const receiverTsChain = getTsChain(receiverTsChainId, network);
+
+    const spokeChain = getSpokeChain(tsChain.tsChainId, network);
+    const receiverSpokeChain = getSpokeChain(receiverTsChainId, network);
+    const receiverSpokeTokenData = getSpokeTokenData(
+      receiverSpokeChain,
+      tsTokenId
+    );
+
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+    if (receiverSpokeTokenData.token.type === TokenType.CROSS_CHAIN)
+      assertAdapterSupportsCrossChainToken(
+        receiverTsChainId,
+        receiverSpokeTokenData.token,
+        adapters.returnAdapterId
+      );
+    else
+      assertAdapterSupportsDataMessage(
+        receiverTsChainId,
+        adapters.returnAdapterId
+      );
+
+    assertSpokeChainSupportTsToken(receiverTsChainId, tsTokenId, network);
+
+    const hubChain = getHubChain(network);
+    const hubTokenData = getHubTokenData(tsTokenId, network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const feeParams: OptionalFeeParams = {};
+
+    const returnData: SendTokenMessageData = {
+      amount,
+    };
+    const returnExtraArgs: SendTokenExtraArgs = {
+      tsTokenId,
+      token: hubTokenData.token,
+      recipient: receiverSpokeTokenData.spokeAddress,
+      amount,
+    };
+    const overrideData: OverrideTokenData = {
+      tsTokenId,
+      token: receiverSpokeTokenData.token,
+      address: receiverSpokeTokenData.spokeAddress,
+      amount,
+    };
+    const returnMessageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.SendToken,
+      sender: hubChain.hubAddress,
+      destinationChainId: receiverTsChainId,
+      handler: receiverSpokeTokenData.spokeAddress,
+      data: returnData,
+      extraArgs: returnExtraArgs,
+      overrideData,
+    };
+    feeParams.returnGasLimit = await estimateAdapterReceiveGasLimit(
+      hubChain.tsChainId,
+      receiverTsChain.tsChainId,
+      TSCore.getEVMProvider(receiverTsChain.tsChainId),
+      tsChain.network,
+      MessageDirection.HubToSpoke,
+      returnMessageBuilderParams
+    );
+
+    const data: WithdrawMessageData = {
+      loanId,
+      poolId: hubTokenData.poolId,
+      receiverTsChainId,
+      amount,
+      isFAmount: isTAmount,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.Withdraw,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: '0x',
+    };
+    feeParams.receiverValue = await TsHubLoan.getSendTokenAdapterFees(
+      TSCore.getHubProvider(),
+      network,
+      accountId,
+      tsTokenId,
+      amount,
+      receiverTsChainId,
+      adapters,
+      feeParams
+    );
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams,
+      feeParams.receiverValue
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.prepare.withdraw(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          network,
+          accountId,
+          loanId,
+          tsTokenId,
+          amount,
+          isTAmount,
+          receiverTsChainId,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async borrow(
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    maxStableRate: bigint,
+    receiverTsChainId: TSChainId,
+    adapters: MessageAdapters
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+    const network = tsChain.network;
+    const receiverTsChain = getTsChain(receiverTsChainId, network);
+
+    const spokeChain = getSpokeChain(tsChain.tsChainId, network);
+    const receiverSpokeChain = getSpokeChain(receiverTsChainId, network);
+    const receiverSpokeTokenData = getSpokeTokenData(
+      receiverSpokeChain,
+      tsTokenId
+    );
+
+    assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+    if (receiverSpokeTokenData.token.type === TokenType.CROSS_CHAIN)
+      assertAdapterSupportsCrossChainToken(
+        receiverTsChainId,
+        receiverSpokeTokenData.token,
+        adapters.returnAdapterId
+      );
+    else
+      assertAdapterSupportsDataMessage(
+        receiverTsChainId,
+        adapters.returnAdapterId
+      );
+    assertSpokeChainSupportTsToken(receiverTsChainId, tsTokenId, network);
+
+    const hubChain = getHubChain(network);
+    const hubTokenData = getHubTokenData(tsTokenId, network);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const feeParams: OptionalFeeParams = {};
+
+    const returnData: SendTokenMessageData = {
+      amount,
+    };
+    const returnExtraArgs: SendTokenExtraArgs = {
+      tsTokenId,
+      token: hubTokenData.token,
+      recipient: receiverSpokeTokenData.spokeAddress,
+      amount,
+    };
+    const overrideData: OverrideTokenData = {
+      tsTokenId,
+      token: receiverSpokeTokenData.token,
+      address: receiverSpokeTokenData.spokeAddress,
+      amount,
+    };
+    const returnMessageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.SendToken,
+      sender: hubChain.hubAddress,
+      destinationChainId: receiverTsChainId,
+      handler: receiverSpokeTokenData.spokeAddress,
+      data: returnData,
+      extraArgs: returnExtraArgs,
+      overrideData,
+    };
+    feeParams.returnGasLimit = await estimateAdapterReceiveGasLimit(
+      hubChain.tsChainId,
+      receiverTsChain.tsChainId,
+      TSCore.getEVMProvider(receiverTsChain.tsChainId),
+      tsChain.network,
+      MessageDirection.HubToSpoke,
+      returnMessageBuilderParams
+    );
+
+    const data: BorrowMessageData = {
+      loanId,
+      poolId: hubTokenData.poolId,
+      receiverTsChainId,
+      amount,
+      maxStableRate,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.Borrow,
+      sender: spokeChain.spokeOperationAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs: '0x',
+    };
+    feeParams.receiverValue = await TsHubLoan.getSendTokenAdapterFees(
+      TSCore.getHubProvider(),
+      network,
+      accountId,
+      tsTokenId,
+      amount,
+      receiverTsChainId,
+      adapters,
+      feeParams
+    );
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams,
+      feeParams.receiverValue
+    );
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.prepare.borrow(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          network,
+          accountId,
+          loanId,
+          tsTokenId,
+          amount,
+          maxStableRate,
+          receiverTsChainId,
+          spokeChain
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async repay(
+    accountId: AccountId,
+    loanId: LoanId,
+    loanTypeId: LoanTypeId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    maxOverRepayment: bigint,
+    adapters: MessageAdapters
+  ): Promise<PrepareRepayCall> {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupportTsToken(
+      tsChain.tsChainId,
+      tsTokenId,
+      tsChain.network
+    );
+    assertLoanTypeSupported(loanTypeId, tsTokenId, tsChain.network);
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const hubChain = getHubChain(tsChain.network);
+
+    const spokeTokenData = getSpokeTokenData(spokeChain, tsTokenId);
+    const hubTokenData = getHubTokenData(tsTokenId, tsChain.network);
+
+    if (spokeTokenData.token.type === TokenType.CROSS_CHAIN)
+      assertAdapterSupportsCrossChainToken(
+        tsChain.tsChainId,
+        spokeTokenData.token,
+        adapters.adapterId
+      );
+    else
+      assertAdapterSupportsDataMessage(tsChain.tsChainId, adapters.adapterId);
+
+    const userAddress = getSignerGenericAddress({
+      signer: TSCore.getTSSigner().signer,
+      chainType: tsChain.chainType,
+    });
+
+    const data: RepayMessageData = {
+      loanId,
+      poolId: hubTokenData.poolId,
+      amount,
+      maxOverRepayment,
+    };
+    const extraArgs: RepayExtraArgs = {
+      token: spokeTokenData.token,
+      recipient: hubTokenData.poolAddress,
+      amount,
+    };
+    const messageBuilderParams: MessageBuilderParams = {
+      userAddress,
+      accountId,
+      adapters,
+      action: Action.Repay,
+      sender: getSpokeTokenData(spokeChain, tsTokenId).spokeAddress,
+      destinationChainId: hubChain.tsChainId,
+      handler: hubChain.hubAddress,
+      data,
+      extraArgs,
+    };
+    const feeParams: OptionalFeeParams = {};
+
+    feeParams.gasLimit = await estimateAdapterReceiveGasLimit(
+      tsChain.tsChainId,
+      hubChain.tsChainId,
+      TSCore.getHubProvider(),
+      tsChain.network,
+      MessageDirection.SpokeToHub,
+      messageBuilderParams
+    );
+    feeParams.returnGasLimit = SEND_TOKEN_ACTION_RETURN_GAS_LIMIT;
+
+    const messageToSend = buildMessageToSend(
+      tsChain.chainType,
+      messageBuilderParams,
+      feeParams
+    );
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.prepare.repay(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          convertFromGenericAddress(userAddress, tsChain.chainType),
+          messageToSend,
+          accountId,
+          loanId,
+          amount,
+          maxOverRepayment,
+          spokeChain,
+          spokeTokenData
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+};
+
+export const write = {
+  async createLoan(
+    accountId: AccountId,
+    nonce: Nonce,
+    loanTypeId: LoanTypeId,
+    loanName: LoanName,
+    prepareCall: PrepareCreateLoanCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.write.createLoan(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          nonce,
+          loanTypeId,
+          loanName,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async deleteLoan(
+    accountId: AccountId,
+    loanId: LoanId,
+    prepareCall: PrepareCreateLoanCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.write.deleteLoan(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          loanId,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async createLoanAndDeposit(
+    accountId: AccountId,
+    nonce: Nonce,
+    loanTypeId: LoanTypeId,
+    loanName: LoanName,
+    amount: bigint,
+    includeApproval: boolean,
+    prepareCall: PrepareCreateLoanAndDepositCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.write.createLoanAndDeposit(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          nonce,
+          loanTypeId,
+          loanName,
+          amount,
+          includeApproval,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async deposit(
+    accountId: AccountId,
+    loanId: LoanId,
+    amount: bigint,
+    includeApproval: boolean,
+    prepareCall: PrepareDepositCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.write.deposit(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          loanId,
+          amount,
+          includeApproval,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async withdraw(
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    isTAmount: boolean,
+    receiverTsChainId: TSChainId,
+    prepareCall: PrepareWithdrawCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    const { poolId } = getHubTokenData(tsTokenId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.write.withdraw(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          loanId,
+          poolId,
+          amount,
+          isTAmount,
+          receiverTsChainId,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async borrow(
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    maxStableRate: bigint,
+    receiverTsChainId: TSChainId,
+    prepareCall: PrepareBorrowCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    const { poolId } = getHubTokenData(tsTokenId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.write.borrow(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          loanId,
+          poolId,
+          amount,
+          maxStableRate,
+          receiverTsChainId,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async repay(
+    accountId: AccountId,
+    loanId: LoanId,
+    amount: bigint,
+    maxOverRepayment: bigint,
+    includeApproval: boolean,
+    prepareCall: PrepareRepayCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    assertSpokeChainSupported(tsChain.tsChainId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.write.repay(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          loanId,
+          amount,
+          maxOverRepayment,
+          includeApproval,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async liquidate(accountId: AccountId, prepareCall: PrepareLiquidateCall) {
+    const tsChain = TSCore.getSelectedTsChain();
+    assertHubChainSelected(tsChain.tsChainId, tsChain.network);
+
+    return await TsHubLoan.write.liquidate(
+      TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+      TSCore.getSigner<ChainType.EVM>(),
+      accountId,
+      prepareCall
+    );
+  },
+  async repayWithCollateral(
+    accountId: AccountId,
+    loanId: LoanId,
+    tsTokenId: TSTokenId,
+    amount: bigint,
+    prepareCall: PrepareRepayWithCollateralCall
+  ) {
+    const tsChain = TSCore.getSelectedTsChain();
+
+    const { poolId } = getHubTokenData(tsTokenId, tsChain.network);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.write.repayWithCollateral(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          TSCore.getSigner<ChainType.EVM>(),
+          accountId,
+          loanId,
+          poolId,
+          amount,
+          prepareCall
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+};
+
+export const read = {
+  async rateLimit(
+    tsTokenId: TSTokenId,
+    tsChainId: TSChainId
+  ): Promise<TokenRateLimit> {
+    const network = TSCore.getSelectedNetwork();
+    const tsChain = getTsChain(tsChainId, network);
+
+    assertSpokeChainSupportTsToken(
+      tsChain.tsChainId,
+      tsTokenId,
+      tsChain.network
+    );
+    const spokeChain = getSpokeChain(tsChain.tsChainId, tsChain.network);
+    const spokeTokenData = getSpokeTokenData(spokeChain, tsTokenId);
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return await TSEvmLoan.read.rateLimitInfo(
+          TSCore.getProvider<ChainType.EVM>(tsChain.tsChainId),
+          spokeTokenData
+        );
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  },
+
+  async loanTypeInfo(loanTypeId: LoanTypeId): Promise<LoanTypeInfo> {
+    const network = TSCore.getSelectedNetwork();
+
+    // filter for all tokens supported in loan type
+    const tokensData = Object.values(getHubTokensData(network)).filter(
+      (tokenData) => tokenData.supportedLoanTypes.has(loanTypeId)
+    );
+
+    return await TsHubLoan.getLoanTypeInfo(
+      TSCore.getHubProvider(),
+      network,
+      loanTypeId,
+      tokensData
+    );
+  },
+
+  async userLoansIds(
+    accountId: AccountId,
+    loanTypeIdsFilter?: Array<LoanTypeId>
+  ): Promise<Map<LoanTypeId, Array<LoanId>>> {
+    const network = TSCore.getSelectedNetwork();
+    return await TsHubLoan.getUserLoanIds(
+      TSCore.getHubProvider(),
+      network,
+      accountId,
+      loanTypeIdsFilter
+    );
+  },
+
+  async userLoans(
+    loanIds: Array<LoanId>,
+    throwErrorOnInactiveLoan = true
+  ): Promise<Map<LoanId, LoanControllerUserLoan>> {
+    const network = TSCore.getSelectedNetwork();
+    return await TsHubLoan.getUserLoans(
+      TSCore.getHubProvider(),
+      network,
+      loanIds,
+      throwErrorOnInactiveLoan
+    );
+  },
+};
+
+export const util = {
+  userLoansInfo(
+    userLoansMap: Map<LoanId, LoanControllerUserLoan>,
+    poolsInfo: Partial<Record<TSTokenId, PoolInfo>>,
+    loanTypesInfo: Partial<Record<LoanTypeId, LoanTypeInfo>>,
+    oraclePrices: OraclePrices,
+    additionalInterests?: AssetsAdditionalInterest
+  ): Record<LoanId, UserLoanInfo> {
+    // get info of each user loan
+    return TsHubLoan.getUserLoansInfo(
+      userLoansMap,
+      poolsInfo,
+      loanTypesInfo,
+      oraclePrices,
+      additionalInterests
+    );
+  },
+
+  emptyLoanForSimulate(
+    accountId: AccountId,
+    loanTypeId: LoanTypeId
+  ): LoanControllerUserLoan {
+    return {
+      accountId,
+      loanTypeId,
+      colPools: [],
+      borPools: [],
+      userLoanCollateral: [],
+      userLoanBorrow: [],
+    };
+  },
+
+  simulateLoanChanges(
+    loan: LoanControllerUserLoan,
+    changes: Array<LoanChange>
+  ): LoanControllerUserLoan {
+    return TsHubLoan.simulateLoanChanges(loan, changes);
+  },
+};