@gearbox-protocol/sdk 15.0.0 → 15.1.0-next.2

package/dist/cjs/dev/AccountOpener.js

@@ -1,909 +1,687 @@
-"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 });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_abi_iERC20 = require("../abi/iERC20.js");
+const require_abi_310_generated = require("../abi/310/generated.js");
+const require_sdk_utils_AddressMap = require("../sdk/utils/AddressMap.js");
+const require_sdk_utils_AddressSet = require("../sdk/utils/AddressSet.js");
+const require_sdk_utils_AssetsMap = require("../sdk/utils/AssetsMap.js");
+const require_sdk_utils_childLogger = require("../sdk/utils/childLogger.js");
+require("../sdk/constants/addresses.js");
+const require_sdk_constants_math = require("../sdk/constants/math.js");
+const require_sdk_base_SDKConstruct = require("../sdk/base/SDKConstruct.js");
+const require_sdk_utils_viem_sendRawTx = require("../sdk/utils/viem/sendRawTx.js");
+const require_sdk_pools_PoolService = require("../sdk/pools/PoolService.js");
+require("../sdk/index.js");
+const require_dev_abi = require("./abi.js");
+const require_dev_claimFromFaucet = require("./claimFromFaucet.js");
+const require_dev_createAnvilClient = require("./createAnvilClient.js");
+const require_dev_midasUtils = require("./midasUtils.js");
+const require_dev_mint_factory = require("./mint/factory.js");
+require("./mint/index.js");
+let viem = require("viem");
+let viem_accounts = require("viem/accounts");
+//#region src/dev/AccountOpener.ts
+const DIRECT_TRANSFERS_QUOTA = 10000n;
+var OpenTxRevertedError = class extends viem.BaseError {
+	txHash;
+	constructor(txHash) {
+		super("open credit account tx reverted");
+		this.txHash = txHash;
+	}
 };
