@rhea-finance/cross-chain-sdk

Cross-chain lending SDK that supports unified lending operations across multiple blockchains, including EVM chains, Solana, Bitcoin, and NEAR.

Features

• 🔗 Cross-chain Support: Supports multi-chain operations on EVM, Solana, Bitcoin, and NEAR
• 💰 Lending Functions: Provides complete lending functionality including Supply, Borrow, Repay, Withdraw, etc.
• 📊 Data Queries: Supports querying asset information, portfolio, prices, balances, and other data
• 🏥 Health Factor: Automatically calculates and manages lending health factors
• 💼 Multi-chain Account (MCA): Supports creating and managing multi-chain accounts to unify multi-chain asset management
• 🔐 Wallet Management: Supports adding and removing multi-chain wallets
• 📈 Liquidity Mining: Supports liquidity mining and reward queries
• ⚡ Batch Queries: Provides batch view queries to reduce RPC call frequency

Supported Blockchains

• EVM Chains: Ethereum, Arbitrum, Optimism, Base, BNB Chain, etc.
• Solana
• Bitcoin
• NEAR Protocol

Installation

npm install @rhea-finance/cross-chain-sdk
# or
pnpm add @rhea-finance/cross-chain-sdk
# or
yarn add @rhea-finance/cross-chain-sdk

Quick Start

Basic Usage

// Type imports
import type {
  ILendingData,
  IAccountAllPositionsDetailed,
  IAssetDetailed,
  IConfig,
  IPythInfo,
  IMetadata,
  IAssetFarm,
  IPrices,
  Portfolio,
} from "@rhea-finance/cross-chain-sdk";

// Function imports
import {
  batchViews,
  getAccountAllPositions,
  getAssetsDetail,
  getConfig,
  getTokenPythInfos,
  getAllMetadata,
  getMetadata,
  getBalance,
  getAllFarms,
  getPrices,
} from "@rhea-finance/cross-chain-sdk";

// Batch query - get all data at once
const lendingData: ILendingData = await batchViews(accountId);
console.log(lendingData.account_all_positions);
console.log(lendingData.assets_paged_detailed);
console.log(lendingData.config);
console.log(lendingData.token_pyth_infos);

// Individual queries - get data separately

// Get account all positions
const accountAllPositions: IAccountAllPositionsDetailed = await getAccountAllPositions(accountId);
// Get assets detail
const assetsPagedDetailed: IAssetDetailed[] = await getAssetsDetail();

// Get config
const config: IConfig = await getConfig();

// Get token pyth infos
const tokenPythInfos: Record<string, IPythInfo> = await getTokenPythInfos();

// Get metadata - batch query
const tokenIds = ["usdt.tether-token.near", "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1", "zec.omft.near"];
const allMetadata: IMetadata[] = await getAllMetadata(tokenIds);

// Get metadata - single query
const metadata: IMetadata | undefined = await getMetadata("token1.near");

// Get balance - get token balance in NEAR wallet
const balance: string = await getBalance("usdt.tether-token.near", accountId);

// Get all farms - get all lending farm data
const allFarms: [Record<string, string>, IAssetFarm][] = await getAllFarms();

// Get prices - get price data for all assets in lending
const prices: IPrices | undefined = await getPrices({
  token_pyth_infos: tokenPythInfos,
  config: config,
});

Multi-chain Account (MCA) Management

// Import MCA related functions separately
import {
  getMcaByWallet,
  getListWalletsByMca,
  getCreateMcaFee,
  getCreateMcaFeePaged,
  getNearValue,
  getNearValuesPaged,
  getZcashCreateMcaDepositAddress,
  getZcashResponseDataByAddress,
} from "@rhea-finance/cIChainross-chain-sdk";
import type { , IWallet } from "@rhea-finance/cross-chain-sdk";

// Get MCA by wallet - query multi-chain account based on logged-in wallet
// Parameters:
//   chain: Supported chain type, currently supports "evm", "solana", "btc"
//   identityKey: Unique identifier of the logged-in account on the specified chain
//     - evm: Account ID (e.g., "0x1234...")
//     - solana: Account ID (e.g., "ABC123...")
//     - btc: Public key (e.g., "02abc123...")
const mcaId: string | null = await getMcaByWallet({
  chain: "evm" as IChain,
  identityKey: "0x1234...",
});

