@mezo-org/passport 0.4.0-dev.7 → 0.4.0-dev.71

package/src/hooks/useWatchTransferEvents.ts

@@ -0,0 +1,74 @@
+import { useMemo } from "react"
+import { useAccount, useWatchContractEvent } from "wagmi"
+import {
+  mainnetTokenContracts,
+  MezoChainToken,
+  testnetTokenContracts,
+} from "../lib/contracts"
+import { usePassportContext } from "./usePassportContext"
+import { CHAIN_ID } from "../constants"
+import { useRefreshPassport } from "./useRefreshPassport"
+import { simpleWssMezoConfig } from "../config"
+
+function useWatchTransferEvents(token: MezoChainToken) {
+  const { address: userAddress } = useAccount()
+  const { environment = "mainnet" } = usePassportContext()
+  const { refreshTokensBalances, refreshBorrowData } = useRefreshPassport()
+
+  const contract = useMemo(() => {
+    const contracts =
+      environment === "mainnet" ? mainnetTokenContracts : testnetTokenContracts
+
+    return contracts[token]
+  }, [environment, token])
+
+  useWatchContractEvent({
+    address: contract.address,
+    abi: contract.abi,
+    eventName: "Transfer",
+    args: {
+      from: userAddress,
+    },
+    chainId: CHAIN_ID[environment],
+    enabled: !!userAddress,
+    config: simpleWssMezoConfig,
+    onLogs() {
+      console.log(`[${token}] Transfer from: ${userAddress}`)
+      refreshTokensBalances()
+      refreshBorrowData()
+    },
+  })
+
+  useWatchContractEvent({
+    address: contract.address,
+    abi: contract.abi,
+    eventName: "Transfer",
+    args: {
+      to: userAddress,
+    },
+    chainId: CHAIN_ID[environment],
+    enabled: !!userAddress,
+    config: simpleWssMezoConfig,
+    onLogs() {
+      console.log(`[${token}] Transfer to: ${userAddress}`)
+      refreshTokensBalances()
+      refreshBorrowData()
+    },
+  })
+}
+
+function useWatchTransferEventsForAllTokens() {
+  useWatchTransferEvents("mcbBTC")
+  useWatchTransferEvents("mDAI")
+  useWatchTransferEvents("mFBTC")
+  useWatchTransferEvents("mSolvBTC")
+  useWatchTransferEvents("mswBTC")
+  useWatchTransferEvents("mT")
+  useWatchTransferEvents("mUSDC")
+  useWatchTransferEvents("mUSDe")
+  useWatchTransferEvents("mUSDT")
+  useWatchTransferEvents("mxSolvBTC")
+  useWatchTransferEvents("MUSD")
+}
+
+export { useWatchTransferEvents, useWatchTransferEventsForAllTokens }

package/src/index.ts

@@ -1,6 +1,17 @@
 export * from "./components"
-export * from "./config"
+export {
+  defaultConfig,
+  unisatWalletMezoMainnet,
+  unisatWalletMezoTestnet,
+  okxWalletMezoMainnet,
+  okxWalletMezoTestnet,
+  xverseWalletMezoMainnet,
+  xverseWalletMezoTestnet,
+  getDefaultWallets,
+  getConfig,
+} from "./config"
 export * from "./constants"
 export * from "./hooks"
 export * from "./provider"
 export * from "./wallet"
+export { DISALLOWED_MEZO_ID_PATTERNS } from "./utils/mezoId"

package/src/lib/contracts/index.ts

