@molecularlabs/nucleus-frontend/dist/vaults/withdraw/withdraw.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 withdraw_exports = {};
__export(withdraw_exports, {
  prepareApproveWithdrawToken: () => prepareApproveWithdrawToken,
  prepareBridgeAndWithdrawTransactionData: () => prepareBridgeAndWithdrawTransactionData,
  prepareWithdrawTransactionData: () => prepareWithdrawTransactionData
});
module.exports = __toCommonJS(withdraw_exports);
var import_viem = require("viem");
var import_accountant = require("../../api/accountant");
var import_erc20 = require("../../api/erc20");
var import_solver_slippage = require("../../api/solver-slippage");
var import_vault_config = require("../../api/vault-config");
var import_constants = require("../../constants");
var import_atomic_queue_abi = require("../../contracts/atomic-queue-abi");
var import_boring_vault_abi = require("../../contracts/boring-vault-abi");
var import_try_catch = require("../../utils/try-catch");
var import_bridge = require("../bridge");
var import__ = require("../index");
var import_utils = require("./utils");
const prepareWithdrawTransactionData = async ({
  vaultKey,
  chainId,
  wantTokenSymbol,
  offerAmount,
  deadline = import_constants.DEFAULT_DEADLINE,
  slippage
}) => {
  const vault = await (0, import__.getVaultByKey)(vaultKey);
  const normalizedChainId = (0, import_vault_config.toChainId)(chainId);
  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(
      `BoringVault contract not configured for vault ${vaultKey}`
    );
  }
  const boringVaultAddress = vault.contracts.boringVault;
  if (!vault.contracts.accountant) {
    throw new Error(`Accountant contract not configured for vault ${vaultKey}`);
  }
  const accountantAddress = vault.contracts.accountant;
  const destinationChain = vault.withdraw.sourceChains[normalizedChainId].destinationChains[normalizedChainId];
  const wantTokens = destinationChain.wantTokens;
  if (!!wantTokens && !wantTokens[wantTokenSymbol]) {
    throw new Error(
      `Invalid want token "${wantTokenSymbol}" for vault ${vaultKey}. Allowed tokens are: ${Object.keys(wantTokens).join(", ")}`
    );
  }
  const wantAssetAddress = wantTokens[wantTokenSymbol].address;
  if (!wantAssetAddress) {
    throw new Error(`Invalid want token symbol: ${wantTokenSymbol}`);
  }
  const [wantAssetDecimals, sharesAssetDecimals, rateInQuote] = await (0, import_accountant.getRateInQuoteAndSharesAndWantAssetDecimals)({
    sharesAssetAddress: boringVaultAddress,
    wantAssetAddress,
    accountantAddress,
    chainId: normalizedChainId
  });
  if (wantAssetDecimals.status === "failure") {
    throw new Error(wantAssetDecimals.error.message);
  }
  if (rateInQuote.status === "failure") {
    throw new Error(rateInQuote.error.message);
  }
  if (sharesAssetDecimals.status === "failure") {
    throw new Error(sharesAssetDecimals.error.message);
  }
  const formattedOfferAmount = (0, import_viem.parseUnits)(
    offerAmount,
    sharesAssetDecimals.result
  );
  const {
    data: solverSlippage,
    error: solverSlippageError,
    success: solverSlippageSuccess
  } = await (0, import_try_catch.tryCatch)(
    (0, import_solver_slippage.getAssetSlippage)(normalizedChainId, boringVaultAddress, wantAssetAddress)
  );
  if (!solverSlippageSuccess) {
    throw new Error(
      `Error getting solver slippage: ${solverSlippageError.message}`
    );
  }
  const effectiveSlippage = slippage ?? solverSlippage;
  const atomicPrice = (0, import_utils.calculateAtomicPrice)(
    rateInQuote.result,
    wantAssetDecimals.result,
    effectiveSlippage
  );
  const userRequest = (0, import_utils.prepareUserRequest)(
    formattedOfferAmount,
    atomicPrice,
    deadline
  );
  return {
    abi: import_atomic_queue_abi.AtomicQueueAbi,
    address: import_constants.ATOMIC_QUEUE_CONTRACT_ADDRESS,
    functionName: "updateAtomicRequest",
    args: [boringVaultAddress, wantAssetAddress, userRequest],
    chainId: normalizedChainId
  };
};
const prepareBridgeAndWithdrawTransactionData = async ({
  deadline = import_constants.DEFAULT_DEADLINE,
  destinationChainId,
  offerAmount,
  slippage = import_constants.DEFAULT_WITHDRAW_SLIPPAGE,
  sourceChainId,
  userAddress,
  vaultKey,
  wantTokenSymbol
}) => {
  const vault = await (0, import__.getVaultByKey)(vaultKey);
  if (!vault) {
    throw new Error(`Invalid vault key: ${vaultKey}`);
  }
  const {
    data: withdrawTransactionData,
    error: withdrawError,
    success: withdrawSuccess
  } = await (0, import_try_catch.tryCatch)(
    prepareWithdrawTransactionData({
      vaultKey,
      chainId: destinationChainId,
      userAddress,
      wantTokenSymbol,
      offerAmount,
      deadline,
      slippage
    })
  );
  if (!withdrawSuccess) {
    throw new Error(withdrawError.message);
  }
  const { args } = withdrawTransactionData;
  const [, , userRequest] = args;
  const { offerAmount: bridgeAmount } = userRequest;
  const {
    data: bridgeTransactionData,
    error: bridgeError,
    success: bridgeSuccess
  } = await (0, import_try_catch.tryCatch)(
    (0, import_bridge.prepareBridgeTransactionData)({
      vaultKey,
      bridgeAmount,
      sourceChainId,
      destinationChainId,
      userAddress
    })
  );
  if (!bridgeSuccess) {
    throw new Error(bridgeError.message);
  }
  return {
    bridgeTransactionData,
    withdrawTransactionData
  };
};
const prepareApproveWithdrawToken = async ({
  vaultKey,
  withdrawAmount,
  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 withdrawAssetAddress = vault.contracts.boringVault;
  const {
    data: withdrawAssetDecimals,
    error: withdrawAssetDecimalsError,
    success: withdrawAssetDecimalsSuccess
  } = await (0, import_try_catch.tryCatch)(
    (0, import_erc20.getErc20Decimals)({
      chainId: normalizedChainId,
      tokenAddress: withdrawAssetAddress
    })
  );
  if (!withdrawAssetDecimalsSuccess) {
    throw new Error(
      `Error getting withdraw asset decimals. ${withdrawAssetDecimalsError.name}: ${withdrawAssetDecimalsError.message}`
    );
  }
  if (!withdrawAssetDecimals) {
    throw new Error(`Invalid withdraw token symbol: ${withdrawAssetAddress}`);
  }
  const withdrawAmountAsBitInt = withdrawAmount ? (0, import_viem.parseUnits)(withdrawAmount, withdrawAssetDecimals) : import_constants.DEFAULT_APPROVAL_AMOUNT;
  return {
    abi: import_boring_vault_abi.BoringVaultAbi,
    address: withdrawAssetAddress,
    functionName: "approve",
    args: [import_constants.ATOMIC_QUEUE_CONTRACT_ADDRESS, withdrawAmountAsBitInt]
  };
};
//# sourceMappingURL=withdraw.js.map