@lombard.finance/sdk 2.5.2 → 3.1.0

package/src/vaults/lib/withdraw.ts

@@ -0,0 +1,224 @@
+import BigNumber from 'bignumber.js';
+import { isVedaVaultChain, Vault, VAULTS } from '..';
+import { CommonWriteParameters } from '../../common/parameters';
+import { makePublicClient } from '../../clients/public-client';
+import { makeWalletClient } from '../../clients/wallet-client';
+import {
+  fromBaseDenomination,
+  getTokenInfo,
+  toBaseDenomination,
+  Token,
+} from '../../tokens/tokens';
+import toBigInt from '../../utils/numbers';
+import { CHAIN_ID_TO_VIEM_CHAIN_MAP } from '../../common/chains';
+import { getErrorMessage } from '../../utils/err';
+import { DAY } from '../../utils/time';
+
+export type QueueWithdrawParameters = {
+  /** The amount to be withdrawn from the DeFi vault. */
+  amount: BigNumber.Value;
+  /**
+   * A flag determining whether the amount should be approved within
+   * the execution of this function. If set to `false` it will
+   * throw an error when the withdraw amount exceeds allowance.
+   */
+  approve?: boolean;
+  /** The optional deposit asset. */
+  token?: Token;
+  /** The vault identifier. */
+  vaultKey?: Vault;
+} & CommonWriteParameters;
+
+/**
+ * Queues withdrawal from the DeFi vault.
+ * @param {QueueWithdrawParameters} parameters - The parameters.
+ * @param {BigNumber.Value} parameters.amount - The deposit amount.
+ * @param {boolean} parameters.approve - The optional flag determining whether approve actions should be performed.
+ * @param {Token} parameters.token - The optional deposit asset.
+ * @param {Vault} parameters.vaultKey - The vault identifier.
+ * @param {Address} parameters.account - The EVM account address.
+ * @param {ChainId} parameters.chainId - The chain id.
+ * @param {EIP1193Provider} parameters.provider - The EIP1193 provider.
+ * @param {string} parameters.rpcUrl - The optional rpc url.
+ *
+ * @returns {Promise<Hash>}
+ */
+export async function queueWithdraw({
+  amount: amountRaw,
+  approve = true,
+  token = 'LBTC',
+  vaultKey = Vault.Veda,
+  account,
+  chainId,
+  provider,
+  rpcUrl,
+  env,
+}: QueueWithdrawParameters) {
+  const vault = VAULTS[vaultKey];
+  if (!vault) {
+    throw new Error(`Unknown vault key: ${vaultKey}`);
+  }
+
+  if (!isVedaVaultChain(chainId)) {
+    throw new Error(
+      `Unsupported chain id: ${chainId}. Please switch to one of the supported chains: ${vault.chains.join(', ')}`,
+    );
+  }
+
+  const publicClient = makePublicClient({ chainId, rpcUrl });
+  const walletClient = makeWalletClient({ provider, chainId });
+
+  const withdrawToken = await getTokenInfo(token, chainId, env, rpcUrl);
+  if (!withdrawToken) {
+    throw new Error(`Unknown withdraw token: ${token}`);
+  }
+
+  const amount = BigNumber(amountRaw);
+  const amountBase = toBigInt(toBaseDenomination(amount, vault.decimals));
+
+  const balanceRaw = await publicClient.readContract({
+    address: vault.lensContract.address,
+    abi: vault.lensContract.abi,
+    functionName: 'balanceOf',
+    args: [account, vault.vaultContract.address],
+  });
+  const balance = fromBaseDenomination(String(balanceRaw), vault.decimals);
+
+  const allowanceRaw = await publicClient.readContract({
+    address: vault.vaultContract.address,
+    abi: vault.vaultContract.abi,
+    functionName: 'allowance',
+    args: [account, vault.withdrawQueueContracts[chainId].address],
+  });
+  const allowance = fromBaseDenomination(String(allowanceRaw), vault.decimals);
+
+  // check if amount exceeds balance
+  if (amount.isGreaterThan(balance)) {
+    throw new Error(
+      `The withdraw amount exceeds the account's balance. \nWithdraw amount: ${amount.toFixed()} \nBalance: ${balance.toFixed()}`,
+    );
+  }
+
+  // check if amount exceeds allowance
+  if (amount.isGreaterThan(allowance)) {
+    const exceededMessage = `The withdraw amount exceeds allowance. \nWithdraw amount: ${amount.toFixed()} \nAllowance: ${allowance.toFixed()}`;
+    if (!approve) {
+      throw new Error(exceededMessage);
+    }
+
+    // try to approve new amount
+    try {
+      console.info(`Trying to approve ${amountBase}`);
+      const { request } = await publicClient.simulateContract({
+        account,
+        chain: CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId],
+        address: vault.vaultContract.address,
+        abi: vault.vaultContract.abi,
+        functionName: 'approve',
+        args: [vault.withdrawQueueContracts[chainId].address, amountBase],
+      });
+
+      const txHash = await walletClient.writeContract(request);
+      console.info(`Approve tx hash: ${txHash}`);
+      console.info(`Approved ${amountBase} for ${vault.vaultContract.address}`);
+    } catch (err) {
+      const msg = getErrorMessage(err);
+      throw new Error(
+        `Could not approve ${amountBase} for ${vault.vaultContract.address}. \nReason: ${msg}`,
+      );
+    }
+  }
+
+  // queue withdraw vault token to wihdraw token via the withdraw queue contract
+  const expiry = BigNumber(Date.now())
+    .dividedBy(1000)
+    .plus(BigNumber(vault.queueWithdrawDaysValid).multipliedBy(DAY / 1000))
+    .decimalPlaces(0, BigNumber.ROUND_DOWN); // expiry = now(seconds) + days(seconds)
+
+  const discount = BigNumber(vault.queueWithdrawDiscountPercent).multipliedBy(
+    10000, // 1% = 10000
+  );
+
+  const { request } = await publicClient.simulateContract({
+    account,
+    chain: CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId],
+    address: vault.withdrawQueueContracts[chainId].address,
+    abi: vault.withdrawQueueContracts[chainId].abi,
+    functionName: 'safeUpdateAtomicRequest',
+    args: [
+      vault.vaultContract.address,
+      withdrawToken.address,
+      [expiry.toFixed(0), 0n, amountBase, false],
+      vault.accountantContract.address,
+      discount.toFixed(0),
+    ],
+  });
+
+  const txHash = await walletClient.writeContract(request);
+  return txHash;
+}
+
+export type CancelWithdrawParameters = Pick<
+  QueueWithdrawParameters,
+  'token' | 'vaultKey'
+> &
+  CommonWriteParameters;
+
+/**
+ * Cancels queued withdrawal.
+ * @param {CancelWithdrawParameters} parameters - The parameters.
+ * @param {Token} parameters.token - The optional deposit asset.
+ * @param {Vault} parameters.vaultKey - The vault identifier.
+ * @param {Address} parameters.account - The EVM account address.
+ * @param {ChainId} parameters.chainId - The chain id.
+ * @param {EIP1193Provider} parameters.provider - The EIP1193 provider.
+ * @param {string} parameters.rpcUrl - The optional rpc url.
+ *
+ * @returns {Promise<Hash>}
+ * @returns
+ */
+export async function cancelWithdraw({
+  token = 'LBTC',
+  vaultKey = Vault.Veda,
+  account,
+  chainId,
+  provider,
+  rpcUrl,
+  env,
+}: CancelWithdrawParameters) {
+  const vault = VAULTS[vaultKey];
+  if (!vault) {
+    throw new Error(`Unknown vault key: ${vaultKey}`);
+  }
+
+  if (!isVedaVaultChain(chainId)) {
+    throw new Error(
+      `Unsupported chain id: ${chainId}. Please switch to one of the supported chains: ${vault.chains.join(', ')}`,
+    );
+  }
+
+  const publicClient = makePublicClient({ chainId, rpcUrl });
+  const walletClient = makeWalletClient({ provider, chainId });
+
+  const withdrawToken = await getTokenInfo(token, chainId, env, rpcUrl);
+  if (!withdrawToken) {
+    throw new Error(`Unknown withdraw token: ${token}`);
+  }
+
+  // cancel withdrawal via withdraw queue contract
+  const { request } = await publicClient.simulateContract({
+    account,
+    chain: CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId],
+    address: vault.withdrawQueueContracts[chainId].address,
+    abi: vault.withdrawQueueContracts[chainId].abi,
+    functionName: 'updateAtomicRequest',
+    args: [
+      vault.vaultContract.address,
+      withdrawToken.address,
+      [0, 0, 0, false],
+    ],
+  });
+
+  const txHash = await walletClient.writeContract(request);
+  return txHash;
+}