// Get list wallets by MCA - query all wallets bound to a multi-chain account
const wallets: IWallet[] = await getListWalletsByMca(mcaId);

// Get create MCA fee - get creation fee for a specific asset
const createFee: string = await getCreateMcaFee("usdt.tether-token.near");

// Get create MCA fee paged - get list of creation fee tokens
const createFeeList: Record<string, string> = await getCreateMcaFeePaged();

// Get near value - get exchange rate between a specific token and NEAR
const nearValue: string = await getNearValue("usdt.tether-token.near");

// Get near values paged - get all token exchange rates with NEAR
const nearValues: Record<string, string> = await getNearValuesPaged();

// Get Zcash create MCA deposit address - get deposit address when creating MCA with Zcash (Old way)
const zcashDepositAddress: string = await getZcashCreateMcaDepositAddress("multica.near");

// Get Zcash response data by address - query Zcash deposit/creation status (Old way)
const zcashData = await getZcashResponseDataByAddress(address);

Operations

Create Multi-chain Account (MCA)

The following steps describe how to create a multi-chain account:

import type {
  IChain,
  IIntentsQuoteResult,
  Asset,
} from "@rhea-finance/cross-chain-sdk";
import {
  format_wallet,
  serializationObj,
  getCreateMcaCustomRecipientMsg,
  getCreateMcaFeeData,
  intentsQuotation,
  prepare_sign_message_evm,
  process_signature_evm,
} from "@rhea-finance/cross-chain-sdk";

// Step 1: Create multi-chain wallet
const w = format_wallet({
  chain: "evm" as IChain,
  identityKey: "0x1234...",
});

// Step 2: Sign
// Signing content
const message = serializationObj([w]);

// Format signing content
const _message = prepare_sign_message_evm(message);

// Sign (this is a wallet SDK method, not from this SDK)
const signature = signMessage(_message);

// Process signature result
const signedMessage = process_signature_evm(signature);

// Step 3: Get customRecipientMsg
// useAsCollateral parameter determines whether these assets should be used as collateral.
const customRecipientMsg = getCreateMcaCustomRecipientMsg({
  useAsCollateral: true,
  wallets: [w],
  signedMessages: [signedMessage],
});

// Step 4: Get create MCA fee data
// Get the on-chain fee for creating an MCA account
// Parameters:
//   asset: The Asset object
//   bufferMultiple: Optional buffer multiplier (default 1.05)
const mcaFee = await getCreateMcaFeeData({
  asset: asset,
  bufferMultiple: 1.05, // optional, default 1.05
});
// mcaFee.amountRaw     - fee amount with token precision (for contract calls)
// mcaFee.amountReadable - human-readable fee amount

// Step 5: Get intents quote to obtain depositAddress
const res_quote: IIntentsQuoteResult = await intentsQuotation({
  originAsset: "nep141:xxx",
  destinationAsset: "nep141:xxx",
  amount: "14743",
  refundTo: "0xxxx",
  recipient: "multica.near",
  isReverse: false,
  dry: false,
  slippageTolerance: 50,
  customRecipientMsg: customRecipientMsg,
});

// Step 6: Get depositAddress and transfer funds to complete MCA creation
const depositAddress = res_quote.quoteSuccessResult?.quote?.depositAddress;

// Step 7: Calculate total fee
// Total fee = MCA creation fee + intents quotation fee (cross-chain bridge/swap fee)
// quoteFeeData is returned by intentsQuotation when quoteStatus is "success"
//   quoteFeeData.feeAmount - bridge/swap fee amount (readable)
//   quoteFeeData.feeUsd    - bridge/swap fee in USD
const quoteFee = res_quote.quoteFeeData;
// Total fee (readable) = mcaFee.amountReadable + quoteFee.feeAmount
// Total fee (USD)       = mcaFee amount in USD  + quoteFee.feeUsd

// Transfer funds to depositAddress using your wallet

Create MCA via Zcash (Old way)

When creating an MCA account with Zcash, use getZcashCreateMcaDepositAddress to obtain the deposit address:

import { getZcashCreateMcaDepositAddress } from "@rhea-finance/cross-chain-sdk";