@@ -0,0 +1,92 @@
+import cbbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mcbBTC.json"
+import daiMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mDAI.json"
+import fbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mFBTC.json"
+import solvbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mSolvBTC.json"
+import swbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mswBTC.json"
+import tMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mT.json"
+import usdcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDC.json"
+import usdeMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDe.json"
+import usdtMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mUSDT.json"
+import xsolvbtcMainnet from "@mezo-org/mezod-contracts/deployments/mainnet/mxSolvBTC.json"
+import musdMainnet from "@mezo-org/musd-contracts/deployments/mainnet/MUSD.json"
+import troveManagerMainnet from "@mezo-org/musd-contracts/deployments/mainnet/TroveManager.json"
+import borrowerOperationsMainnet from "@mezo-org/musd-contracts/deployments/mainnet/BorrowerOperations.json"
+
+import cbbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mcbBTC.json"
+import daiTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mDAI.json"
+import fbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mFBTC.json"
+import solvbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mSolvBTC.json"
+import swbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mswBTC.json"
+import tTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mT.json"
+import usdcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDC.json"
+import usdeTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDe.json"
+import usdtTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mUSDT.json"
+import xsolvbtcTestnet from "@mezo-org/mezod-contracts/deployments/testnet/mxSolvBTC.json"
+import musdTestnet from "@mezo-org/musd-contracts/deployments/matsnet/MUSD.json"
+import troveManagerTestnet from "@mezo-org/musd-contracts/deployments/matsnet/TroveManager.json"
+import borrowerOperationsTestnet from "@mezo-org/musd-contracts/deployments/matsnet/BorrowerOperations.json"
+
+import { Abi, Address } from "viem"
+
+export type MezoChainToken =
+  | "mcbBTC"
+  | "mDAI"
+  | "mFBTC"
+  | "mSolvBTC"
+  | "mswBTC"
+  | "mT"
+  | "mUSDC"
+  | "mUSDe"
+  | "mUSDT"
+  | "mxSolvBTC"
+  | "MUSD"
+
+export type MezoBorrowContract = "TroveManager" | "BorrowerOperations"
+
+type ContractsMap<K extends string> = Record<
+  K,
+  {
+    address: Address
+    abi: Abi
+  }
+>
+
+export const testnetTokenContracts = {
+  mcbBTC: cbbtcTestnet,
+  mDAI: daiTestnet,
+  mFBTC: fbtcTestnet,
+  mSolvBTC: solvbtcTestnet,
+  mswBTC: swbtcTestnet,
+  mT: tTestnet,
+  mUSDC: usdcTestnet,
+  mUSDe: usdeTestnet,
+  mUSDT: usdtTestnet,
+  mxSolvBTC: xsolvbtcTestnet,
+  MUSD: musdTestnet,
+} as unknown as ContractsMap<MezoChainToken>
+
+export const mainnetTokenContracts = {
+  mcbBTC: cbbtcMainnet,
+  mDAI: daiMainnet,
+  mFBTC: fbtcMainnet,
+  mSolvBTC: solvbtcMainnet,
+  mswBTC: swbtcMainnet,
+  mT: tMainnet,
+  mUSDC: usdcMainnet,
+  mUSDe: usdeMainnet,
+  mUSDT: usdtMainnet,
+  mxSolvBTC: xsolvbtcMainnet,
+  MUSD: musdMainnet,
+} as unknown as ContractsMap<MezoChainToken>
+
+export const mainnetBorrowContracts = {
+  TroveManager: troveManagerMainnet,
+  BorrowerOperations: borrowerOperationsMainnet,
+} as unknown as ContractsMap<MezoBorrowContract>
+
+export const testnetBorrowContracts = {
+  TroveManager: troveManagerTestnet,
+  BorrowerOperations: borrowerOperationsTestnet,
+} as unknown as ContractsMap<MezoBorrowContract>
+
+export { default as priceOracleContract } from "./priceOracle"

package/src/lib/contracts/priceOracle.ts

@@ -0,0 +1,53 @@
+import { Address } from "viem"
+
+export default {
+  address: "0x7b7c000000000000000000000000000000000015" as Address,
+  abi: [
+    {
+      inputs: [],
+      name: "decimals",
+      outputs: [
+        {
+          internalType: "uint8",
+          name: "",
+          type: "uint8",
+        },
+      ],
+      stateMutability: "view",
+      type: "function",
+    },
+    {
+      inputs: [],
+      name: "latestRoundData",
+      outputs: [
+        {
+          internalType: "uint80",
+          name: "roundId",
+          type: "uint80",
+        },
+        {
+          internalType: "int256",
+          name: "answer",
+          type: "int256",
+        },
+        {
+          internalType: "uint256",
+          name: "startedAt",
+          type: "uint256",
+        },
+        {
+          internalType: "uint256",
+          name: "updatedAt",
+          type: "uint256",
+        },
+        {
+          internalType: "uint80",
+          name: "answeredInRound",
+          type: "uint80",
+        },
+      ],
+      stateMutability: "view",
+      type: "function",
+    },
+  ] as const,
+}