package/src/common/const.ts

@@ -1,5 +0,0 @@
-/**
- * Address of the zero account.
- * Can also be used as a placeholder for unknown addresses.
- */
-export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';

package/src/common/types/internalTypes.ts

@@ -1,10 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-
-export interface IEnvParam {
-  /**
-   * The environment. Available values are `prod`, `stage` and `testnet`
-   *
-   * @default 'prod'
-   */
-  env?: Env;
-}

package/src/common/types/types.ts

@@ -1,57 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-
-export const SUI_DEVNET_CHAIN = 'sui:devnet' as const;
-export const SUI_TESTNET_CHAIN = 'sui:testnet' as const;
-export const SUI_LOCALNET_CHAIN = 'sui:localnet' as const;
-export const SUI_MAINNET_CHAIN = 'sui:mainnet' as const;
-
-export type SuiChain =
-  | typeof SUI_DEVNET_CHAIN
-  | typeof SUI_TESTNET_CHAIN
-  | typeof SUI_LOCALNET_CHAIN
-  | typeof SUI_MAINNET_CHAIN;
-
-export const OChainId = {
-  ethereum: 1,
-  holesky: 17000,
-  binanceSmartChain: 56,
-  binanceSmartChainTestnet: 97,
-  sepolia: 11155111,
-  base: 8453,
-  baseSepoliaTestnet: 84532,
-  berachain: 80094,
-  berachainBartioTestnet: 80084,
-  corn: 21000000,
-  swell: 1923,
-  sonic: 146,
-  sonicBlazeTestnet: 57054,
-  morph: 2818,
-  morphHolesky: 2810,
-  etherlink: 42793,
-} as const;
-
-export type TChainId = (typeof OChainId)[keyof typeof OChainId];
-
-/**
- * Abstract EIP-1193 provider
- */
-export interface IEIP1193Provider {
-  request: (args: unknown) => Promise<unknown>;
-}
-
-export const getEthNetworkByEnv = (env: Env) =>
-  env === Env.prod ? OChainId.ethereum : OChainId.holesky;
-
-export const getBscNetworkByEnv = (env: Env) =>
-  env === Env.prod
-    ? OChainId.binanceSmartChain
-    : OChainId.binanceSmartChainTestnet;
-
-export const getBaseNetworkByEnv = (env: Env) =>
-  env === Env.prod ? OChainId.base : OChainId.baseSepoliaTestnet;
-
-export const getSuiNetworkByEnv = (env: Env) =>
-  env === Env.prod ? 'sui:mainnet' : 'sui:testnet';
-
-export const getSonicNetworkByEnv = (env: Env) =>
-  env === Env.prod ? OChainId.sonic : OChainId.sonicBlazeTestnet;