// Get deposit address for Zcash MCA creation
// Parameters:
//   am_id: Account manager ID (e.g., "multica.near")
const depositAddress: string = await getZcashCreateMcaDepositAddress("multica.near");

// Transfer Zcash to depositAddress to complete MCA creation

getZcashResponseDataByAddress (Old way)

Get Zcash deposit/creation data by address. Query the status and details of a Zcash MCA creation or adding wallet flow:

import {
  getZcashResponseDataByAddress,
  type IDataByAddressResponse,
} from "@rhea-finance/cross-chain-sdk";

// Parameters:
//   address: Zcash deposit address
const data: IDataByAddressResponse | undefined =
  await getZcashResponseDataByAddress(address);

// data contains: deposit_address, mca_id, status, tx_hash, application, etc.

Cross-chain Supply

import {
  getSupplyCustomRecipientMsg,
  format_wallet,
  intentsQuotation,
  config_near,
} from "@rhea-finance/cross-chain-sdk";

const wallet = format_wallet({ chain, identityKey });
const customRecipientMsg = getSupplyCustomRecipientMsg({
  useAsCollateral: true,
  w: wallet,
});

const quoteResult = await intentsQuotation({
  recipient: "rhea00000x.multica.near", // or mca account address
  customRecipientMsg,
  // ... other parameters
});

// Transfer to depositAddress
const depositAddress = quoteResult.quoteSuccessResult?.quote?.depositAddress;

getSupplyDepositData

Get supply deposit address and quote result, simplifies Cross-chain Supply flow:

import { getSupplyDepositData } from "@rhea-finance/cross-chain-sdk";

// Parameters:
//   chain: Chain type, supports "evm" | "solana" | "btc"
//   identityKey: Wallet address or public key
//   useAsCollateral: Whether to use as collateral
//   originAsset: Origin asset (e.g. "nep141:usdt.tether-token.near")
//   destinationAsset: Destination asset
//   amount: Amount (raw amount)
//   refundTo: Refund address
//   recipient: MCA account address
const result = await getSupplyDepositData({
  chain: "evm",
  identityKey: "0x1234...",
  useAsCollateral: true,
  originAsset: "nep141:usdt.tether-token.near",
  destinationAsset: "nep141:wrap.near",
  amount: "1000000",
  refundTo: "rhea00000x.multica.near",
  recipient: "rhea00000x.multica.near",
});

// Transfer to depositAddress to complete Supply
const depositAddress = result.depositAddress;
// result also contains quoteResult's full quote data

// quoteFeeData - cross-chain bridge/swap fee (present when quote succeeds)
const quoteFeeData = result.quoteResult?.quoteFeeData;
// quoteFeeData.feeAmount - bridge/swap fee amount (readable)
// quoteFeeData.feeUsd    - bridge/swap fee in USD

Cross-chain Repay

import {
  getRepayCustomRecipientMsg,
  format_wallet,
  intentsQuotation,
  config_near,
} from "@rhea-finance/cross-chain-sdk";

const wallet = format_wallet({ chain, identityKey });
const customRecipientMsg = getRepayCustomRecipientMsg({
  w: wallet,
});

const quoteResult = await intentsQuotation({
  recipient: "rhea00000x.multica.near", // or mca account address
  customRecipientMsg,
  // ... other parameters
});

// Transfer to depositAddress
const depositAddress = quoteResult.quoteSuccessResult?.quote?.depositAddress;

Cross-chain Borrow

// Get simple withdraw data
// simpleWithdrawData: Extract a portion of assets from user's lending assets to pay the relayer
// User pays relayer's gas fees and NEAR required for registration
// Parameters:
//   nearStorageAmount: NEAR storage amount
//   mca: Multi-chain account ID
//   relayerGasFees: Relayer gas fees for different chains
//   assets: Assets data (from getAssets() or batchViews())
//   portfolio: Portfolio data (from getAccountAllPositions() or batchViews())
const simpleWithdrawData: ISimpleWithdraw | null = computeRelayerGas({
  nearStorageAmount,
  mca,
  relayerGasFees,
  assets,
  portfolio
})