-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 AccountOpener = class extends require_sdk_base_SDKConstruct.SDKConstruct {
+	borrowerKey;
+	depositorKey;
+	#service;
+	#anvil;
+	#logger;
+	#borrower;
+	#depositor;
+	#faucet;
+	#poolDepositMultiplier;
+	#minDebtMultiplier;
+	#allowMint;
+	#leverageDelta;
+	#poolService;
+	constructor(service, options_ = {}) {
+		super(service.sdk);
+		const { borrowerKey, depositorKey, faucet, poolDepositMultiplier = 30000n, minDebtMultiplier = 10100n, leverageDelta = 500n, allowMint = false } = options_;
+		this.#service = service;
+		this.#allowMint = allowMint;
+		this.#logger = require_sdk_utils_childLogger.childLogger("AccountOpener", service.sdk.logger);
+		this.#anvil = require_dev_createAnvilClient.extendAnvilClient(service.sdk.client);
+		try {
+			this.#faucet = faucet ?? service.sdk.addressProvider.getAddress("FAUCET");
+		} catch (_e) {
+			this.#logger?.warn("faucet not found, will not claim from faucet");
+		}
+		this.borrowerKey = borrowerKey ?? (0, viem_accounts.generatePrivateKey)();
+		this.depositorKey = depositorKey ?? (0, viem_accounts.generatePrivateKey)();
+		this.#poolDepositMultiplier = BigInt(poolDepositMultiplier);
+		this.#minDebtMultiplier = BigInt(minDebtMultiplier);
+		this.#leverageDelta = BigInt(leverageDelta);
+		this.#poolService = new require_sdk_pools_PoolService.PoolService(service.sdk);
+		this.#logger?.info({
+			borrower: (0, viem_accounts.privateKeyToAccount)(this.borrowerKey).address,
+			depositor: (0, viem_accounts.privateKeyToAccount)(this.depositorKey).address,
+			faucet: this.faucet,
+			poolDepositMultiplier: this.#poolDepositMultiplier.toString(),
+			minDebtMultiplier: this.#minDebtMultiplier.toString(),
+			leverageDelta: this.#leverageDelta.toString(),
+			allowMint: this.#allowMint
+		}, "account opener options");
+	}
+	get borrower() {
+		if (!this.#borrower) throw new Error("borrower can be used only after openCreditAccounts");
+		return this.#borrower;
+	}
+	get depositor() {
+		if (!this.#depositor) throw new Error("depositor can be used only after openCreditAccounts");
+		return this.#depositor;
+	}
+	/**
+	* Tries to open account with underlying only in each CM
+	*/
+	async openCreditAccounts(targets, depositIntoPools = true, claimFromFaucet = true) {
+		this.#logger?.info({
+			targets,
+			depositIntoPools,
+			claimFromFaucet
+		}, "opening credit accounts");
+		let deposits = [];
+		if (depositIntoPools) try {
+			deposits = await this.#depositIntoPools(targets);
+		} catch (e) {
+			this.#logger?.warn(`failed to deposit into pools: ${e}`);
+		}
+		if (claimFromFaucet) await this.#prepareBorrower(targets);
+		const toApprove = new require_sdk_utils_AddressMap.AddressMap();
+		for (const c of targets) {
+			const cm = this.sdk.marketRegister.findCreditManager(c.creditManager);
+			const toApproveOnCM = toApprove.get(c.creditManager) ?? /* @__PURE__ */ new Set();
+			toApproveOnCM.add(cm.underlying);
+			toApprove.upsert(c.creditManager, toApproveOnCM);
+		}
+		for (const [cmAddr, tokens] of toApprove.entries()) {
+			const cm = this.sdk.marketRegister.findCreditManager(cmAddr);
+			for (const token of tokens) await this.#approve(token, cm);
+		}
+		const accounts = [];
+		let success = 0;
+		for (let i = 0; i < targets.length; i++) {
+			const target = targets[i];
+			try {
+				const result = await this.#openAccount(target, i + 1, targets.length);
+				accounts.push(result);
+				success += result.account ? 1 : 0;
+				if (result.error) this.#logger?.error(new Error(`failed to open account #${i + 1}/${targets.length}`, { cause: result.error }));
+			} catch (e) {
+				this.#logger?.error(new Error(`failed to open account #${i + 1}/${targets.length}`, { cause: e }));
+				accounts.push({
+					input: target,
+					error: e
+				});
+			}
+		}
+		this.#logger?.info(`opened ${success}/${targets.length} accounts`);
+		try {
+			await this.#directlyDistributeTokens(accounts);
+			this.#logger?.info("distributed direct transfer tokens");
+		} catch (e) {
+			this.#logger?.error(`failed to distribute tokens: ${e}`);
+		}
+		return {
+			deposits,
+			accounts
+		};
+	}
+	async #openAccount(input, index, total) {
+		const { creditManager, target: collateral } = input;
+		const cm = this.sdk.marketRegister.findCreditManager(creditManager);
+		const symbol = this.sdk.tokensMeta.symbol(collateral);
+		const logger = this.#logger?.child?.({
+			creditManager: cm.name,
+			collateral: symbol
+		});
+		logger?.debug(`opening account #${index}/${total}`);
+		const borrower = await this.#getBorrower();
+		const preview = await this.prepareOpen(input);
+		const humanizedInput = this.#humanizePreview(input, preview);
+		let hash;
+		try {
+			hash = await require_sdk_utils_viem_sendRawTx.sendRawTx(this.#anvil, {
+				tx: preview.tx,
+				account: borrower
+			});
+			logger?.debug(`send transaction ${hash}`);
+		} catch (e) {
+			return {
+				input,
+				humanizedInput,
+				error: e,
+				rawTx: {
+					to: preview.tx.to,
+					callData: preview.tx.callData,
+					value: preview.tx.value
+				}
+			};
+		}
+		const receipt = await this.#anvil.waitForTransactionReceipt({ hash });
+		if (receipt.status === "reverted") return {
+			input,
+			humanizedInput,
+			error: new OpenTxRevertedError(hash),
+			txHash: hash,
+			rawTx: {
+				to: preview.tx.to,
+				callData: preview.tx.callData,
+				value: preview.tx.value
+			}
+		};
+		logger?.info(`opened credit account ${index}/${total}`);
+		const logs = (0, viem.parseEventLogs)({
+			abi: require_abi_310_generated.iCreditFacadeV310Abi,
+			logs: receipt.logs,
+			eventName: "OpenCreditAccount"
+		});
+		logger?.info(`found ${logs.length} logs`);
+		let account;
+		if (logs.length > 0) try {
+			logger?.debug(`getting credit account data for ${logs[0].args.creditAccount}`);
+			account = await this.#service.getCreditAccountData(logs[0].args.creditAccount);
+		} catch (e) {
+			logger?.error(`failed to get credit account data: ${e}`);
+		}
+		return {
+			input,
+			humanizedInput,
+			txHash: hash,
+			rawTx: {
+				to: preview.tx.to,
+				callData: preview.tx.callData,
+				value: preview.tx.value
+			},
+			account
+		};
+	}
+	async prepareOpen(input) {
+		const { creditManager, target, slippage = 50, directTransfer = [] } = input;
+		const borrower = await this.#getBorrower();
+		const cm = this.sdk.marketRegister.findCreditManager(creditManager);
+		const symbol = this.sdk.tokensMeta.symbol(target);
+		const logger = this.#logger?.child?.({
+			creditManager: cm.name,
+			target: symbol
+		});
+		const leverage = this.#getLeverage(input);
+		const { underlying } = cm.creditFacade;
+		const minDebt = this.#minDebtMultiplier * cm.creditFacade.minDebt / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		const expectedUnderlyingBalance = minDebt * leverage / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		const expectedBalances = [];
+		const leftoverBalances = [];
+		for (const t of cm.creditManager.collateralTokens) {
+			const token = t;
+			expectedBalances.push({
+				token,
+				balance: token === underlying ? expectedUnderlyingBalance : 1n
+			});
+			leftoverBalances.push({
+				token,
+				balance: 1n
+			});
+		}
+		logger?.debug({
+			minDebt: this.sdk.tokensMeta.formatBN(underlying, minDebt, { symbol: true }),
+			leverage: leverage.toString(),
+			expectedUnderlyingBalance: this.sdk.tokensMeta.formatBN(underlying, expectedUnderlyingBalance, { symbol: true })
+		}, "looking for open strategy");
+		let borrowerBalance = await this.#anvil.readContract({
+			address: underlying,
+			abi: require_abi_iERC20.ierc20Abi,
+			functionName: "balanceOf",
+			args: [borrower.address]
+		});
+		if (borrowerBalance < minDebt) {
+			this.#logger?.warn(`borrower balance in underlying: ${this.sdk.tokensMeta.formatBN(underlying, borrowerBalance, { symbol: true })} is less than the minimum debt: ${this.sdk.tokensMeta.formatBN(underlying, minDebt, { symbol: true })}`);
+			if (this.#allowMint) borrowerBalance = await this.#tryMint(underlying, borrower, minDebt - borrowerBalance);
+		}
+		this.#logger?.debug(`borrower balance in underlying: ${this.sdk.tokensMeta.formatBN(underlying, borrowerBalance, { symbol: true })}`);
+		const strategy = await this.sdk.routerFor(cm).findOpenStrategyPath({
+			creditManager: cm.creditManager,
+			expectedBalances,
+			leftoverBalances,
+			slippage,
+			target
+		});
+		logger?.debug(strategy, "found open strategy");
+		const strategyCalls = await require_dev_midasUtils.prependMidasReceiveGreenlist({
+			cm,
+			client: this.#anvil,
+			calls: strategy.calls,
+			logger
+		});
+		const debt = minDebt * (leverage - require_sdk_constants_math.PERCENTAGE_FACTOR) / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		const averageQuota = this.#getCollateralQuota(cm, target, strategy.amount, debt, logger);
+		const minQuota = this.#getCollateralQuota(cm, target, strategy.minAmount, debt, logger);
+		for (const token of directTransfer) {
+			averageQuota.push({
+				token,
+				balance: DIRECT_TRANSFERS_QUOTA
+			});
+			minQuota.push({
+				token,
+				balance: DIRECT_TRANSFERS_QUOTA
+			});
+		}
+		logger?.debug({
+			averageQuota,
+			minQuota
+		}, "calculated quotas");
+		const tx = await this.#service.openCA({
+			creditManager: cm.creditManager.address,
+			averageQuota,
+			minQuota,
+			collateral: [{
+				token: underlying,
+				balance: minDebt
+			}],
+			debt,
+			calls: strategyCalls,
+			ethAmount: 0n,
+			permits: {},
+			to: borrower.address,
+			referralCode: 0n
+		});
+		logger?.debug(`open account tx: ${this.sdk.stringifyFunctionData(tx.to, tx.callData)}`);
+		logger?.debug("prepared open account transaction");
+		return {
+			tx,
+			leverage,
+			collateral: {
+				token: underlying,
+				balance: minDebt
+			},
+			minQuota,
+			averageQuota,
+			slippage
+		};
+	}
+	async getOpenedAccounts() {
+		return await this.#service.getCreditAccounts({ owner: this.borrower.address });
+	}
+	async #depositIntoPools(targets) {
+		this.#logger?.debug("checking and topping up pools if necessary");
+		const minAvailableByPool = new require_sdk_utils_AssetsMap.AssetsMap();
+		for (let i = 0; i < targets.length; i++) {
+			const t = targets[i];
+			const leverage = this.#getLeverage(t);
+			const cm = this.sdk.marketRegister.findCreditManager(t.creditManager);
+			let amount = this.#minDebtMultiplier * cm.creditFacade.minDebt / require_sdk_constants_math.PERCENTAGE_FACTOR * (leverage - require_sdk_constants_math.PERCENTAGE_FACTOR) / require_sdk_constants_math.PERCENTAGE_FACTOR * this.#poolDepositMultiplier / require_sdk_constants_math.PERCENTAGE_FACTOR;
+			amount = amount > cm.creditFacade.maxDebt ? cm.creditFacade.maxDebt : amount;
+			minAvailableByPool.inc(cm.pool, amount);
+			this.#logger?.debug(`target #${i + 1} (${this.labelAddress(t.target)}) needs ${this.sdk.tokensMeta.formatBN(cm.underlying, amount, { symbol: true })} in pool (leverage: ${Number(leverage / require_sdk_constants_math.PERCENTAGE_FACTOR)}%)`);
+		}
+		const deposits = [];
+		const claims = new require_sdk_utils_AssetsMap.AssetsMap();
+		for (const [p, minAvailable] of minAvailableByPool.entries()) {
+			const pool = this.sdk.marketRegister.findByPool(p).pool.pool;
+			let diff = minAvailable - pool.availableLiquidity;
+			diff = diff < 0n ? 0n : diff;
+			const [minS, availableS, diffS] = [
+				minAvailable,
+				pool.availableLiquidity,
+				diff
+			].map((v) => this.sdk.tokensMeta.formatBN(pool.underlying, v, { symbol: true }));
+			this.#logger?.debug(`Pool ${this.labelAddress(pool.address)} has ${availableS} liquidity, needs ${diffS} more for the minimum of ${minS}`);
+			if (diff > 0n) {
+				deposits.push([pool, diff]);
+				claims.inc(pool.underlying, diff * require_sdk_constants_math.PERCENTAGE_FACTOR / 8950n);
+			}
+		}
+		const depositor = await this.#getDepositor();
+		this.#logger?.debug(`depositor: ${depositor.address}`);
+		try {
+			await this.#claimFromFaucet(depositor, "depositor", claims);
+		} catch (e) {
+			if (this.#allowMint) this.#logger?.error(`depositor failed to claim from faucet: ${e}`);
+			else throw e;
+		}
+		const results = [];
+		for (const [pool, amount] of deposits) {
+			const result = await this.#depositToPool(pool, depositor, amount);
+			results.push(result);
+		}
+		return results;
+	}
+	async #depositToPool(pool, depositor, amount) {
+		const { underlying, address } = pool;
+		const poolName = this.sdk.labelAddress(address);
+		const poolData = {
+			pool: address,
+			token: underlying,
+			amount
+		};
+		let txHash;
+		try {
+			const amnt = this.sdk.tokensMeta.formatBN(pool.underlying, amount, { symbol: true });
+			this.#logger?.debug(`depositing ${amnt} into pool ${poolName}`);
+			let allowance = await this.#anvil.readContract({
+				address: underlying,
+				abi: require_abi_iERC20.ierc20Abi,
+				functionName: "balanceOf",
+				args: [depositor.address]
+			});
+			if (allowance < amount) {
+				this.#logger?.warn(`depositor balance in underlying: ${this.sdk.tokensMeta.formatBN(pool.underlying, allowance, { symbol: true })} is less than the amount to deposit: ${amnt}`);
+				if (this.#allowMint) allowance = await this.#tryMint(underlying, depositor, amount - allowance);
+			}
+			this.#logger?.debug(`depositor balance in underlying: ${this.sdk.tokensMeta.formatBN(pool.underlying, allowance, { symbol: true })}`);
+			const tokensOut = this.#poolService.getDepositTokensOut(address, underlying);
+			this.#logger?.debug({ tokensOut: tokensOut.map((t) => this.labelAddress(t)) }, "deposit tokens out");
+			if (tokensOut.length === 0) throw new Error(`no tokens out found for pool ${poolName}`);
+			const tokenOut = tokensOut[0];
+			const metadata = this.#poolService.getDepositMetadata(address, underlying, tokenOut);
+			this.logger?.debug({
+				underlying: this.labelAddress(underlying),
+				tokenOut: this.labelAddress(tokenOut),
+				...metadata
+			}, "pool deposit metadata");
+			txHash = await this.#anvil.writeContract({
+				account: depositor,
+				address: underlying,
+				abi: require_abi_iERC20.ierc20Abi,
+				functionName: "approve",
+				args: [metadata.approveTarget, allowance],
+				chain: this.#anvil.chain
+			});
+			let receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });
+			if (receipt.status === "reverted") throw new Error(`tx ${txHash} that approves underlying from depositor for pool ${poolName} reverted`);
+			this.#logger?.debug(`depositor approved underlying for pool ${poolName}: ${txHash}`);
+			const depositCall = this.#poolService.addLiquidity({
+				collateral: {
+					token: underlying,
+					balance: amount
+				},
+				pool: address,
+				wallet: depositor.address,
+				meta: metadata
+			});
+			if (!depositCall) throw new Error(`no deposit call could be created for ${poolName}`);
+			txHash = await this.#anvil.sendTransaction({
+				account: depositor,
+				to: depositCall.tx.to,
+				data: depositCall.tx.callData,
+				value: BigInt(depositCall.tx.value ?? "0"),
+				chain: this.#anvil.chain
+			});
+			receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });
+			if (receipt.status === "reverted") throw new Error(`tx ${txHash} that deposits to pool ${poolName} reverted`);
+			this.#logger?.debug(`deposited ${amnt} into ${poolName}`);
+			return {
+				...poolData,
+				txHash,
+				success: true
+			};
+		} catch (e) {
+			this.#logger?.error(`failed to deposit to pool ${poolName}: ${e}`);
+			return {
+				...poolData,
+				txHash,
+				success: false,
+				error: e
+			};
+		}
+	}
+	/**
+	* Tries to mint tokens, returns the balance after attempt (success or not)
+	* @param token
+	* @param dest
+	* @param amount
+	*/
+	async #tryMint(token, dest, amount) {
+		return require_dev_mint_factory.createMinter(this.sdk, this.#anvil, token).tryMint(token, dest.address, amount);
+	}
+	/**
+	* Creates borrower wallet,
+	* Sets ETH balance,
+	* Gets tokens from faucet,
+	* Gets DEGEN_NFT,
+	*/
+	async #prepareBorrower(targets) {
+		const borrower = await this.#getBorrower();
+		const degenNFTS = {};
+		const claims = new require_sdk_utils_AssetsMap.AssetsMap();
+		for (const target of targets) {
+			const cm = this.sdk.marketRegister.findCreditManager(target.creditManager);
+			const { degenNFT } = cm.creditFacade;
+			const minDebt = this.#minDebtMultiplier * cm.creditFacade.minDebt / require_sdk_constants_math.PERCENTAGE_FACTOR;
+			claims.inc(cm.underlying, minDebt * 11n / 10n);
+			if ((0, viem.isAddress)(degenNFT) && degenNFT !== "0x0000000000000000000000000000000000000000") degenNFTS[degenNFT] = (degenNFTS[degenNFT] ?? 0) + 1;
+		}
+		await this.#claimFromFaucet(borrower, "borrower", claims);
+		for (const [degenNFT, amount] of Object.entries(degenNFTS)) await this.#mintDegenNft(degenNFT, borrower.address, amount);
+		this.#logger?.debug("prepared borrower");
+		return borrower;
+	}
+	async #claimFromFaucet(claimer, role, claims) {
+		await require_dev_claimFromFaucet.claimFromFaucet({
+			sdk: this.sdk,
+			publicClient: this.#anvil,
+			wallet: this.#anvil,
+			faucet: this.faucet,
+			claimer,
+			role,
+			amount: claims.entries().map(([k, v]) => ({
+				token: k,
+				amount: v
+			})),
+			logger: this.#logger
+		});
+	}
+	async #approve(token, cm) {
+		const borrower = await this.#getBorrower();
+		const symbol = this.#service.sdk.tokensMeta.symbol(token);
+		try {
+			if (symbol === "USDT") {
+				const hash = await this.#anvil.writeContract({
+					account: borrower,
+					address: token,
+					abi: require_abi_iERC20.ierc20Abi,
+					functionName: "approve",
+					args: [cm.creditManager.address, 0n],
+					chain: this.#anvil.chain
+				});
+				await this.#anvil.waitForTransactionReceipt({ hash });
+			}
+			const hash = await this.#anvil.writeContract({
+				account: borrower,
+				address: token,
+				abi: require_abi_iERC20.ierc20Abi,
+				functionName: "approve",
+				args: [cm.creditManager.address, require_sdk_constants_math.MAX_UINT256],
+				chain: this.#anvil.chain
+			});
+			if ((await this.#anvil.waitForTransactionReceipt({ hash })).status === "reverted") this.#logger?.error(`failed to allowed credit manager ${cm.creditManager.name} to spend ${symbol} (${token}), tx reverted: ${hash}`);
+			else this.#logger?.debug(`allowed credit manager ${cm.creditManager.name} to spend ${symbol} (${token}), tx: ${hash}`);
+		} catch (e) {
+			this.#logger?.error(`failed to allowed credit manager ${cm.creditManager.name} to spend ${symbol} (${token}): ${e}`);
+		}
+	}
+	async #mintDegenNft(degenNFT, to, amount) {
+		if (amount <= 0) return;
+		let minter;
+		try {
+			minter = await this.#anvil.readContract({
+				address: degenNFT,
+				abi: require_dev_abi.iDegenNftv2Abi,
+				functionName: "minter"
+			});
+		} catch (e) {
+			this.#logger?.error(`failed to get minter of degenNFT ${degenNFT}: ${e}`);
+			return;
+		}
+		try {
+			await this.#anvil.impersonateAccount({ address: minter });
+			await this.#anvil.setBalance({
+				address: minter,
+				value: (0, viem.parseEther)("100")
+			});
+			const hash = await this.#anvil.writeContract({
+				account: minter,
+				address: degenNFT,
+				abi: require_dev_abi.iDegenNftv2Abi,
+				functionName: "mint",
+				args: [to, BigInt(amount)],
+				chain: this.#anvil.chain
+			});
+			if ((await this.#anvil.waitForTransactionReceipt({ hash })).status === "reverted") this.#logger?.error(`failed to mint ${amount} degenNFT ${degenNFT} to borrower ${to}, tx reverted: ${hash}`);
+			this.#logger?.debug(`minted ${amount} degenNFT ${degenNFT} to borrower ${to}, tx: ${hash}`);
+		} catch (e) {
+			this.#logger?.error(`failed to mint ${amount} degenNFT ${degenNFT} to borrower ${to}: ${e}`);
+		} finally {
+			await this.#anvil.stopImpersonatingAccount({ address: minter });
+		}
+	}
+	async #getBorrower() {
+		if (!this.#borrower) {
+			this.#borrower = await this.#createAccount(this.borrowerKey);
+			this.#logger?.info(`created borrower ${this.#borrower.address}`);
+		}
+		return this.borrower;
+	}
+	async #getDepositor() {
+		if (!this.#depositor) {
+			this.#depositor = await this.#createAccount(this.depositorKey);
+			this.#logger?.info(`created depositor ${this.#depositor.address}`);
+		}
+		return this.depositor;
+	}
+	async #createAccount(privateKey) {
+		const acc = (0, viem_accounts.privateKeyToAccount)(privateKey);
+		await this.#anvil.setBalance({
+			address: acc.address,
+			value: (0, viem.parseEther)("100")
+		});
+		return acc;
+	}
+	/**
+	* Claims tokens from faucet, uniformly distributes them to accounts
+	* @param targets
+	* @returns
+	*/
+	async #directlyDistributeTokens(targets) {
+		const tokens = new require_sdk_utils_AddressSet.AddressSet(targets.flatMap((t) => t.input.directTransfer ?? []));
+		if (tokens.size === 0) return;
+		const distributorKey = (0, viem_accounts.generatePrivateKey)();
+		const distributor = (0, viem_accounts.privateKeyToAccount)(distributorKey);
+		await this.#anvil.setBalance({
+			address: distributor.address,
+			value: (0, viem.parseEther)("100")
+		});
+		await require_dev_claimFromFaucet.claimFromFaucet({
+			sdk: this.sdk,
+			publicClient: this.#anvil,
+			wallet: this.#anvil,
+			faucet: this.faucet,
+			claimer: distributor,
+			role: "reward token distributor",
+			logger: this.#logger
+		});
+		const actualBalances = await this.#anvil.multicall({
+			contracts: tokens.map((token) => ({
+				address: token,
+				abi: viem.erc20Abi,
+				functionName: "balanceOf",
+				args: [distributor.address]
+			})),
+			allowFailure: false,
+			batchSize: 0
+		});
+		const tokensArr = tokens.asArray();
+		for (let i = 0; i < tokensArr.length; i++) {
+			const token = tokensArr[i];
+			const balance = actualBalances[i];
+			this.#logger?.debug(`${this.labelAddress(token)} balance: ${this.sdk.tokensMeta.formatBN(token, balance)}`);
+		}
+		for (const { account, input } of targets) {
+			if (!account) continue;
+			const directTransfer = new require_sdk_utils_AddressSet.AddressSet(input.directTransfer);
+			for (let i = 0; i < tokensArr.length; i++) {
+				const token = tokensArr[i];
+				if (!directTransfer.has(token)) continue;
+				const balance = actualBalances[i] / BigInt(targets.length);
+				this.#logger?.debug(`sending ${balance} ${token} to ${account.creditAccount}`);
+				const hash = await this.#anvil.writeContract({
+					account: distributor,
+					address: token,
+					abi: viem.erc20Abi,
+					functionName: "transfer",
+					args: [account.creditAccount, balance],
+					chain: this.#anvil.chain
+				});
+				if ((await this.#anvil.waitForTransactionReceipt({ hash })).status === "reverted") this.#logger?.error(`failed to send ${token} to ${account.creditAccount}, tx ${hash} reverted`);
+				else this.#logger?.debug(`sent ${token} to ${account.creditAccount}, tx: ${hash}`);
+			}
+		}
+	}
+	#getCollateralQuota(cm, collateral, collateralAmount, debt, logger) {
+		const { underlying, creditManager: { liquidationThresholds } } = cm;
+		if (collateral.toLowerCase() === underlying.toLowerCase()) return [];
+		const collateralLT = BigInt(liquidationThresholds.mustGet(collateral));
+		const quotaInfo = this.sdk.marketRegister.findByCreditManager(cm.creditManager.address).pool.pqk.quotas.mustGet(collateral);
+		const availableQuota = quotaInfo.limit - quotaInfo.totalQuoted;
+		if (availableQuota <= 0n) throw new Error(`quota exceeded for asset ${this.labelAddress(collateral)} in ${cm.name}`);
+		const amount = this.sdk.marketRegister.findByCreditManager(cm.creditManager.address).priceOracle.convert(collateral, underlying, collateralAmount);
+		const desiredQuota = this.#calcQuota(amount, debt, collateralLT);
+		logger?.debug({
+			desiredQuota: this.sdk.tokensMeta.formatBN(underlying, desiredQuota, { symbol: true }),
+			availableQuota: this.sdk.tokensMeta.formatBN(underlying, availableQuota, { symbol: true }),
+			collateralAmount: this.sdk.tokensMeta.formatBN(collateral, collateralAmount, { symbol: true }),
+			amount: this.sdk.tokensMeta.formatBN(underlying, amount, { symbol: true }),
+			debt: this.sdk.tokensMeta.formatBN(underlying, debt, { symbol: true }),
+			lt: Number(collateralLT)
+		}, "calculated quota");
+		return [{
+			token: collateral,
+			balance: desiredQuota < availableQuota ? desiredQuota : availableQuota
+		}];
+	}
+	#calcQuota(amount, debt, lt) {
+		let quota = amount * lt / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		quota = debt < quota ? debt : quota;
+		quota = quota * (require_sdk_constants_math.PERCENTAGE_FACTOR + 500n) / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		return quota / require_sdk_constants_math.PERCENTAGE_FACTOR * require_sdk_constants_math.PERCENTAGE_FACTOR;
+	}
+	/**
+	* Returns leverage in percentage factor format
+	* @param param0
+	* @returns
+	*/
+	#getLeverage({ creditManager, target, leverage }) {
+		if (leverage) return BigInt(leverage) * require_sdk_constants_math.PERCENTAGE_FACTOR;
+		const cm = this.sdk.marketRegister.findCreditManager(creditManager);
+		const lt = BigInt(cm.creditManager.liquidationThresholds.mustGet(target));
+		const d = this.#leverageDelta;
+		let result = require_sdk_constants_math.PERCENTAGE_FACTOR * (1n + (lt - d) / (require_sdk_constants_math.PERCENTAGE_FACTOR - lt));
+		result = result > 10000n * 10n ? require_sdk_constants_math.PERCENTAGE_FACTOR * 10n : result;
+		result = BigInt(Math.floor(Number(result) / 1e3) * 1e3);
+		return result;
+	}
+	#humanizePreview(input, preview) {
+		return {
+			creditManager: this.sdk.labelAddress(input.creditManager),
+			target: this.sdk.labelAddress(input.target),
+			leverage: Number(preview.leverage),
+			slippage: preview.slippage,
+			collateral: this.sdk.tokensMeta.formatBN(preview.collateral, { symbol: true }),
+			minQuota: preview.minQuota.filter((q) => q.balance > 10n).map((q) => this.sdk.tokensMeta.formatBN(q, { symbol: true })),
+			averageQuota: preview.averageQuota.filter((q) => q.balance > 10n).map((q) => this.sdk.tokensMeta.formatBN(q, { symbol: true }))
+		};
+	}
+	get faucet() {
+		if (!this.#faucet) throw new Error("faucet not found");
+		return this.#faucet;
+	}
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var AccountOpener_exports = {};
-__export(AccountOpener_exports, {
-  AccountOpener: () => AccountOpener,
-  OpenTxRevertedError: () => OpenTxRevertedError
-});
-module.exports = __toCommonJS(AccountOpener_exports);
-var import_viem = require("viem");
-var import_accounts = require("viem/accounts");
-var import_generated = require("../abi/310/generated.js");
-var import_iERC20 = require("../abi/iERC20.js");
-var import_sdk = require("../sdk/index.js");
-var import_abi = require("./abi.js");
-var import_claimFromFaucet = require("./claimFromFaucet.js");
-var import_createAnvilClient = require("./createAnvilClient.js");
-var import_mint = require("./mint/index.js");
-const DIRECT_TRANSFERS_QUOTA = 10000n;
-class OpenTxRevertedError extends import_viem.BaseError {
-  txHash;
-  constructor(txHash) {
-    super("open credit account tx reverted");
-    this.txHash = txHash;
-  }
-}
-class AccountOpener extends import_sdk.SDKConstruct {
-  borrowerKey;
-  depositorKey;
-  #service;
-  #anvil;
-  #logger;
-  #borrower;
-  #depositor;
-  #faucet;
-  #poolDepositMultiplier;
-  #minDebtMultiplier;
-  #allowMint;
-  #leverageDelta;
-  #poolService;
-  constructor(service, options_ = {}) {
-    super(service.sdk);
-    const {
-      borrowerKey,
-      depositorKey,
-      faucet,
-      poolDepositMultiplier = 30000n,
-      minDebtMultiplier = 10100n,
-      leverageDelta = 500n,
-      allowMint = false
-    } = options_;
-    this.#service = service;
-    this.#allowMint = allowMint;
-    this.#logger = (0, import_sdk.childLogger)("AccountOpener", service.sdk.logger);
-    this.#anvil = (0, import_createAnvilClient.extendAnvilClient)(service.sdk.client);
-    try {
-      this.#faucet = faucet ?? service.sdk.addressProvider.getAddress("FAUCET");
-    } catch (_e) {
-      this.#logger?.warn("faucet not found, will not claim from faucet");
-    }
-    this.borrowerKey = borrowerKey ?? (0, import_accounts.generatePrivateKey)();
-    this.depositorKey = depositorKey ?? (0, import_accounts.generatePrivateKey)();
-    this.#poolDepositMultiplier = BigInt(poolDepositMultiplier);
-    this.#minDebtMultiplier = BigInt(minDebtMultiplier);
-    this.#leverageDelta = BigInt(leverageDelta);
-    this.#poolService = new import_sdk.PoolService(service.sdk);
-    this.#logger?.info(
-      {
-        borrower: (0, import_accounts.privateKeyToAccount)(this.borrowerKey).address,
-        depositor: (0, import_accounts.privateKeyToAccount)(this.depositorKey).address,
-        faucet: this.faucet,
-        poolDepositMultiplier: this.#poolDepositMultiplier.toString(),
-        minDebtMultiplier: this.#minDebtMultiplier.toString(),
-        leverageDelta: this.#leverageDelta.toString(),
-        allowMint: this.#allowMint
-      },
-      "account opener options"
-    );
-  }
-  get borrower() {
-    if (!this.#borrower) {
-      throw new Error("borrower can be used only after openCreditAccounts");
-    }
-    return this.#borrower;
-  }
-  get depositor() {
-    if (!this.#depositor) {
-      throw new Error("depositor can be used only after openCreditAccounts");
-    }
-    return this.#depositor;
-  }
-  /**
-   * Tries to open account with underlying only in each CM
-   */
-  async openCreditAccounts(targets, depositIntoPools = true, claimFromFaucet2 = true) {
-    this.#logger?.info(
-      {
-        targets,
-        depositIntoPools,
-        claimFromFaucet: claimFromFaucet2
-      },
-      "opening credit accounts"
-    );
-    await Promise.all([
-      this.sdk.tokensMeta.loadTokenData(),
-      this.sdk.marketRegister.loadZappers()
-    ]);
-    let deposits = [];
-    if (depositIntoPools) {
-      try {
-        deposits = await this.#depositIntoPools(targets);
-      } catch (e) {
-        this.#logger?.warn(`failed to deposit into pools: ${e}`);
-      }
-    }
-    if (claimFromFaucet2) {
-      await this.#prepareBorrower(targets);
-    }
-    const toApprove = new import_sdk.AddressMap();
-    for (const c of targets) {
-      const cm = this.sdk.marketRegister.findCreditManager(c.creditManager);
-      const toApproveOnCM = toApprove.get(c.creditManager) ?? /* @__PURE__ */ new Set();
-      toApproveOnCM.add(cm.underlying);
-      toApprove.upsert(c.creditManager, toApproveOnCM);
-    }
-    for (const [cmAddr, tokens] of toApprove.entries()) {
-      const cm = this.sdk.marketRegister.findCreditManager(cmAddr);
-      for (const token of tokens) {
-        await this.#approve(token, cm);
-      }
-    }
-    const accounts = [];
-    let success = 0;
-    for (let i = 0; i < targets.length; i++) {
-      const target = targets[i];
-      try {
-        const result = await this.#openAccount(target, i + 1, targets.length);
-        accounts.push(result);
-        success += result.account ? 1 : 0;
-        if (result.error) {
-          this.#logger?.error(
-            new Error(`failed to open account #${i + 1}/${targets.length}`, {
-              cause: result.error
-            })
-          );
-        }
-      } catch (e) {
-        this.#logger?.error(
-          new Error(`failed to open account #${i + 1}/${targets.length}`, {
-            cause: e
-          })
-        );
-        accounts.push({
-          input: target,
-          error: e
-        });
-      }
-    }
-    this.#logger?.info(`opened ${success}/${targets.length} accounts`);
-    try {
-      await this.#directlyDistributeTokens(accounts);
-      this.#logger?.info("distributed direct transfer tokens");
-    } catch (e) {
-      this.#logger?.error(`failed to distribute tokens: ${e}`);
-    }
-    return { deposits, accounts };
-  }
-  async #openAccount(input, index, total) {
-    const { creditManager, target: collateral } = input;
-    const cm = this.sdk.marketRegister.findCreditManager(creditManager);
-    const symbol = this.sdk.tokensMeta.symbol(collateral);
-    const logger = this.#logger?.child?.({
-      creditManager: cm.name,
-      collateral: symbol
-    });
-    logger?.debug(`opening account #${index}/${total}`);
-    const borrower = await this.#getBorrower();
-    const preview = await this.prepareOpen(input);
-    const humanizedInput = this.#humanizePreview(input, preview);
-    let hash;
-    try {
-      hash = await (0, import_sdk.sendRawTx)(this.#anvil, {
-        tx: preview.tx,
-        account: borrower
-      });
-      logger?.debug(`send transaction ${hash}`);
-    } catch (e) {
-      return {
-        input,
-        humanizedInput,
-        error: e,
-        rawTx: {
-          to: preview.tx.to,
-          callData: preview.tx.callData,
-          value: preview.tx.value
-        }
-      };
-    }
-    const receipt = await this.#anvil.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      return {
-        input,
-        humanizedInput,
-        error: new OpenTxRevertedError(hash),
-        txHash: hash,
-        rawTx: {
-          to: preview.tx.to,
-          callData: preview.tx.callData,
-          value: preview.tx.value
-        }
-      };
-    }
-    logger?.info(`opened credit account ${index}/${total}`);
-    const logs = (0, import_viem.parseEventLogs)({
-      abi: import_generated.iCreditFacadeV310Abi,
-      logs: receipt.logs,
-      eventName: "OpenCreditAccount"
-    });
-    logger?.info(`found ${logs.length} logs`);
-    let account;
-    if (logs.length > 0) {
-      try {
-        logger?.debug(
-          `getting credit account data for ${logs[0].args.creditAccount}`
-        );
-        account = await this.#service.getCreditAccountData(
-          logs[0].args.creditAccount
-        );
-      } catch (e) {
-        logger?.error(`failed to get credit account data: ${e}`);
-      }
-    }
-    return {
-      input,
-      humanizedInput,
-      txHash: hash,
-      rawTx: {
-        to: preview.tx.to,
-        callData: preview.tx.callData,
-        value: preview.tx.value
-      },
-      account
-    };
-  }
-  async prepareOpen(input) {
-    const { creditManager, target, slippage = 50, directTransfer = [] } = input;
-    const borrower = await this.#getBorrower();
-    const cm = this.sdk.marketRegister.findCreditManager(creditManager);
-    const symbol = this.sdk.tokensMeta.symbol(target);
-    const logger = this.#logger?.child?.({
-      creditManager: cm.name,
-      target: symbol
-    });
-    const leverage = this.#getLeverage(input);
-    const { underlying } = cm.creditFacade;
-    const minDebt = this.#minDebtMultiplier * cm.creditFacade.minDebt / import_sdk.PERCENTAGE_FACTOR;
-    const expectedUnderlyingBalance = minDebt * leverage / import_sdk.PERCENTAGE_FACTOR;
-    const expectedBalances = [];
-    const leftoverBalances = [];
-    for (const t of cm.creditManager.collateralTokens) {
-      const token = t;
-      expectedBalances.push({
-        token,
-        balance: token === underlying ? expectedUnderlyingBalance : 1n
-      });
-      leftoverBalances.push({
-        token,
-        balance: 1n
-      });
-    }
-    logger?.debug(
-      {
-        minDebt: this.sdk.tokensMeta.formatBN(underlying, minDebt, {
-          symbol: true
-        }),
-        leverage: leverage.toString(),
-        expectedUnderlyingBalance: this.sdk.tokensMeta.formatBN(
-          underlying,
-          expectedUnderlyingBalance,
-          { symbol: true }
-        )
-      },
-      "looking for open strategy"
-    );
-    let borrowerBalance = await this.#anvil.readContract({
-      address: underlying,
-      abi: import_iERC20.ierc20Abi,
-      functionName: "balanceOf",
-      args: [borrower.address]
-    });
-    if (borrowerBalance < minDebt) {
-      this.#logger?.warn(
-        `borrower balance in underlying: ${this.sdk.tokensMeta.formatBN(underlying, borrowerBalance, { symbol: true })} is less than the minimum debt: ${this.sdk.tokensMeta.formatBN(underlying, minDebt, { symbol: true })}`
-      );
-      if (this.#allowMint) {
-        borrowerBalance = await this.#tryMint(
-          underlying,
-          borrower,
-          minDebt - borrowerBalance
-        );
-      }
-    }
-    this.#logger?.debug(
-      `borrower balance in underlying: ${this.sdk.tokensMeta.formatBN(underlying, borrowerBalance, { symbol: true })}`
-    );
-    const strategy = await this.sdk.routerFor(cm).findOpenStrategyPath({
-      creditManager: cm.creditManager,
-      expectedBalances,
-      leftoverBalances,
-      slippage,
-      target
-    });
-    logger?.debug(strategy, "found open strategy");
-    const debt = minDebt * (leverage - import_sdk.PERCENTAGE_FACTOR) / import_sdk.PERCENTAGE_FACTOR;
-    const averageQuota = this.#getCollateralQuota(
-      cm,
-      target,
-      strategy.amount,
-      debt,
-      logger
-    );
-    const minQuota = this.#getCollateralQuota(
-      cm,
-      target,
-      strategy.minAmount,
-      debt,
-      logger
-    );
-    for (const token of directTransfer) {
-      averageQuota.push({ token, balance: DIRECT_TRANSFERS_QUOTA });
-      minQuota.push({ token, balance: DIRECT_TRANSFERS_QUOTA });
-    }
-    logger?.debug({ averageQuota, minQuota }, "calculated quotas");
-    const { tx, calls } = await this.#service.openCA({
-      creditManager: cm.creditManager.address,
-      averageQuota,
-      minQuota,
-      collateral: [{ token: underlying, balance: minDebt }],
-      debt,
-      calls: strategy.calls,
-      ethAmount: 0n,
-      permits: {},
-      to: borrower.address,
-      referralCode: 0n
-    });
-    for (let i = 0; i < calls.length; i++) {
-      const call = calls[i];
-      logger?.debug(
-        `call #${i + 1}: ${this.sdk.parseFunctionData(call.target, call.callData)}`
-      );
-    }
-    logger?.debug("prepared open account transaction");
-    return {
-      tx,
-      leverage,
-      collateral: { token: underlying, balance: minDebt },
-      minQuota,
-      averageQuota,
-      slippage
-    };
-  }
-  async getOpenedAccounts() {
-    return await this.#service.getCreditAccounts({
-      owner: this.borrower.address
-    });
-  }
-  async #depositIntoPools(targets) {
-    this.#logger?.debug("checking and topping up pools if necessary");
-    const minAvailableByPool = {};
-    for (let i = 0; i < targets.length; i++) {
-      const t = targets[i];
-      const leverage = this.#getLeverage(t);
-      const cm = this.sdk.marketRegister.findCreditManager(t.creditManager);
-      const minDebt = this.#minDebtMultiplier * cm.creditFacade.minDebt / import_sdk.PERCENTAGE_FACTOR;
-      let amount = minDebt * (leverage - import_sdk.PERCENTAGE_FACTOR) / import_sdk.PERCENTAGE_FACTOR * this.#poolDepositMultiplier / import_sdk.PERCENTAGE_FACTOR;
-      amount = amount > cm.creditFacade.maxDebt ? cm.creditFacade.maxDebt : amount;
-      minAvailableByPool[cm.pool] = (minAvailableByPool[cm.pool] ?? 0n) + amount;
-      this.#logger?.debug(
-        `target #${i + 1} (${this.labelAddress(t.target)}) needs ${this.sdk.tokensMeta.formatBN(cm.underlying, amount, { symbol: true })} in pool (leverage: ${Number(leverage / import_sdk.PERCENTAGE_FACTOR)}%)`
-      );
-    }
-    const deposits = [];
-    const claims = new import_sdk.AddressMap();
-    for (const [p, minAvailable] of Object.entries(minAvailableByPool)) {
-      const market = this.sdk.marketRegister.findByPool(p);
-      const pool = market.pool.pool;
-      let diff = minAvailable - pool.availableLiquidity;
-      diff = diff < 0n ? 0n : diff;
-      const [minS, availableS, diffS] = [
-        minAvailable,
-        pool.availableLiquidity,
-        diff
-      ].map(
-        (v) => this.sdk.tokensMeta.formatBN(pool.underlying, v, { symbol: true })
-      );
-      this.#logger?.debug(
-        `Pool ${this.labelAddress(pool.address)} has ${availableS} liquidity, needs ${diffS} more for the minimum of ${minS}`
-      );
-      if (diff > 0n) {
-        deposits.push([pool, diff]);
-        let claim = claims.get(pool.underlying) ?? 0n;
-        claim += diff * import_sdk.PERCENTAGE_FACTOR / 8950n;
-        claims.upsert(pool.underlying, claim);
-      }
-    }
-    const depositor = await this.#getDepositor();
-    this.#logger?.debug(`depositor: ${depositor.address}`);
-    try {
-      await this.#claimFromFaucet(depositor, "depositor", claims);
-    } catch (e) {
-      if (this.#allowMint) {
-        this.#logger?.error(`depositor failed to claim from faucet: ${e}`);
-      } else {
-        throw e;
-      }
-    }
-    const results = [];
-    for (const [pool, amount] of deposits) {
-      const result = await this.#depositToPool(pool, depositor, amount);
-      results.push(result);
-    }
-    return results;
-  }
-  async #depositToPool(pool, depositor, amount) {
-    const { underlying, address } = pool;
-    const poolName = this.sdk.labelAddress(address);
-    const poolData = {
-      pool: address,
-      token: underlying,
-      amount
-    };
-    let txHash;
-    try {
-      const amnt = this.sdk.tokensMeta.formatBN(pool.underlying, amount, {
-        symbol: true
-      });
-      this.#logger?.debug(`depositing ${amnt} into pool ${poolName}`);
-      let allowance = await this.#anvil.readContract({
-        address: underlying,
-        abi: import_iERC20.ierc20Abi,
-        functionName: "balanceOf",
-        args: [depositor.address]
-      });
-      if (allowance < amount) {
-        this.#logger?.warn(
-          `depositor balance in underlying: ${this.sdk.tokensMeta.formatBN(pool.underlying, allowance, { symbol: true })} is less than the amount to deposit: ${amnt}`
-        );
-        if (this.#allowMint) {
-          allowance = await this.#tryMint(
-            underlying,
-            depositor,
-            amount - allowance
-          );
-        }
-      }
-      this.#logger?.debug(
-        `depositor balance in underlying: ${this.sdk.tokensMeta.formatBN(pool.underlying, allowance, { symbol: true })}`
-      );
-      const tokensOut = this.#poolService.getDepositTokensOut(
-        address,
-        underlying
-      );
-      this.#logger?.debug(
-        { tokensOut: tokensOut.map((t) => this.labelAddress(t)) },
-        "deposit tokens out"
-      );
-      if (tokensOut.length === 0) {
-        throw new Error(`no tokens out found for pool ${poolName}`);
-      }
-      const tokenOut = tokensOut[0];
-      const metadata = this.#poolService.getDepositMetadata(
-        address,
-        underlying,
-        tokenOut
-      );
-      this.logger?.debug(
-        {
-          underlying: this.labelAddress(underlying),
-          tokenOut: this.labelAddress(tokenOut),
-          ...metadata
-        },
-        "pool deposit metadata"
-      );
-      txHash = await this.#anvil.writeContract({
-        account: depositor,
-        address: underlying,
-        abi: import_iERC20.ierc20Abi,
-        functionName: "approve",
-        args: [metadata.approveTarget, allowance],
-        chain: this.#anvil.chain
-      });
-      let receipt = await this.#anvil.waitForTransactionReceipt({
-        hash: txHash
-      });
-      if (receipt.status === "reverted") {
-        throw new Error(
-          `tx ${txHash} that approves underlying from depositor for pool ${poolName} reverted`
-        );
-      }
-      this.#logger?.debug(
-        `depositor approved underlying for pool ${poolName}: ${txHash}`
-      );
-      const depositCall = this.#poolService.addLiquidity({
-        collateral: { token: underlying, balance: amount },
-        pool: address,
-        wallet: depositor.address,
-        meta: metadata
-      });
-      if (!depositCall) {
-        throw new Error(`no deposit call could be created for ${poolName}`);
-      }
-      txHash = await this.#anvil.sendTransaction({
-        account: depositor,
-        to: depositCall.tx.to,
-        data: depositCall.tx.callData,
-        value: BigInt(depositCall.tx.value ?? "0"),
-        chain: this.#anvil.chain
-      });
-      receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });
-      if (receipt.status === "reverted") {
-        throw new Error(
-          `tx ${txHash} that deposits to pool ${poolName} reverted`
-        );
-      }
-      this.#logger?.debug(`deposited ${amnt} into ${poolName}`);
-      return {
-        ...poolData,
-        txHash,
-        success: true
-      };
-    } catch (e) {
-      this.#logger?.error(`failed to deposit to pool ${poolName}: ${e}`);
-      return {
-        ...poolData,
-        txHash,
-        success: false,
-        error: e
-      };
-    }
-  }
-  /**
-   * Tries to mint tokens, returns the balance after attempt (success or not)
-   * @param token
-   * @param dest
-   * @param amount
-   */
-  async #tryMint(token, dest, amount) {
-    const minter = (0, import_mint.createMinter)(this.sdk, this.#anvil, token);
-    return minter.tryMint(token, dest.address, amount);
-  }
-  /**
-   * Creates borrower wallet,
-   * Sets ETH balance,
-   * Gets tokens from faucet,
-   * Gets DEGEN_NFT,
-   */
-  async #prepareBorrower(targets) {
-    const borrower = await this.#getBorrower();
-    const degenNFTS = {};
-    const claims = new import_sdk.AddressMap();
-    for (const target of targets) {
-      const cm = this.sdk.marketRegister.findCreditManager(
-        target.creditManager
-      );
-      const market = this.sdk.marketRegister.findByCreditManager(
-        target.creditManager
-      );
-      const { degenNFT } = cm.creditFacade;
-      const minDebt = this.#minDebtMultiplier * cm.creditFacade.minDebt / import_sdk.PERCENTAGE_FACTOR;
-      const claim = claims.get(cm.underlying) ?? 0n;
-      claims.upsert(cm.underlying, claim + minDebt * 11n / 10n);
-      if ((0, import_viem.isAddress)(degenNFT) && degenNFT !== import_sdk.ADDRESS_0X0) {
-        degenNFTS[degenNFT] = (degenNFTS[degenNFT] ?? 0) + 1;
-      }
-    }
-    await this.#claimFromFaucet(borrower, "borrower", claims);
-    for (const [degenNFT, amount] of Object.entries(degenNFTS)) {
-      await this.#mintDegenNft(degenNFT, borrower.address, amount);
-    }
-    this.#logger?.debug("prepared borrower");
-    return borrower;
-  }
-  async #claimFromFaucet(claimer, role, claims) {
-    await (0, import_claimFromFaucet.claimFromFaucet)({
-      sdk: this.sdk,
-      publicClient: this.#anvil,
-      wallet: this.#anvil,
-      faucet: this.faucet,
-      claimer,
-      role,
-      amount: claims.entries().map(([k, v]) => ({ token: k, amount: v })),
-      logger: this.#logger
-    });
-  }
-  async #approve(token, cm) {
-    const borrower = await this.#getBorrower();
-    const symbol = this.#service.sdk.tokensMeta.symbol(token);
-    try {
-      if (symbol === "USDT") {
-        const hash2 = await this.#anvil.writeContract({
-          account: borrower,
-          address: token,
-          abi: import_iERC20.ierc20Abi,
-          functionName: "approve",
-          args: [cm.creditManager.address, 0n],
-          chain: this.#anvil.chain
-        });
-        await this.#anvil.waitForTransactionReceipt({
-          hash: hash2
-        });
-      }
-      const hash = await this.#anvil.writeContract({
-        account: borrower,
-        address: token,
-        abi: import_iERC20.ierc20Abi,
-        functionName: "approve",
-        args: [cm.creditManager.address, import_sdk.MAX_UINT256],
-        chain: this.#anvil.chain
-      });
-      const receipt = await this.#anvil.waitForTransactionReceipt({
-        hash
-      });
-      if (receipt.status === "reverted") {
-        this.#logger?.error(
-          `failed to allowed credit manager ${cm.creditManager.name} to spend ${symbol} (${token}), tx reverted: ${hash}`
-        );
-      } else {
-        this.#logger?.debug(
-          `allowed credit manager ${cm.creditManager.name} to spend ${symbol} (${token}), tx: ${hash}`
-        );
-      }
-    } catch (e) {
-      this.#logger?.error(
-        `failed to allowed credit manager ${cm.creditManager.name} to spend ${symbol} (${token}): ${e}`
-      );
-    }
-  }
-  async #mintDegenNft(degenNFT, to, amount) {
-    if (amount <= 0) {
-      return;
-    }
-    let minter;
-    try {
-      minter = await this.#anvil.readContract({
-        address: degenNFT,
-        abi: import_abi.iDegenNftv2Abi,
-        functionName: "minter"
-      });
-    } catch (e) {
-      this.#logger?.error(`failed to get minter of degenNFT ${degenNFT}: ${e}`);
-      return;
-    }
-    try {
-      await this.#anvil.impersonateAccount({ address: minter });
-      await this.#anvil.setBalance({
-        address: minter,
-        value: (0, import_viem.parseEther)("100")
-      });
-      const hash = await this.#anvil.writeContract({
-        account: minter,
-        address: degenNFT,
-        abi: import_abi.iDegenNftv2Abi,
-        functionName: "mint",
-        args: [to, BigInt(amount)],
-        chain: this.#anvil.chain
-      });
-      const receipt = await this.#anvil.waitForTransactionReceipt({
-        hash
-      });
-      if (receipt.status === "reverted") {
-        this.#logger?.error(
-          `failed to mint ${amount} degenNFT ${degenNFT} to borrower ${to}, tx reverted: ${hash}`
-        );
-      }
-      this.#logger?.debug(
-        `minted ${amount} degenNFT ${degenNFT} to borrower ${to}, tx: ${hash}`
-      );
-    } catch (e) {
-      this.#logger?.error(
-        `failed to mint ${amount} degenNFT ${degenNFT} to borrower ${to}: ${e}`
-      );
-    } finally {
-      await this.#anvil.stopImpersonatingAccount({ address: minter });
-    }
-  }
-  async #getBorrower() {
-    if (!this.#borrower) {
-      this.#borrower = await this.#createAccount(this.borrowerKey);
-      this.#logger?.info(`created borrower ${this.#borrower.address}`);
-    }
-    return this.borrower;
-  }
-  async #getDepositor() {
-    if (!this.#depositor) {
-      this.#depositor = await this.#createAccount(this.depositorKey);
-      this.#logger?.info(`created depositor ${this.#depositor.address}`);
-    }
-    return this.depositor;
-  }
-  async #createAccount(privateKey) {
-    const acc = (0, import_accounts.privateKeyToAccount)(privateKey);
-    await this.#anvil.setBalance({
-      address: acc.address,
-      value: (0, import_viem.parseEther)("100")
-    });
-    return acc;
-  }
-  /**
-   * Claims tokens from faucet, uniformly distributes them to accounts
-   * @param targets
-   * @returns
-   */
-  async #directlyDistributeTokens(targets) {
-    const tokens = new import_sdk.AddressSet(
-      targets.flatMap((t) => t.input.directTransfer ?? [])
-    );
-    if (tokens.size === 0) {
-      return;
-    }
-    const distributorKey = (0, import_accounts.generatePrivateKey)();
-    const distributor = (0, import_accounts.privateKeyToAccount)(distributorKey);
-    await this.#anvil.setBalance({
-      address: distributor.address,
-      value: (0, import_viem.parseEther)("100")
-    });
-    await (0, import_claimFromFaucet.claimFromFaucet)({
-      sdk: this.sdk,
-      publicClient: this.#anvil,
-      wallet: this.#anvil,
-      faucet: this.faucet,
-      claimer: distributor,
-      role: "reward token distributor",
-      logger: this.#logger
-    });
-    const actualBalances = await this.#anvil.multicall({
-      contracts: tokens.map(
-        (token) => ({
-          address: token,
-          abi: import_viem.erc20Abi,
-          functionName: "balanceOf",
-          args: [distributor.address]
-        })
-      ),
-      allowFailure: false,
-      batchSize: 0
-    });
-    const tokensArr = tokens.asArray();
-    for (let i = 0; i < tokensArr.length; i++) {
-      const token = tokensArr[i];
-      const balance = actualBalances[i];
-      this.#logger?.debug(
-        `${this.labelAddress(token)} balance: ${this.sdk.tokensMeta.formatBN(token, balance)}`
-      );
-    }
-    for (const { account, input } of targets) {
-      if (!account) {
-        continue;
-      }
-      const directTransfer = new import_sdk.AddressSet(input.directTransfer);
-      for (let i = 0; i < tokensArr.length; i++) {
-        const token = tokensArr[i];
-        if (!directTransfer.has(token)) {
-          continue;
-        }
-        const balance = actualBalances[i] / BigInt(targets.length);
-        this.#logger?.debug(
-          `sending ${balance} ${token} to ${account.creditAccount}`
-        );
-        const hash = await this.#anvil.writeContract({
-          account: distributor,
-          address: token,
-          abi: import_viem.erc20Abi,
-          functionName: "transfer",
-          args: [account.creditAccount, balance],
-          chain: this.#anvil.chain
-        });
-        const receipt = await this.#anvil.waitForTransactionReceipt({
-          hash
-        });
-        if (receipt.status === "reverted") {
-          this.#logger?.error(
-            `failed to send ${token} to ${account.creditAccount}, tx ${hash} reverted`
-          );
-        } else {
-          this.#logger?.debug(
-            `sent ${token} to ${account.creditAccount}, tx: ${hash}`
-          );
-        }
-      }
-    }
-  }
-  #getCollateralQuota(cm, collateral, collateralAmount, debt, logger) {
-    const {
-      underlying,
-      creditManager: { liquidationThresholds }
-    } = cm;
-    const inUnderlying = collateral.toLowerCase() === underlying.toLowerCase();
-    if (inUnderlying) {
-      return [];
-    }
-    const collateralLT = BigInt(liquidationThresholds.mustGet(collateral));
-    const market = this.sdk.marketRegister.findByCreditManager(
-      cm.creditManager.address
-    );
-    const quotaInfo = market.pool.pqk.quotas.mustGet(collateral);
-    const availableQuota = quotaInfo.limit - quotaInfo.totalQuoted;
-    if (availableQuota <= 0n) {
-      throw new Error(
-        `quota exceeded for asset ${this.labelAddress(collateral)} in ${cm.name}`
-      );
-    }
-    const oracle = this.sdk.marketRegister.findByCreditManager(
-      cm.creditManager.address
-    ).priceOracle;
-    const amount = oracle.convert(collateral, underlying, collateralAmount);
-    const desiredQuota = this.#calcQuota(amount, debt, collateralLT);
-    logger?.debug(
-      {
-        desiredQuota: this.sdk.tokensMeta.formatBN(underlying, desiredQuota, {
-          symbol: true
-        }),
-        availableQuota: this.sdk.tokensMeta.formatBN(
-          underlying,
-          availableQuota,
-          { symbol: true }
-        ),
-        collateralAmount: this.sdk.tokensMeta.formatBN(
-          collateral,
-          collateralAmount,
-          { symbol: true }
-        ),
-        amount: this.sdk.tokensMeta.formatBN(underlying, amount, {
-          symbol: true
-        }),
-        debt: this.sdk.tokensMeta.formatBN(underlying, debt, { symbol: true }),
-        lt: Number(collateralLT)
-      },
-      "calculated quota"
-    );
-    return [
-      {
-        token: collateral,
-        balance: desiredQuota < availableQuota ? desiredQuota : availableQuota
-      }
-    ];
-  }
-  #calcQuota(amount, debt, lt) {
-    let quota = amount * lt / import_sdk.PERCENTAGE_FACTOR;
-    quota = debt < quota ? debt : quota;
-    quota = quota * (import_sdk.PERCENTAGE_FACTOR + 500n) / import_sdk.PERCENTAGE_FACTOR;
-    return quota / import_sdk.PERCENTAGE_FACTOR * import_sdk.PERCENTAGE_FACTOR;
-  }
-  /**
-   * Returns leverage in percentage factor format
-   * @param param0
-   * @returns
-   */
-  #getLeverage({ creditManager, target, leverage }) {
-    if (leverage) {
-      return BigInt(leverage) * import_sdk.PERCENTAGE_FACTOR;
-    }
-    const cm = this.sdk.marketRegister.findCreditManager(creditManager);
-    const lt = BigInt(cm.creditManager.liquidationThresholds.mustGet(target));
-    const d = this.#leverageDelta;
-    let result = import_sdk.PERCENTAGE_FACTOR * (1n + (lt - d) / (import_sdk.PERCENTAGE_FACTOR - lt));
-    result = result > import_sdk.PERCENTAGE_FACTOR * 10n ? import_sdk.PERCENTAGE_FACTOR * 10n : result;
-    result = BigInt(Math.floor(Number(result) / 1e3) * 1e3);
-    return result;
-  }
-  #humanizePreview(input, preview) {
-    return {
-      creditManager: this.sdk.labelAddress(input.creditManager),
-      target: this.sdk.labelAddress(input.target),
-      leverage: Number(preview.leverage),
-      slippage: preview.slippage,
-      collateral: this.sdk.tokensMeta.formatBN(preview.collateral, {
-        symbol: true
-      }),
-      minQuota: preview.minQuota.filter((q) => q.balance > 10n).map((q) => this.sdk.tokensMeta.formatBN(q, { symbol: true })),
-      averageQuota: preview.averageQuota.filter((q) => q.balance > 10n).map((q) => this.sdk.tokensMeta.formatBN(q, { symbol: true }))
-    };
-  }
-  get faucet() {
-    if (!this.#faucet) {
-      throw new Error("faucet not found");
-    }
-    return this.#faucet;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AccountOpener,
-  OpenTxRevertedError
-});
+//#endregion
+exports.AccountOpener = AccountOpener;
+exports.OpenTxRevertedError = OpenTxRevertedError;