package/src/common/utils/isValidChain.ts

@@ -1,5 +0,0 @@
-import { OChainId, TChainId } from '../types/types';
-
-export function isValidChain(chainId: number): chainId is TChainId {
-  return Object.values(OChainId).includes(chainId as TChainId);
-}

package/src/provider/Provider.ts

@@ -1,171 +0,0 @@
-import Web3, { Contract, ContractAbi, Transaction, utils } from 'web3';
-import { IEIP1193Provider } from '../common/types/types';
-import { IReadProviderParams, ReadProvider } from './ReadProvider';
-import {
-  TRpcUrlConfig,
-  rpcUrlConfig as defaultRpcUrlConfig,
-} from './rpcUrlConfig';
-import { ISendOptions, IWeb3SendResult } from './types';
-
-export interface IProviderParams extends IReadProviderParams {
-  /**
-   * The EIP-1193 provider instance.
-   */
-  provider: IEIP1193Provider;
-  /**
-   * The сurrent account address.
-   */
-  account: string;
-}
-
-/**
- * Provider for interacting with a blockchain network.
- */
-export class Provider extends ReadProvider {
-  web3: Web3;
-  account: string;
-  rpcConfig: TRpcUrlConfig = defaultRpcUrlConfig;
-
-  constructor({ provider, account, chainId, rpcUrlConfig }: IProviderParams) {
-    super({ chainId, rpcUrlConfig });
-    this.web3 = new Web3(provider);
-    this.account = account;
-    this.chainId = chainId;
-    this.rpcConfig = { ...defaultRpcUrlConfig, ...rpcUrlConfig };
-  }
-
-  /**
-   * Signs a message using the current provider and account.
-   * @public
-   * @param message - The message to be signed.
-   * @returns A promise that resolves to the signed message as a string.
-   */
-  public async signMessage(message: string) {
-    const { account } = this;
-
-    const messageHex = `0x${Buffer.from(message, 'utf8').toString('hex')}`;
-
-    const ethereum = this.web3.currentProvider;
-    if (!ethereum) {
-      throw new Error('Undefined provider');
-    }
-
-    return ethereum.request({
-      method: 'personal_sign',
-      params: [messageHex, account],
-    }) as unknown as Promise<string>;
-  }
-
-  /**
-   * Custom replacement for web3js [send](https://docs.web3js.org/libdocs/Contract#send).
-   *
-   * @public
-   * @param {string} from - Address of the sender.
-   * @param {string} to - Address of the recipient.
-   * @param {ISendOptions} sendOptions - Options for sending transaction.
-   * @returns {Promise<IWeb3SendResult>} Promise with transaction hash and receipt promise.
-   */
-  public async sendTransactionAsync(
-    from: string,
-    to: string,
-    sendOptions: ISendOptions,
-  ): Promise<IWeb3SendResult> {
-    const { chainId, web3: web3Write } = this;
-    const web3Read = this.getReadWeb3();
-
-    const {
-      data,
-      estimate = false,
-      estimateFee = false,
-      extendedGasLimit,
-      gasLimit = '0',
-      value = '0',
-      gasLimitMultiplier = 1,
-    } = sendOptions;
-    let { nonce } = sendOptions;
-
-    if (!nonce) {
-      nonce = await web3Read.eth.getTransactionCount(from);
-    }
-
-    console.log(`Nonce: ${nonce}`);
-
-    const tx: Transaction = {
-      from,
-      to,
-      value: utils.numberToHex(value),
-      data,
-      nonce,
-      chainId: utils.numberToHex(chainId),
-    };
-
-    if (estimate) {
-      try {
-        const estimatedGas = await web3Read.eth.estimateGas(tx);
-
-        const multipliedGasLimit = Math.round(
-          Number(estimatedGas) * gasLimitMultiplier,
-        );
-
-        if (extendedGasLimit) {
-          tx.gas = utils.numberToHex(multipliedGasLimit + extendedGasLimit);
-        } else {
-          tx.gas = utils.numberToHex(multipliedGasLimit);
-        }
-      } catch (e) {
-        throw new Error(
-          (e as Partial<Error>).message ??
-            'Failed to estimate gas limit for transaction.',
-        );
-      }
-    } else {
-      tx.gas = utils.numberToHex(gasLimit);
-    }
-
-    const { maxFeePerGas, maxPriorityFeePerGas } = estimateFee
-      ? await this.getMaxFees().catch(() => sendOptions)
-      : sendOptions;
-
-    if (maxPriorityFeePerGas !== undefined) {
-      tx.maxPriorityFeePerGas = utils.numberToHex(maxPriorityFeePerGas);
-    }
-
-    if (maxFeePerGas !== undefined) {
-      tx.maxFeePerGas = utils.numberToHex(maxFeePerGas);
-    }
-
-    if (!tx.maxFeePerGas && !tx.maxPriorityFeePerGas) {
-      const safeGasPrice = await this.getSafeGasPriceWei();
-      tx.gasPrice = safeGasPrice.toString(10);
-    }
-
-    if (!tx.maxFeePerGas && !tx.maxPriorityFeePerGas) {
-      const safeGasPrice = await this.getSafeGasPriceWei();
-      tx.gasPrice = safeGasPrice.toString(10);
-    }
-
-    console.log('Sending transaction via Web3: ', tx);
-
-    return new Promise((resolve, reject) => {
-      const promise = web3Write.eth.sendTransaction(tx);
-
-      promise
-        .once('transactionHash', async (transactionHash: string) => {
-          console.log(`Just signed transaction has is: ${transactionHash}`);
-
-          resolve({
-            receiptPromise: promise,
-            transactionHash,
-          });
-        })
-        .catch(reject);
-    });
-  }
-
-  public createContract<AbiType extends ContractAbi>(
-    abi: AbiType,
-    address: string,
-  ): Contract<AbiType> {
-    return new this.web3.eth.Contract<AbiType>(abi, address);
-  }
-}