// Prepare borrow business data
// Parameters:
//   amountBurrow: Amount of assets to withdraw from lending (precision required by lending contract)
//   amountToken: Amount of assets to withdraw from lending (precision of the token)
//   config: Configuration data (from getConfig() or batchViews())
//   simpleWithdrawData: Simple withdraw data (see above for details)
const { businessMap, quoteResult } = await prepareBusinessDataOnBorrow({
  mca,
  recipient: "0x7dxxx...",
  tokenId: "usdt.tether-token.near",
  originAsset: "nep141:usdt.tether-token.near",
  destinationAsset: "xxxx",
  amountBurrow,
  amountToken,
  config: config,
  simpleWithdrawData: simpleWithdrawData,
});

const wallet = format_wallet({ chain, identityKey });
const signedBusiness = await sign_message({
  chain,
  message: serializationObj(businessMap),
});

// Submit multi-chain lending request
const relayer_result = await postMultichainLendingRequests({
  mca_id: mca,
  wallet: serializationObj(wallet),
  request: [
    serializationObj({
      signer_wallet: wallet,
      business: businessMap,
      signature: signedBusiness,
      attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
    }),
  ],
});

// Poll transaction result
if (relayer_result?.code == 0) {
  const { status, tx_hash } = await pollingRelayerTransactionResult(
    relayer_result.data,
    2000
  );
  console.log("Transaction status:", status);
  console.log("Transaction hash:", tx_hash);
}

Cross-chain Withdraw

// Get simple withdraw data (see Cross-chain Borrow section for detailed explanation)
const simpleWithdrawData: ISimpleWithdraw | null = await computeRelayerGas({
  nearStorageAmount,
  mca,
  relayerGasFees,
  assets,
  portfolio
})

// Prepare withdraw business data
// Parameters:
//   amountBurrow: Amount of assets to withdraw from lending (precision required by lending contract)
//   amountToken: Amount of assets to withdraw from lending (precision of the token)
//   config: Configuration data (from getConfig() or batchViews())
//   simpleWithdrawData: Simple withdraw data (see Cross-chain Borrow section for details)
//   isDecrease: Whether to decrease collateral
//   decreaseCollateralAmount: Amount to decrease collateral (if isDecrease is true)
const { businessMap, quoteResult } = await prepareBusinessDataOnWithdraw({
  mca,
  recipient: "0x7dxxx...",
  tokenId: "usdt.tether-token.near",
  originAsset: "nep141:usdt.tether-token.near",
  destinationAsset: "xxxx",
  amountBurrow,
  amountToken,
  config: config,
  simpleWithdrawData,
  isDecrease: false,
  decreaseCollateralAmoun,
});

// quoteFeeData - cross-chain bridge/swap fee (present when quote succeeds)
const quoteFeeData = quoteResult?.quoteFeeData;
// quoteFeeData.feeAmount - bridge/swap fee amount (readable)
// quoteFeeData.feeUsd    - bridge/swap fee in USD

const wallet = format_wallet({ chain, identityKey });
const signedBusiness = await sign_message({
  chain,
  message: serializationObj(businessMap),
});

// Submit multi-chain lending request
const relayer_result = await postMultichainLendingRequests({
  mca_id: mca,
  wallet: serializationObj(wallet),
  request: [
    serializationObj({
      signer_wallet: wallet,
      business: businessMap,
      signature: signedBusiness,
      attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
    }),
  ],
});

// Poll transaction result
if (relayer_result?.code == 0) {
  const { status, tx_hash } = await pollingRelayerTransactionResult(
    relayer_result.data,
    2000
  );
  console.log("Transaction status:", status);
  console.log("Transaction hash:", tx_hash);
}

Add Wallet to MCA

// Step 1: the new wallet to add
const newWallet = {
  chain: "xxx",
  identityKey,
}
const add_w = format_wallet({
  chain: newWallet.chain,
  identityKey: newWallet.identityKey,
});

// Step 2: Sign the new wallet with the new wallet itself
// Signing content: mca + serialized wallet
const signature_new_wallet = await sign_message({
  chain: newWallet.chain,
  message: mca + serializationObj(add_w),
});

// Step 3: Prepare add wallet business data
// Parameters:
//   mca: Multi-chain account ID
//   w: Wallet to add (formatted using format_wallet)
//   signature_w: Signature of the new wallet (signed by the new wallet itself)
//   gas_token_id: Token ID for gas payment
//   gas_token_amount: Amount of gas token
const businessMap = await prepareBusinessDataOnAddWallet({
  mca: "rhea00000x.multica.near",
  w: add_w,
  signature_w: signature_new_wallet,
  gas_token_id: "usdt.tether-token.near",
  gas_token_amount: "1000000",
});

