@gearbox-protocol/deploy-tools 6.9.2 → 6.9.3

package/dist/index.mjs

@@ -197366,22 +197366,17 @@ function discoverRwaCreditManagers(sdk, logger) {
         );
         continue;
       }
-      const dsToken = matched[0];
-      const dsTokenMeta = sdk.tokensMeta.mustGet(dsToken);
+      const dsToken = sdk.tokensMeta.mustGet(matched[0]);
       const assetMeta = sdk.tokensMeta.mustGet(underlyingMeta.asset);
       result.push({
         liquidity,
         pool: market.pool.pool.address,
-        label: `${cm.creditManager.name} \u2014 ${dsTokenMeta.symbol} ${liquidity}`,
+        label: `${cm.creditManager.name} \u2014 ${dsToken.symbol} ${liquidity}`,
         creditManager: cm.creditManager.address,
-        dsToken,
         factory: factory.address,
-        underlying: market.underlying,
-        underlyingDecimals: underlyingMeta.decimals,
-        asset: underlyingMeta.asset,
-        assetDecimals: assetMeta.decimals,
-        dsTokenDecimals: dsTokenMeta.decimals,
-        dsTokenSymbol: dsTokenMeta.symbol
+        dsToken,
+        underlying: sdk.tokensMeta.mustGet(market.underlying),
+        asset: assetMeta
       });
     }
   }
@@ -197539,6 +197534,21 @@ var LEVERAGE_ONE = 10n ** BigInt(LEVERAGE_PRECISION);
 function childLogger2(logger, context) {
   return logger?.child?.(context) ?? logger;
 }