package/src/provider/ReadProvider.ts

@@ -1,126 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { Web3, Contract, ContractAbi } from 'web3';
-import {
-  TRpcUrlConfig,
-  rpcUrlConfig as defaultRpcUrlConfig,
-} from './rpcUrlConfig';
-import { IGetMaxFeesResult } from './types';
-import { getMaxPriorityFeePerGas } from './utils/getMaxPriorityFeePerGas';
-
-const FEE_MULTIPLIER = 2;
-const ADDITIONAL_SAFE_GAS_PRICE_WEI = 25_000;
-
-export interface IReadProviderParams {
-  /**
-   * Chain ID of the network to interact with.
-   */
-  chainId: number;
-  /**
-   * The RPC URL configuration. If not provided, the default configuration will be used.
-   */
-  rpcUrlConfig?: TRpcUrlConfig;
-}
-
-export class ReadProvider {
-  chainId: number;
-  rpcConfig: TRpcUrlConfig;
-
-  constructor({ chainId, rpcUrlConfig }: IReadProviderParams) {
-    this.chainId = chainId;
-    this.rpcConfig = { ...defaultRpcUrlConfig, ...rpcUrlConfig };
-  }
-
-  /**
-   * Returns web3 instance for read operations.
-   *
-   * @public
-   * @returns {Web3} Web3 instance.
-   */
-  public getReadWeb3(): Web3 {
-    const rpcUrl = this.getRpcUrl();
-    const readWeb3 = new Web3();
-    const provider = new Web3.providers.HttpProvider(rpcUrl);
-    readWeb3.setProvider(provider);
-    return readWeb3;
-  }
-
-  /**
-   * Retrieves the RPC URL based on the current chain ID.
-   * @returns The RPC URL for the current chain ID.
-   * @throws Error if the RPC URL for the current chain ID is not found.
-   */
-  getRpcUrl(): string {
-    const { chainId } = this;
-    const rpcUrl = this.rpcConfig?.[chainId];
-
-    if (!rpcUrl) {
-      console.error(
-        `You might need to add the rpcConfig for the ${chainId} chain ID when creating the provider.`,
-      );
-      throw new Error(`RPC URL for chainId ${chainId} not found`);
-    }
-
-    return rpcUrl;
-  }
-
-  /**
-   * Calculates max fees for transaction. Thess values are available for networks
-   * with EIP-1559 support.
-   *
-   * @public
-   * @note If current network is Binance Smart Chain, will return default values.
-   * @returns {Promise<IGetMaxFeesResult>} Max fees for transaction.
-   */
-  public async getMaxFees(): Promise<IGetMaxFeesResult> {
-    const web3 = this.getReadWeb3();
-    const rpcUrl = this.getRpcUrl();
-
-    const [block, maxPriorityFeePerGas] = await Promise.all([
-      web3.eth.getBlock('latest'),
-      getMaxPriorityFeePerGas(rpcUrl),
-    ]);
-
-    if (!block?.baseFeePerGas && typeof block?.baseFeePerGas !== 'bigint') {
-      return {};
-    }
-
-    const maxFeePerGas = new BigNumber(block.baseFeePerGas.toString(10))
-      .multipliedBy(FEE_MULTIPLIER)
-      .plus(maxPriorityFeePerGas);
-
-    return {
-      maxFeePerGas: +maxFeePerGas,
-      maxPriorityFeePerGas: +maxPriorityFeePerGas,
-    };
-  }
-
-  /**
-   * Returns safe gas price for transaction.
-   *
-   * @public
-   * @returns {Promise<BigNumber>} Safe gas price.
-   */
-  public async getSafeGasPriceWei(): Promise<BigNumber> {
-    const pureGasPriceWei = await this.getReadWeb3().eth.getGasPrice();
-
-    return new BigNumber(pureGasPriceWei.toString(10)).plus(
-      ADDITIONAL_SAFE_GAS_PRICE_WEI,
-    );
-  }
-
-  /**
-   * Creates a contract instance with the given ABI and address.
-   *
-   * @template AbiType - The type of the contract ABI.
-   * @param {any} abi - The ABI of the contract.
-   * @param {string} address - The address of the contract.
-   * @returns {Contract<AbiType>} The contract instance.
-   */
-  public createContract<AbiType extends ContractAbi>(
-    abi: AbiType,
-    address: string,
-  ): Contract<AbiType> {
-    const web3 = this.getReadWeb3();
-    return new web3.eth.Contract<AbiType>(abi, address);
-  }
-}