// Step 4: Sign the business data with the signer wallet
const signerWallet = { chain: "xxx", identityKey };
const sign_w = format_wallet({ signerWallet.chain, signerWallet.identityKey });
const signedBusiness = await sign_message({
  chain: signerWallet.chain,
  message: serializationObj(businessMap),
});

// Submit multi-chain lending request
const relayer_result = await postMultichainLendingRequests({
  mca_id: mca,
  wallet: serializationObj(sign_w),
  request: [
    serializationObj({
      signer_wallet: sign_w,
      business: businessMap,
      signature: signedBusiness,
      attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
    }),
  ],
});

// Poll transaction result
if (relayer_result?.code == 0) {
  const { status, tx_hash } = await pollingRelayerTransactionResult(
    relayer_result.data,
    2000
  );
  console.log("Transaction status:", status);
  console.log("Transaction hash:", tx_hash);
}

Remove Wallet from MCA

// Prepare remove wallet business data
// Parameters:
//   mca: Multi-chain account ID
//   w: Wallet to remove (formatted using format_wallet)
//   gas_token_id: Token ID for gas payment
//   gas_token_amount: Amount of gas token
const removeWallet = {
  chain: "xxx",
  identityKey,
}
const remove_w = format_wallet({ chain: removeWallet.chain, identityKey: removeWallet.identityKey });
const businessMap = await prepareBusinessDataOnRemoveWallet({
  mca: "rhea00000x.multica.near",
  w: _removeWallet,
  gas_token_id: "usdt.tether-token.near",
  gas_token_amount: "1000000",
});

// Sign the business data with the signer wallet
const signerWallet = { chain: "xxx", identityKey };
const _signerWallet = format_wallet({ chain: signerWallet.chain, identityKey: signerWallet.identityKey });
const signedBusiness = await sign_message({
  chain: _signerWallet.chain,
  message: serializationObj(businessMap),
});

// Submit multi-chain lending request
const relayer_result = await postMultichainLendingRequests({
  mca_id: mca,
  wallet: serializationObj(_signerWallet),
  request: [
    serializationObj({
      signer_wallet: _signerWallet,
      business: businessMap,
      signature: signedBusiness,
      attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
    }),
  ],
});

// Poll transaction result
if (relayer_result?.code == 0) {
  const { status, tx_hash } = await pollingRelayerTransactionResult(
    relayer_result.data,
    2000
  );
  console.log("Transaction status:", status);
  console.log("Transaction hash:", tx_hash);
}

Adjust Collateral

// Get simple withdraw data (see Cross-chain Borrow section for detailed explanation)
const simpleWithdrawData: ISimpleWithdraw | null = await computeRelayerGas({
  nearStorageAmount,
  mca,
  relayerGasFees,
  assets,
  portfolio
})

// Prepare adjust business data
// Parameters:
//   mca: Multi-chain account ID
//   tokenId: Token ID to adjust
//   config: Configuration data (from getConfig() or batchViews())
//   simpleWithdrawData: Simple withdraw data (see Cross-chain Borrow section for details)
//   isIncreaseCollateral: Whether to increase collateral
//   increaseAmountBurrow: Amount to increase collateral (if isIncreaseCollateral is true)
//   isDecreaseCollateral: Whether to decrease collateral
//   decreaseAmountBurrow: Amount to decrease collateral (if isDecreaseCollateral is true)
const businessMap = await prepareBusinessDataOnAdjust({
  mca: "rhea00000x.multica.near",
  tokenId: "usdt.tether-token.near",
  config: config,
  simpleWithdrawData: simpleWithdrawData,
  isIncreaseCollateral: true,
  increaseAmountBurrow,
  isDecreaseCollateral: false,
  decreaseAmountBurrow,
});

const wallet = format_wallet({ chain, identityKey });
const signedBusiness = await sign_message({
  chain,
  message: serializationObj(businessMap),
});

// Submit multi-chain lending request
const relayer_result = await postMultichainLendingRequests({
  mca_id: mca,
  wallet: serializationObj(wallet),
  request: [
    serializationObj({
      signer_wallet: wallet,
      business: businessMap,
      signature: signedBusiness,
      attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
    }),
  ],
});