package/src/provider.ts

@@ -29,7 +29,7 @@ export function PassportProvider({
   portalApiUrl,
   children,
 }: PassportProviderProps) {
-  if (environment !== "mainnet" && environment !== "testnet") {
+  if (environment && !["mainnet", "testnet"].includes(environment)) {
     throw new Error("Wrong environment passed to PassportProvider.")
   }
 

package/src/stores/dropdownStore.ts

@@ -0,0 +1,20 @@
+import { create } from "zustand"
+
+export enum DropdownView {
+  ROOT = "ROOT",
+  RECEIVE = "RECEIVE",
+}
+
+interface DropdownStore {
+  view: DropdownView
+  setView: (view: DropdownView) => void
+  isNestedView: () => boolean
+}
+
+const useDropdownStore = create<DropdownStore>((set, get) => ({
+  view: DropdownView.ROOT,
+  setView: (view: DropdownView) => set({ view }),
+  isNestedView: () => get().view !== DropdownView.ROOT,
+}))
+
+export default useDropdownStore

package/src/utils/address.test.ts

@@ -10,12 +10,6 @@ describe("trimAddress", () => {
     const expected = "0x123...bcdef"
     expect(trimAddress(input)).toBe(expected)
   })
-
-  it("returns lowercase result", () => {
-    const input = "0xABCDEF1234567890"
-    const expected = "0xabc...67890"
-    expect(trimAddress(input)).toBe(expected)
-  })
 })
 
 describe("getAddressExplorerUrl", () => {
@@ -41,4 +35,14 @@ describe("getAddressExplorerUrl", () => {
     const url = getAddressExplorerUrl(evmAddress, "evm", true)
     expect(url).toBe(`https://sepolia.etherscan.io/address/${evmAddress}`)
   })
+
+  it("returns correct mainnet Mezo explorer URL", () => {
+    const url = getAddressExplorerUrl(evmAddress, "mezo", false)
+    expect(url).toBe(`https://explorer.mezo.org/address/${evmAddress}`)
+  })
+
+  it("returns correct testnet Mezo explorer URL", () => {
+    const url = getAddressExplorerUrl(evmAddress, "mezo", true)
+    expect(url).toBe(`https://explorer.test.mezo.org/address/${evmAddress}`)
+  })
 })

package/src/utils/address.ts

@@ -11,14 +11,16 @@ export function trimAddress(address: string): string {
   return trimmedAddress
 }
 
