@molecularlabs/nucleus-frontend/dist/vaults/deposit/deposit.js

Nucleus BoringVault Frontend SDK

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var deposit_exports = {};
__export(deposit_exports, {
  prepareApproveDepositToken: () => prepareApproveDepositToken,
  prepareDepositAndBridgeTransactionData: () => prepareDepositAndBridgeTransactionData,
  prepareDepositTransactionData: () => prepareDepositTransactionData
});
module.exports = __toCommonJS(deposit_exports);
var import_viem = require("viem");
var import_accountant = require("../../api/accountant");
var import_erc20 = require("../../api/erc20");
var import_vault_config = require("../../api/vault-config");
var import_constants = require("../../constants");
var import_teller_abi = require("../../contracts/teller-abi");
var import_try_catch = require("../../utils/try-catch");
var import_bridge = require("../bridge");
var import__ = require("../index");
var import_utils = require("./utils");
const prepareDepositTransactionData = async ({
  vaultKey,
  depositTokenSymbol,
  depositAmount,
  chainId,
  slippage = import_constants.DEFAULT_DEPOSIT_SLIPPAGE
}) => {
  try {
    const normalizedChainId = (0, import_vault_config.toChainId)(chainId);
    const vault = await (0, import__.getVaultByKey)(vaultKey);
    const depositAssetAddress = vault.deposit.sourceChains[normalizedChainId].depositTokens[depositTokenSymbol].address;
    if (!vault) {
      throw new Error(`Invalid vault key: ${vaultKey}`);
    }
    if (!depositAssetAddress) {
      throw new Error(
        `Couldn't find address for ${depositTokenSymbol} on ${chainId}`
      );
    }
    if (!vault.contracts) {
      throw new Error(`Contracts not configured for vault ${vaultKey}`);
    }
    if (!vault.contracts.teller) {
      throw new Error(`Teller contract not configured for vault ${vaultKey}`);
    }
    const [depositAssetDecimals, rate] = await (0, import_accountant.getRateInQuoteWithAssetDecimals)({
      assetAddress: depositAssetAddress,
      accountantAddress: vault.contracts.accountant,
      chainId: normalizedChainId
    });
    if (depositAssetDecimals.status === "failure") {
      throw new Error(depositAssetDecimals.error.message);
    }
    if (rate.status === "failure") {
      throw new Error(rate.error.message);
    }
    const depositAmountAsBitInt = (0, import_viem.parseUnits)(
      depositAmount,
      depositAssetDecimals.result
    );
    const minimumMint = (0, import_utils.calculateMinimumMint)(
      depositAmountAsBitInt,
      rate.result,
      slippage
    );
    return {
      abi: import_teller_abi.TellerAbi,
      address: vault.contracts.teller,
      functionName: "deposit",
      args: [depositAssetAddress, depositAmountAsBitInt, minimumMint],
      chainId: normalizedChainId
    };
  } catch (error) {
    console.error(error);
    throw new Error(`Failed to get rate in quote for vault ${vaultKey}`);
  }
};
const prepareDepositAndBridgeTransactionData = async ({
  depositAmount,
  depositTokenSymbol,
  destinationChainId,
  slippage = import_constants.DEFAULT_DEPOSIT_SLIPPAGE,
  sourceChainId,
  userAddress,
  vaultKey
}) => {
  const normalizedSourceChainId = (0, import_vault_config.toChainId)(sourceChainId);
  const normalizedDestinationChainId = (0, import_vault_config.toChainId)(destinationChainId);
  const vault = await (0, import__.getVaultByKey)(vaultKey);
  const depositAssetAddress = vault.deposit.sourceChains[normalizedSourceChainId].depositTokens[depositTokenSymbol].address;
  if (!vault) {
    throw new Error(`Invalid vault key: ${vaultKey}`);
  }
  if (!vault.contracts) {
    throw new Error(`Contracts not configured for vault ${vaultKey}`);
  }
  if (!vault.contracts.accountant) {
    throw new Error(`Accountant contract not configured for vault ${vaultKey}`);
  }
  const bridgeIdentifier = vault.deposit.sourceChains[normalizedSourceChainId].destinationChains[normalizedDestinationChainId].bridge.chainIdentifier;
  const [depositAssetDecimals, rate] = await (0, import_accountant.getRateInQuoteWithAssetDecimals)({
    assetAddress: depositAssetAddress,
    accountantAddress: vault.contracts.accountant,
    chainId: normalizedSourceChainId
  });
  if (depositAssetDecimals.status === "failure") {
    throw new Error(depositAssetDecimals.error.message);
  }
  if (rate.status === "failure") {
    throw new Error(rate.error.message);
  }
  const depositAmountAsBitInt = (0, import_viem.parseUnits)(
    depositAmount,
    depositAssetDecimals.result
  );
  const minimumMint = (0, import_utils.calculateMinimumMint)(
    depositAmountAsBitInt,
    rate.result,
    slippage
  );
  const bridgeData = (0, import_bridge.prepareBridgeContractArg)({
    bridgeChainIdentifier: bridgeIdentifier,
    userAddress
  });
  return {
    abi: import_teller_abi.TellerAbi,
    address: vault.contracts.teller,
    functionName: "depositAndBridge",
    args: [depositAssetAddress, depositAmountAsBitInt, minimumMint, bridgeData],
    chainId: normalizedSourceChainId,
    value: BigInt(0)
    // This will be updated with actual bridge fee when executing
  };
};
const prepareApproveDepositToken = async ({
  vaultKey,
  depositTokenSymbol,
  depositAmount,
  chainId
}) => {
  const normalizedChainId = (0, import_vault_config.toChainId)(chainId);
  const vault = await (0, import__.getVaultByKey)(vaultKey);
  if (!vault) {
    throw new Error(`Invalid vault key: ${vaultKey}`);
  }
  if (!vault.contracts) {
    throw new Error(`Contracts not configured for vault ${vaultKey}`);
  }
  if (!vault.contracts.boringVault) {
    throw new Error(`Teller contract not configured for vault ${vaultKey}`);
  }
  const depositAssetAddress = vault.deposit.sourceChains[normalizedChainId].depositTokens[depositTokenSymbol].address;
  if (!depositAssetAddress) {
    throw new Error(`Invalid deposit token symbol: ${depositTokenSymbol}`);
  }
  const {
    data: depositAssetDecimals,
    error: depositAssetDecimalsError,
    success: depositAssetDecimalsSuccess
  } = await (0, import_try_catch.tryCatch)(
    (0, import_erc20.getErc20Decimals)({
      chainId: normalizedChainId,
      tokenAddress: depositAssetAddress
    })
  );
  if (depositAssetDecimalsSuccess === false) {
    throw new Error(
      `Error getting deposit asset decimals. ${depositAssetDecimalsError.name}: ${depositAssetDecimalsError.message}`
    );
  }
  if (!depositAssetDecimals) {
    throw new Error(`Invalid deposit token symbol: ${depositTokenSymbol}`);
  }
  const depositAmountAsBitInt = depositAmount ? (0, import_viem.parseUnits)(depositAmount, depositAssetDecimals) : import_constants.DEFAULT_APPROVAL_AMOUNT;
  return {
    abi: import_viem.erc20Abi,
    address: depositAssetAddress,
    functionName: "approve",
    args: [vault.contracts.boringVault, depositAmountAsBitInt]
  };
};
//# sourceMappingURL=deposit.js.map