// Poll transaction result
if (relayer_result?.code == 0) {
  const { status, tx_hash } = await pollingRelayerTransactionResult(
    relayer_result.data,
    2000
  );
  console.log("Transaction status:", status);
  console.log("Transaction hash:", tx_hash);
}

Repay from Supplied

// Get simple withdraw data (see Cross-chain Borrow section for detailed explanation)
const simpleWithdrawData: ISimpleWithdraw | null = await computeRelayerGas({
  nearStorageAmount,
  mca,
  relayerGasFees,
  assets,
  portfolio
})

// Prepare repay from supplied business data
// Parameters:
//   mca: Multi-chain account ID
//   tokenId: Token ID to repay
//   config: Configuration data (from getConfig() or batchViews())
//   simpleWithdrawData: Simple withdraw data (see Cross-chain Borrow section for details)
//   amountBurrow: Amount to repay (precision required by lending contract)
//   decreaseAmountBurrow: Amount to decrease collateral (precision required by lending contract)
const businessMap = await prepareBusinessDataOnRepayFromSupplied({
  mca: "rhea00000x.multica.near",
  tokenId: "usdt.tether-token.near",
  config: config,
  simpleWithdrawData: simpleWithdrawData,
  amountBurrow,
  decreaseAmountBurrow,
});

const wallet = format_wallet({ chain, identityKey });
const signedBusiness = await sign_message({
  chain,
  message: serializationObj(businessMap),
});

// Submit multi-chain lending request
const relayer_result = await postMultichainLendingRequests({
  mca_id: mca,
  wallet: serializationObj(wallet),
  request: [
    serializationObj({
      signer_wallet: wallet,
      business: businessMap,
      signature: signedBusiness,
      attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
    }),
  ],
});

// Poll transaction result
if (relayer_result?.code == 0) {
  const { status, tx_hash } = await pollingRelayerTransactionResult(
    relayer_result.data,
    2000
  );
  console.log("Transaction status:", status);
  console.log("Transaction hash:", tx_hash);
}

Claim Rewards

// Prepare claim business data
// Parameters:
//   mca: Multi-chain account ID
//   gas_token_id: Token ID for gas payment
//   gas_token_amount: Amount of gas token
const businessMap = await prepareBusinessDataOnClaim({
  mca: "rhea00000x.multica.near",
  gas_token_id: "usdt.tether-token.near",
  gas_token_amount: "1000000",
});

const wallet = format_wallet({ chain, identityKey });
const signedBusiness = await sign_message({
  chain,
  message: serializationObj(businessMap),
});

// Submit multi-chain lending request
const relayer_result = await postMultichainLendingRequests({
  mca_id: mca,
  wallet: serializationObj(wallet),
  request: [
    serializationObj({
      signer_wallet: wallet,
      business: businessMap,
      signature: signedBusiness,
      attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
    }),
  ],
});

// Poll transaction result
if (relayer_result?.code == 0) {
  const { status, tx_hash } = await pollingRelayerTransactionResult(
    relayer_result.data,
    2000
  );
  console.log("Transaction status:", status);
  console.log("Transaction hash:", tx_hash);
}

Get farm details for an asset

import {
  getFarmDetailsOfAsset,
  getAssetDetailsView,
} from "@rhea-finance/cross-chain-sdk";

// Get assets view (IAssetsView)
const assets = await getAssetDetailsView();

// Get farm details for a specific asset
const farmDetails = getFarmDetailsOfAsset({
  assets,
  assetId: "zec.omft.near",
  booster: 1.5, // optional, default 1.5
});

// farmDetails: IFarmDetailsOfAsset
console.log(farmDetails.minFarmApy);    // market farm APY (min)
console.log(farmDetails.maxFarmApy);    // max farm APY (with booster)
console.log(farmDetails.tokenNetRewards); // reward token metadata
console.log(farmDetails.canBeBooster);  // whether asset can be boosted
console.log(farmDetails.supplyApy);     // supply APR (%)
console.log(farmDetails.borrowApy);    // borrow APR (%)

Cross-chain Withdraw Rewards