+function calcQuota(amount, debt, lt) {
+  let quota = amount * lt / PERCENTAGE_FACTOR;
+  quota = debt < quota ? debt : quota;
+  quota = quota * (PERCENTAGE_FACTOR + 500n) / PERCENTAGE_FACTOR;
+  return quota / PERCENTAGE_FACTOR * PERCENTAGE_FACTOR;
+}
+function getDsTokenQuota(market, cm, dsToken, dsTokenAmount, debt) {
+  const lt = BigInt(cm.creditManager.liquidationThresholds.mustGet(dsToken));
+  const amountInUnderlying = market.priceOracle.convert(
+    dsToken,
+    cm.underlying,
+    dsTokenAmount
+  );
+  return calcQuota(amountInUnderlying, debt, lt);
+}
 async function runSecuritizeBorrowingFlow(props) {
   const {
     sdk,
@@ -197560,29 +197570,30 @@ async function runSecuritizeBorrowingFlow(props) {
   const investor = wallet.account.address;
   logger?.info(`created investor wallet ${investor}`);
   const market = sdk.marketRegister.findByPool(entry.pool);
+  const cm = sdk.marketRegister.findCreditManager(entry.creditManager);
   const dsAmount = market.priceOracle.convertFromUSD(
-    entry.dsToken,
+    entry.dsToken.addr,
     BigInt(usdAmount) * 10n ** 8n
   );
   await claimDSToken({
     anvil,
     claimer: investor,
     adminPrivateKey,
-    token: entry.dsToken,
+    token: entry.dsToken.addr,
     usdAmount,
     marketConfigurators,
     rwaFactories,
     logger
   });
   logger?.info(
-    `claimed ${dsAmount} ${entry.dsTokenSymbol} (${usdAmount} USD) for ${investor}`
+    `claimed ${dsAmount} ${entry.dsToken.symbol} (${usdAmount} USD) for ${investor}`
   );
   const approvalTarget = await sdk.accounts.getApprovalAddress({
     creditManager: entry.creditManager,
     borrower: investor
   });
   let hash4 = await wallet.writeContract({
-    address: entry.dsToken,
+    address: entry.dsToken.addr,
     abi: erc20Abi,
     functionName: "approve",
     args: [approvalTarget, MAX_UINT256],
@@ -197593,12 +197604,12 @@ async function runSecuritizeBorrowingFlow(props) {
     pollingInterval: 100
   });
   logger?.info(
-    `approved ${approvalTarget} for ${entry.dsTokenSymbol}: ${hash4}`
+    `approved ${approvalTarget} for ${entry.dsToken.symbol}: ${hash4}`
   );
   const requirements = await sdk.accounts.getOpenAccountRequirements(
     investor,
     entry.creditManager,
-    { tokenOutAddress: entry.dsToken }
+    { tokenOutAddress: entry.dsToken.addr }
   );
   if (!requirements) {
     throw new Error(
@@ -197613,7 +197624,7 @@ async function runSecuritizeBorrowingFlow(props) {
     requirements.requiredSignatures
   );
   logger?.info(`signed ${signaturesToCache.length} register-vault message(s)`);
-  const debtBn = parseUnits(debt, entry.underlyingDecimals);
+  const debtBn = parseUnits(debt, entry.underlying.decimals);
   const unwrapCalls = await sdk.accounts.getRWAUnwrapCalls(
     debtBn,
     entry.creditManager
@@ -197622,21 +197633,31 @@ async function runSecuritizeBorrowingFlow(props) {
     throw new Error(`getRWAUnwrapCalls returned undefined for ${entry.label}`);
   }
   logger?.info(`built ${unwrapCalls.length} unwrap call(s)`);
+  const quota = getDsTokenQuota(
+    market,
+    cm,
+    entry.dsToken.addr,
+    dsAmount,
+    debtBn
+  );
+  logger?.debug(
+    `computed dsToken quota: ${sdk.tokensMeta.formatBN(entry.underlying.addr, quota, { symbol: true })}`
+  );
   const { tx } = await sdk.accounts.openCA({
     creditManager: entry.creditManager,
-    collateral: [{ token: entry.dsToken, balance: dsAmount }],
+    collateral: [{ token: entry.dsToken.addr, balance: dsAmount }],
     debt: debtBn,
     calls: unwrapCalls,
-    withdrawToken: entry.asset,
-    averageQuota: [{ token: entry.dsToken, balance: debtBn + debtBn / 10n }],
-    minQuota: [{ token: entry.dsToken, balance: debtBn + debtBn / 10n }],
+    withdrawToken: entry.asset.addr,
+    averageQuota: [{ token: entry.dsToken.addr, balance: quota }],
+    minQuota: [{ token: entry.dsToken.addr, balance: quota }],
     to: investor,
     ethAmount: 0n,
     permits: {},
     referralCode: 0n,
     rwaOptions: {
       type: RWA_FACTORY_SECURITIZE,
-      tokensToRegister: [entry.dsToken],
+      tokensToRegister: [entry.dsToken.addr],
       signaturesToCache
     }
   });
@@ -197663,8 +197684,16 @@ async function runSecuritizeBorrowingFlow(props) {
   }
   const creditAccount = logs[0].args.creditAccount;
   logger?.info(
-    `borrowing flow ok: credit account ${creditAccount} opened for ${investor} with ${sdk.tokensMeta.formatBN(entry.dsToken, dsAmount, { symbol: true })} collateral and ${sdk.tokensMeta.formatBN(entry.underlying, debtBn, { symbol: true })} debt, tx ${hash4}`
+    `borrowing flow ok: credit account ${creditAccount} opened for ${investor} with ${sdk.tokensMeta.formatBN(entry.dsToken.addr, dsAmount, { symbol: true })} collateral and ${sdk.tokensMeta.formatBN(entry.underlying.addr, debtBn, { symbol: true })} debt, tx ${hash4}`
   );
+  const ca = await sdk.accounts.getCreditAccountData(creditAccount);
+  for (const token of ca?.tokens ?? []) {
+    if (token.balance > 1n || token.quota > 1n) {
+      logger?.warn(
+        `${entry.label}: credit account ${creditAccount} has ${sdk.tokensMeta.formatBN(token.token, token.balance, { symbol: true })} collateral with ${sdk.tokensMeta.formatBN(entry.underlying.addr, token.quota, { symbol: true })} quota`
+      );
+    }
+  }
   return { txHash: hash4, creditAccount };
 }
 async function runSecuritizeLeverageFlow(props) {
@@ -197682,19 +197711,19 @@ async function runSecuritizeLeverageFlow(props) {
     anvil,
     claimer: investor,
     adminPrivateKey,
-    token: entry.dsToken,
+    token: entry.dsToken.addr,
     logger
   });
-  logger?.info(`registered investor ${investor} for ${entry.dsTokenSymbol}`);
+  logger?.info(`registered investor ${investor} for ${entry.dsToken.symbol}`);
   const asset = entry.asset;
-  const debtBn = parseUnits(debt, entry.underlyingDecimals);
+  const debtBn = parseUnits(debt, entry.underlying.decimals);
   const leverageBn = parseUnits(leverage, LEVERAGE_PRECISION);
   if (leverageBn <= LEVERAGE_ONE) {
     throw new Error(`leverage must be > 1, got ${leverage}`);
   }
   const assetAmount = debtBn * LEVERAGE_ONE / (leverageBn - LEVERAGE_ONE);
   await anvil.deal({
-    erc20: asset,
+    erc20: asset.addr,
     account: investor,
     amount: assetAmount
   });
@@ -197706,7 +197735,7 @@ async function runSecuritizeLeverageFlow(props) {
     borrower: investor
   });
   let hash4 = await wallet.writeContract({
-    address: asset,
+    address: asset.addr,
     abi: erc20Abi,
     functionName: "approve",
     args: [approvalTarget, MAX_UINT256],
@@ -197716,11 +197745,11 @@ async function runSecuritizeLeverageFlow(props) {
     hash: hash4,
     pollingInterval: 100
   });
-  logger?.info(`approved ${approvalTarget} for asset: ${hash4}`);
+  logger?.info(`approved ${approvalTarget} for ${asset.symbol}: ${hash4}`);
   const requirements = await sdk.accounts.getOpenAccountRequirements(
     investor,
     entry.creditManager,
-    { tokenOutAddress: entry.dsToken }
+    { tokenOutAddress: entry.dsToken.addr }
   );
   if (!requirements) {
     throw new Error(
@@ -197745,28 +197774,46 @@ async function runSecuritizeLeverageFlow(props) {
   logger?.info(`built ${unwrapCalls.length} unwrap call(s)`);
   const strategy = await sdk.routerFor(cm).findOpenStrategyPath({
     creditManager: cm.creditManager,
-    expectedBalances: [{ token: asset, balance: assetAmount + debtBn }],
-    leftoverBalances: [{ token: asset, balance: 1n }],
+    expectedBalances: [{ token: asset.addr, balance: assetAmount + debtBn }],
+    leftoverBalances: [{ token: asset.addr, balance: 1n }],
     slippage: 50,
-    target: entry.dsToken
+    target: entry.dsToken.addr
   });
   logger?.info(
-    `router strategy: ${strategy.calls.length} call(s) to reach ${entry.dsTokenSymbol}`
+    `router strategy: ${strategy.calls.length} call(s) to reach ${entry.dsToken.symbol}`
+  );
+  const market = sdk.marketRegister.findByCreditManager(entry.creditManager);
+  const averageQuotaBn = getDsTokenQuota(
+    market,
+    cm,
+    entry.dsToken.addr,
+    strategy.amount,
+    debtBn
+  );
+  const minQuotaBn = getDsTokenQuota(
+    market,
+    cm,
+    entry.dsToken.addr,
+    strategy.minAmount,
+    debtBn
+  );
+  logger?.debug(
+    `computed dsToken quota: average=${sdk.tokensMeta.formatBN(entry.underlying.addr, averageQuotaBn, { symbol: true })}, min=${sdk.tokensMeta.formatBN(entry.underlying.addr, minQuotaBn, { symbol: true })}`
   );
   const { tx } = await sdk.accounts.openCA({
     creditManager: entry.creditManager,
-    collateral: [{ token: asset, balance: assetAmount }],
+    collateral: [{ token: asset.addr, balance: assetAmount }],
     debt: debtBn,
     calls: [...unwrapCalls, ...strategy.calls],
-    averageQuota: [{ token: entry.dsToken, balance: debtBn + debtBn / 10n }],
-    minQuota: [{ token: entry.dsToken, balance: debtBn + debtBn / 10n }],
+    averageQuota: [{ token: entry.dsToken.addr, balance: averageQuotaBn }],
+    minQuota: [{ token: entry.dsToken.addr, balance: minQuotaBn }],
     to: investor,
     ethAmount: 0n,
     permits: {},
     referralCode: 0n,
     rwaOptions: {
       type: RWA_FACTORY_SECURITIZE,
-      tokensToRegister: [entry.dsToken],
+      tokensToRegister: [entry.dsToken.addr],
       signaturesToCache
     }
   });
@@ -197793,8 +197840,16 @@ async function runSecuritizeLeverageFlow(props) {
   }
   const creditAccount = logs[0].args.creditAccount;
   logger?.info(
-    `leverage flow ok: credit account ${creditAccount} opened for ${investor} with ${sdk.tokensMeta.formatBN(asset, assetAmount, { symbol: true })} collateral and ${sdk.tokensMeta.formatBN(entry.underlying, debtBn, { symbol: true })} debt, tx ${hash4}`
+    `leverage flow ok: credit account ${creditAccount} opened for ${investor} with ${sdk.tokensMeta.formatBN(asset.addr, assetAmount, { symbol: true })} collateral and ${sdk.tokensMeta.formatBN(entry.underlying.addr, debtBn, { symbol: true })} debt, tx ${hash4}`
   );
+  const ca = await sdk.accounts.getCreditAccountData(creditAccount);
+  for (const token of ca?.tokens ?? []) {
+    if (token.balance > 1n || token.quota > 1n) {
+      logger?.warn(
+        `${entry.label}: credit account ${creditAccount} has ${sdk.tokensMeta.formatBN(token.token, token.balance, { symbol: true })} collateral with ${sdk.tokensMeta.formatBN(entry.underlying.addr, token.quota, { symbol: true })} quota`
+      );
+    }
+  }
   return { txHash: hash4, creditAccount };
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gearbox-protocol/deploy-tools",
   "description": "Gearbox deploy tools",
-  "version": "6.9.2",
+  "version": "6.9.3",
   "homepage": "https://gearbox.fi",
   "keywords": [
     "gearbox"