package/src/provider/index.ts

@@ -1,2 +0,0 @@
-export * from './Provider';
-export * from './types';

package/src/provider/rpcUrlConfig.ts

@@ -1,19 +0,0 @@
-import { OChainId } from '../common/types/types';
-
-export type TRpcUrlConfig = Record<number, string>;
-
-export const RPC_URL = 'https://bff.prod.lombard.finance/multi-rpc/proxy';
-
-export const rpcUrlConfig: TRpcUrlConfig = {
-  [OChainId.ethereum]: `${RPC_URL}/eth`,
-  [OChainId.holesky]: `${RPC_URL}/eth_holesky`,
-  [OChainId.sepolia]: `${RPC_URL}/eth_sepolia`,
-  [OChainId.base]: `${RPC_URL}/base`,
-  [OChainId.baseSepoliaTestnet]: `${RPC_URL}/base_sepolia`,
-  [OChainId.binanceSmartChain]: 'https://bsc-dataseed.bnbchain.org',
-  [OChainId.binanceSmartChainTestnet]:
-    'https://bsc-testnet-dataseed.bnbchain.org',
-  [OChainId.corn]: `${RPC_URL}/corn_maizenet`,
-  [OChainId.sonic]: `${RPC_URL}/sonic_mainnet`,
-  [OChainId.sonicBlazeTestnet]: `${RPC_URL}/sonic_blaze_testnet`,
-};