import {
  prepareBusinessDataOnWithdrawRewards,
  getUnclaimedRewards,
  batchViewsData,
  getSimpleWithdrawData,
  format_wallet,
  serializationObj,
  NDeposit,
  TOKEN_STORAGE_DEPOSIT_READ,
  postMultichainLendingRequests,
  pollingRelayerTransactionResult,
} from "@rhea-finance/cross-chain-sdk";

// Get assets, portfolio and config (e.g. for MCA)
const mca = "your_mca_id";
const { assetsView, portfolioView, config } = await batchViewsData(mca);

// Get unclaimed rewards and pick one to withdraw
const unclaimedRewards = getUnclaimedRewards({ portfolioView, assetsView });
const unclaimedReward = unclaimedRewards[0];

// Get simple withdraw data (relayer gas)
const gasData = await getSimpleWithdrawData({
  nearStorageAmount: "0.00125",
  mca,
  assets: assetsView,
  portfolio: portfolioView,
  businessNum: 2, // optional
});
const simpleWithdrawData = gasData?.simpleWithdrawData ?? null;

// Prepare withdraw rewards business data
const receiveTokenId = "zec.omft.near";
const originAsset = "1cs_v1:near:nep141:zec.omft.near";
const destinationAsset = "nep141:zec.omft.near";
const recipient = "t1dsFgNR2nr99MJ7Dq2Wwk3d4EnUs43ATqY";

const res = await prepareBusinessDataOnWithdrawRewards({
  mca,
  rewardTokenId: unclaimedReward?.rewardTokenId,
  amountBurrow: unclaimedReward?.amountBurrow,
  amountToken: unclaimedReward?.amountToken,
  config,
  simpleWithdrawData,
  receiveTokenId,
  originAsset,
  destinationAsset,
  recipient,
});

if (res.status === "success") {
  const { businessMap, businessMapExtra } = res;
  const signedBusiness = await sign_message({
    message: JSON.stringify(businessMap),
  });
  const signedBusinessExtra = await sign_message({
    message: JSON.stringify(businessMapExtra),
  });

  const wallet = format_wallet({ chain, identityKey });
  const relayer_result = await postMultichainLendingRequests({
    mca_id: mca,
    wallet: serializationObj(wallet),
    request: [
      serializationObj({
        signer_wallet: wallet,
        business: businessMap,
        signature: signedBusiness,
        attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
      }),
      serializationObj({
        signer_wallet: wallet,
        business: businessMapExtra,
        signature: signedBusinessExtra,
        attach_deposit: NDeposit(TOKEN_STORAGE_DEPOSIT_READ),
      }),
    ],
  });

  if (relayer_result?.code === 0) {
    const { status, tx_hash } = await pollingRelayerTransactionResult(
      relayer_result.data,
      2000
    );
    console.log("Transaction status:", status);
    console.log("Transaction hash:", tx_hash);
  }
} else {
  console.error("Prepare failed:", res.message);
}

Core API

Actions

Account Management

• createMca - Create multi-chain account
• addWallet - Add wallet to MCA
• removeWallet - Remove wallet from MCA

Lending Operations

• supply - Supply (deposit)
• borrow - Borrow
• repay - Repay
• repayFromSupplied - Repay from supplied assets
• withdraw - Withdraw
• adjust - Adjust collateral
• innnerWithdraw - Inner withdraw
• claim - Claim rewards

Views

• batchViews - Batch query views (account, assets, config, etc.)
• getAssets - Get asset list
• getPrices - Get price information
• getBalance - Get balance
• getFarms - Get liquidity mining information
• getFarmDetailsOfAsset - Get farm details (APY, rewards, canBeBooster) for an asset
• getConfig - Get configuration
• getBoosterTokens - Get booster token information
• getTokenDetail - Get token details
• getLiquidations - Get liquidation information
• getMultichainLendingHistory - Get multi-chain lending history

Health Factor Calculation

• recomputeHealthFactorSupply - Calculate health factor after supply
• recomputeHealthFactorBorrow - Calculate health factor after borrow
• recomputeHealthFactorRepay - Calculate health factor after repay
• recomputeHealthFactorWithdraw - Calculate health factor after withdraw
• recomputeHealthFactorAdjust - Calculate health factor after adjusting collateral

Maximum Available Amount

• getBorrowMaxAmount - Get maximum borrowable amount
• getWithdrawMaxAmount - Get maximum withdrawable amount