-const MAINNET_EXPLORER_URLS: Record<"bitcoin" | "evm", string> = {
+const MAINNET_EXPLORER_URLS: Record<"bitcoin" | "evm" | "mezo", string> = {
   bitcoin: "https://mempool.space",
   evm: "https://etherscan.io",
+  mezo: "https://explorer.mezo.org",
 }
 
-const TESTNET_EXPLORER_URLS: Record<"bitcoin" | "evm", string> = {
+const TESTNET_EXPLORER_URLS: Record<"bitcoin" | "evm" | "mezo", string> = {
   bitcoin: "https://mempool.space/testnet",
   evm: "https://sepolia.etherscan.io",
+  mezo: "https://explorer.test.mezo.org",
 }
 
 /**
@@ -30,7 +32,7 @@ const TESTNET_EXPLORER_URLS: Record<"bitcoin" | "evm", string> = {
  */
 export function getAddressExplorerUrl(
   address: string,
-  chainType: "bitcoin" | "evm",
+  chainType: "bitcoin" | "evm" | "mezo",
   isTestnet: boolean,
 ) {
   const EXPLORER_URLS = isTestnet

package/src/utils/cryptoAssets.test.ts

@@ -1,59 +1,79 @@
+import { BitcoinCircle, EthCircle, MUsdCircle02 } from "@mezo-org/mezo-clay"
 import {
-  BitcoinCircle,
-  EthCircle,
-  MUsdCircle,
-  TBtcCircle,
-} from "@mezo-org/mezo-clay"
-import { getCryptoAsset } from "./cryptoAssets"
+  CryptoAssetKey,
+  getCryptoAsset,
+  isBitcoinLikeCryptoAsset,
+  isUsdLikeCryptoAsset,
+} from "./cryptoAssets"
+
+// FIXME: Test fails if run in full suite (pnpm test) but works when run in isolation (pnpm test cryptoAssets)
 
 describe("getCryptoAsset", () => {
-  it("returns the correct asset for 'btc'", () => {
-    const asset = getCryptoAsset("btc")
+  it("returns the correct asset for 'BTC (mBTC)'", () => {
+    const asset = getCryptoAsset("BTC")
     expect(asset.name).toBe("Bitcoin")
     expect(asset.symbol).toBe("BTC")
-    expect(asset.decimals).toBe(8)
+    expect(asset.decimals).toBe(18)
     expect(asset.icon).toBe(BitcoinCircle)
   })
 
-  it("returns the correct asset for 'eth'", () => {
-    const asset = getCryptoAsset("eth")
+  it("returns the correct asset for 'ETH'", () => {
+    const asset = getCryptoAsset("ETH")
     expect(asset.name).toBe("Ethereum")
     expect(asset.symbol).toBe("ETH")
     expect(asset.decimals).toBe(18)
     expect(asset.icon).toBe(EthCircle)
   })
 
-  it("returns the correct asset for 'tbtc'", () => {
-    const asset = getCryptoAsset("tbtc")
-    expect(asset.name).toBe("Threshold Bitcoin")
-    expect(asset.symbol).toBe("tBTC")
+  it("returns the correct asset for 'MUSD'", () => {
+    const asset = getCryptoAsset("MUSD")
+    expect(asset.name).toBe("MUSD")
+    expect(asset.symbol).toBe("MUSD")
     expect(asset.decimals).toBe(18)
-    expect(asset.icon).toBe(TBtcCircle)
+    expect(asset.icon).toBe(MUsdCircle02)
   })
+})
 
-  it("returns the correct asset for 'wbtc'", () => {
-    const asset = getCryptoAsset("wbtc")
-    expect(asset.name).toBe("Wrapped Bitcoin")
-    expect(asset.symbol).toBe("wBTC")
-    expect(asset.decimals).toBe(8)
-    // FIXME: Test should expect the exact icon component
-    expect(asset.icon).toEqual(expect.any(Function))
-  })
+describe("isBitcoinLikeCryptoAsset", () => {
+  const cases = [
+    { input: "mcbBTC", expected: true },
+    { input: "mDAI", expected: false },
+    { input: "mFBTC", expected: true },
+    { input: "mSolvBTC", expected: true },
+    { input: "mswBTC", expected: true },
+    { input: "mT", expected: false },
+    { input: "mUSDC", expected: false },
+    { input: "mUSDe", expected: false },
+    { input: "mUSDT", expected: false },
+    { input: "mxSolvBTC", expected: true },
+    { input: "MUSD", expected: false },
+  ]
 
-  it("returns the correct asset for 'mbtc'", () => {
-    const asset = getCryptoAsset("mbtc")
-    expect(asset.name).toBe("Matsnet Bitcoin")
-    expect(asset.symbol).toBe("BTC")
-    expect(asset.decimals).toBe(18)
-    // FIXME: Test should expect the exact icon component
-    expect(asset.icon).toEqual(expect.any(Function))
+  cases.forEach(({ input, expected }) => {
+    it(`returns ${expected} for ${input}`, () => {
+      expect(isBitcoinLikeCryptoAsset(input as CryptoAssetKey)).toBe(expected)
+    })
   })
+})
 
-  it("returns the correct asset for 'musd'", () => {
-    const asset = getCryptoAsset("musd")
-    expect(asset.name).toBe("Mezo USD")
-    expect(asset.symbol).toBe("mUSD")
-    expect(asset.decimals).toBe(18)
-    expect(asset.icon).toBe(MUsdCircle)
+describe("isUsdLikeCryptoAsset", () => {
+  const cases = [
+    { input: "mcbBTC", expected: false },
+    { input: "mDAI", expected: true },
+    { input: "mFBTC", expected: false },
+    { input: "mSolvBTC", expected: false },
+    { input: "mswBTC", expected: false },
+    { input: "mT", expected: false },
+    { input: "mUSDC", expected: true },
+    { input: "mUSDe", expected: true },
+    { input: "mUSDT", expected: true },
+    { input: "mxSolvBTC", expected: false },
+    { input: "MUSD", expected: true },
+  ]
+
+  cases.forEach(({ input, expected }) => {
+    it(`returns ${expected} for ${input}`, () => {
+      expect(isUsdLikeCryptoAsset(input as CryptoAssetKey)).toBe(expected)
+    })
   })
 })

package/src/utils/cryptoAssets.ts

@@ -2,12 +2,15 @@ import {
   BitcoinCircle,
   EthCircle,
   IconProps,
-  MUsdCircle,
-  TBtcCircle,
+  MUsdCircle02,
+  Cryptocurrency04,
 } from "@mezo-org/mezo-clay"
-import { createElement, FC } from "react"
+import { FC } from "react"
+import { MezoChainToken } from "../lib/contracts"
+import { convertToUsd, formatUsd } from "./currency"
+import { fromFixedPointToString } from "./numbers"
 
-export type CryptoAssetKey = "btc" | "eth" | "tbtc" | "wbtc" | "mbtc" | "musd"
+export type CryptoAssetKey = MezoChainToken | "BTC" | "ETH"
 
 export type CryptoAsset = {
   name: string
@@ -16,51 +19,85 @@ export type CryptoAsset = {
   decimals: number
 }
 
+// TODO: Add actual icons for the assets
+
 const CRYPTO_ASSETS: Record<CryptoAssetKey, CryptoAsset> = {
-  btc: {
+  BTC: {
     name: "Bitcoin",
     symbol: "BTC",
     icon: BitcoinCircle,
-    decimals: 8,
+    decimals: 18,
   },
-  eth: {
+  ETH: {
     name: "Ethereum",
     symbol: "ETH",
     icon: EthCircle,
     decimals: 18,
   },
-  tbtc: {
-    name: "Threshold Bitcoin",
-    symbol: "tBTC",
-    icon: TBtcCircle,
+  MUSD: {
+    name: "MUSD",
+    symbol: "MUSD",
+    icon: MUsdCircle02,
+    decimals: 18,
+  },
+  mDAI: {
+    name: "mDAI",
+    symbol: "mDAI",
+    icon: Cryptocurrency04,
     decimals: 18,
   },
-  wbtc: {
-    name: "Wrapped Bitcoin",
-    symbol: "wBTC",
-    icon: (props) =>
-      createElement(BitcoinCircle, {
-        ...props,
-        symbolColor: "#FF8A00",
-        color: "#000000",
-      }),
+  mFBTC: {
+    name: "mFBTC",
+    symbol: "mFBTC",
+    icon: BitcoinCircle,
     decimals: 8,
   },
-  mbtc: {
-    name: "Matsnet Bitcoin",
-    symbol: "BTC",
-    icon: (props) =>
-      createElement(BitcoinCircle, {
-        ...props,
-        symbolColor: "#000000",
-        color: "#FFC907",
-      }),
+  mcbBTC: {
+    name: "mcbBTC",
+    symbol: "mcbBTC",
+    icon: BitcoinCircle,
+    decimals: 8,
+  },
+  mSolvBTC: {
+    name: "mSolvBTC",
+    symbol: "mSolvBTC",
+    icon: BitcoinCircle,
     decimals: 18,
   },
-  musd: {
-    name: "Mezo USD",
-    symbol: "MUSD",
-    icon: MUsdCircle,
+  mswBTC: {
+    name: "mswBTC",
+    symbol: "mswBTC",
+    icon: BitcoinCircle,
+    decimals: 8,
+  },
+  mT: {
+    name: "mT",
+    symbol: "mT",
+    icon: Cryptocurrency04,
+    decimals: 18,
+  },
+  mUSDC: {
+    name: "mUSDC",
+    symbol: "mUSDC",
+    icon: Cryptocurrency04,
+    decimals: 6,
+  },
+  mUSDe: {
+    name: "mUSDe",
+    symbol: "mUSDe",
+    icon: Cryptocurrency04,
+    decimals: 18,
+  },
+  mUSDT: {
+    name: "mUSDT",
+    symbol: "mUSDT",
+    icon: Cryptocurrency04,
+    decimals: 6,
+  },
+  mxSolvBTC: {
+    name: "mxSolvBTC",
+    symbol: "mxSolvBTC",
+    icon: BitcoinCircle,
     decimals: 18,
   },
 }
@@ -80,7 +117,7 @@ export function getCryptoAsset(key: CryptoAssetKey) {
  * @returns True if crypto asset is Bitcoin-like
  */
 export function isBitcoinLikeCryptoAsset(key: CryptoAssetKey) {
-  return ["btc", "tbtc", "wbtc", "mbtc"].includes(key)
+  return /(btc)/i.test(key)
 }
 
 /**
@@ -89,5 +126,46 @@ export function isBitcoinLikeCryptoAsset(key: CryptoAssetKey) {
  * @returns True if crypto asset is USD-like
  */
 export function isUsdLikeCryptoAsset(key: CryptoAssetKey) {
-  return ["musd"].includes(key)
+  return /(usd|dai)/i.test(key)
+}
+
+/**
+ * Formats crypto asset to balance details (balance in USD and decimals)
+ * @param type The type of crypto asset
+ * @param balance The balance of crypto asset
+ * @param usdConversionRate The USD conversion rate
+ * @returns The balance details
+ */
+export function mapCryptoAssetToDetails(
+  type: CryptoAssetKey,
+  balance: bigint,
+  usdConversionRate: bigint,
+  usdConversionRateDecimals: number,
+) {
+  const { decimals } = getCryptoAsset(type)
+
+  const formattedBalance = fromFixedPointToString(
+    balance,
+    decimals,
+    isUsdLikeCryptoAsset(type) ? 2 : 4,
+  )
+
+  const usdBalance = convertToUsd(
+    balance,
+    decimals,
+    usdConversionRate,
+    usdConversionRateDecimals,
+  )
+
+  const formattedUsdBalance = formatUsd(usdBalance)
+
+  return {
+    type,
+    rawBalance: balance,
+    formattedBalance,
+    usdBalance,
+    formattedUsdBalance,
+  }
 }
+
+export type DetailedCryptoAsset = ReturnType<typeof mapCryptoAssetToDetails>

package/src/utils/currency.test.ts

@@ -36,3 +36,5 @@ describe("formatUsd", () => {
     expect(result).toBe("$0.00")
   })
 })
+
+// TODO: Add tests for convertToUsd function

package/src/utils/currency.ts

@@ -1,3 +1,5 @@
+import { fromFixedPoint } from "./numbers"
+
 const DEFAULT_FORMAT_OPTIONS: Intl.NumberFormatOptions = {
   style: "currency",
   minimumFractionDigits: 2,
@@ -30,3 +32,22 @@ export function formatCurrency(
 export function formatUsd(value: number): string {
   return formatCurrency(value, { currency: "USD" })
 }
+
+/**
+ * Converts an asset amount to USD based on a conversion rate and decimals
+ * @param assetAmount - The amount of the asset in its smallest unit (e.g., satoshis for BTC)
+ * @param conversionRate - The conversion rate from the asset to USD in fixed-point format
+ * @param decimals - The number of decimals for the asset
+ * @returns - The value in USD as a number
+ */
+export function convertToUsd(
+  assetAmount: bigint,
+  assetDecimals: number,
+  conversionRate: bigint,
+  conversionRateDecimals: number,
+): number {
+  return fromFixedPoint(
+    (assetAmount * conversionRate) / 10n ** BigInt(conversionRateDecimals),
+    assetDecimals,
+  )
+}