package/src/provider/types.ts

@@ -1,58 +0,0 @@
-import { core, eth, FMT_BYTES, FMT_NUMBER, TransactionReceipt } from 'web3';
-
-export interface IGetMaxFeesResult {
-  maxPriorityFeePerGas?: number;
-  maxFeePerGas?: number;
-}
-
-export type PromiEvent<T> = core.Web3PromiEvent<
-  T,
-  eth.SendTransactionEvents<{
-    readonly number: FMT_NUMBER.BIGINT;
-    readonly bytes: FMT_BYTES.HEX;
-  }>
->;
-
-export interface IWeb3SendResult {
-  receiptPromise: PromiEvent<TransactionReceipt>;
-  transactionHash: string;
-}
-
-export interface ISendOptions {
-  /**
-   * Txn data.
-   */
-  data?: string;
-  /**
-   * Gas limit for transaction.
-   * @note When `estimate` is `true`, this value will be redefined by estimated gas limit.
-   */
-  gasLimit?: string;
-  /**
-   * Multiplier for gas limit when estimating gas.
-   * When specified, gas limit will be calculated as `gasLimit * gasLimitMultiplier`.
-   * @note works only when `estimate` is `true`.
-   * @default 1
-   */
-  gasLimitMultiplier?: number;
-  value?: string;
-  /**
-   * When `true`, will estimate gas limit for transaction.
-   * @note `gasLimit` option will be redefined by estimated gas limit.
-   */
-  estimate?: boolean;
-  /**
-   * When `true`, will estimate max fees for transaction.
-   * @note `maxPriorityFeePerGas` and `maxFeePerGas` options will be redefined by estimated values.
-   * @note Please use only for networks with EIP-1559 support.
-   */
-  estimateFee?: boolean;
-  nonce?: bigint;
-  /**
-   * Additional gas limit for transaction.
-   * @note When `estimate` is `true`, this value will be added to estimated gas limit.
-   */
-  extendedGasLimit?: number;
-  maxPriorityFeePerGas?: number;
-  maxFeePerGas?: number;
-}