Core Utilities

Lending Operations

• prepareBusinessDataOnBorrow - Prepare borrow business data
• prepareBusinessDataOnWithdraw - Prepare withdraw business data
• prepareBusinessDataOnAdjust - Prepare adjust collateral business data
• prepareBusinessDataOnRepayFromSupplied - Prepare repay from supplied business data
• prepareBusinessDataOninnerWithdraw - Prepare inner withdraw business data

MCA Creation

• getCreateMcaCustomRecipientMsg - Get custom recipient message for creating MCA
• getCreateMcaFeeData - Get the on-chain fee for creating an MCA account. Returns { amountRaw, amountReadable }. Parameters: asset (Asset object), bufferMultiple (optional, default 1.5)
• getZcashCreateMcaDepositAddress - Get deposit address when creating MCA with Zcash (Old way)
• getZcashResponseDataByAddress - Get Zcash deposit/creation data by address (Old way)

Custom Recipient Messages

• getSupplyCustomRecipientMsg - Get custom recipient message for supply
• getSupplyDepositData - Get supply deposit address and quote result
• getRepayCustomRecipientMsg - Get custom recipient message for repay

Account Management

• prepareBusinessDataOnAddWallet - Prepare add wallet business data
• prepareBusinessDataOnRemoveWallet - Prepare remove wallet business data
• prepareBusinessDataOnClaim - Prepare claim rewards business data
• prepareBusinessDataOnWithdrawRewards - Prepare cross-chain withdraw rewards business data

Intents Quotation

• intentsQuotation - Get cross-chain swap/bridge quote. Returns IIntentsQuoteResult which includes:
  • quoteStatus - "success" or "error"
  • quoteSuccessResult - Quote details (depositAddress, amounts, etc.)
  • quoteFeeData - Fee data for the cross-chain bridge/swap (only present when quoteStatus is "success"):
    • feeAmount - Bridge/swap fee amount (readable, = amountInFormatted - amountOutFormatted)
    • feeUsd - Bridge/swap fee in USD (= amountInUsd - amountOutUsd)

General Utilities

• format_wallet - Format wallet address
• serializationObj - Serialize object
• computeRelayerGas - Calculate relayer gas fee
• pollingTransactionStatus - Poll transaction status
• postMultichainLendingRequests - Submit multi-chain lending request
• pollingRelayerTransactionResult - Poll relayer transaction result

Chain Interaction

• view_on_near - Call NEAR contract view method
• getAccountBalance - Get NEAR account balance

Chain Configuration

• config_near - NEAR chain configuration
• config_evm - EVM chain configuration
• config_solana - Solana chain configuration
• config_btc - Bitcoin chain configuration
• setCustomNodeUrl - Set custom RPC node URL for NEAR chain. This function allows you to customize the RPC endpoint used for NEAR chain interactions.

import { setCustomNodeUrl } from "@rhea-finance/cross-chain-sdk";

// Set custom NEAR RPC node URL
setCustomNodeUrl("https://your-custom-near-rpc-url.com");

Type Definitions

// Chain type
type IChain = "evm" | "solana" | "btc";

// Wallet type
type IWallet = { EVM: string } | { Solana: string } | { Bitcoin: string };

Usage Examples

Check out the cross-chain-demo project for more complete usage examples.

Example 1: Query Account Data

import { batchViews  } from "@rhea-finance/cross-chain-sdk";

async function fetchAccountData(mcaId: string) {
  // Batch query
  const lendingData = await batchViews(mcaId);
  
  return {
    assets: lendingData.assets_paged_detailed,
    config: lendingData.config,
  };
}

## Development

### Build

```bash
pnpm build

Development Mode (watch file changes)

pnpm dev

Type Check

pnpm type-check

Code Formatting

pnpm prettier:fix

Dependencies

Main dependencies include:

• ethers - EVM chain interaction
• @solana/web3.js - Solana chain interaction
• near-api-js - NEAR chain interaction
• btc-wallet - Bitcoin wallet support
• bignumber.js / big.js / decimal.js - Big number calculations
• lodash - Utility functions

License

MIT

Related Links

• Demo Project: cross-chain-demo
• Rhea Finance: https://rhea.finance

Contributing

Issues and Pull Requests are welcome!