@gearbox-protocol/sdk 14.12.0-next.2 → 14.12.0-next.20

package/dist/esm/preview/prerequisites/buildCollateralPrerequisites.js

@@ -0,0 +1,33 @@
+import {
+  AssetsMap
+} from "../../sdk/index.js";
+import { allowanceAndBalance } from "./helpers.js";
+async function buildCollateralPrerequisites(spenderOptions, multicall, ctx) {
+  const { sdk, wallet } = ctx;
+  const required = new AssetsMap();
+  for (const op of multicall) {
+    if (op.operation !== "AddCollateral" || op.amount === 0n) {
+      continue;
+    }
+    required.inc(op.token, op.amount);
+  }
+  if (required.size === 0) {
+    return [];
+  }
+  const spender = await sdk.accounts.getApprovalAddress(spenderOptions);
+  const prereqs = [];
+  for (const [token, amount] of required.entries()) {
+    prereqs.push(
+      ...allowanceAndBalance({
+        token,
+        owner: wallet,
+        spender,
+        required: amount
+      })
+    );
+  }
+  return prereqs;
+}
+export {
+  buildCollateralPrerequisites
+};

package/dist/esm/preview/prerequisites/buildPartialLiquidationPrerequisites.js

@@ -0,0 +1,16 @@
+import { allowanceAndBalance } from "./helpers.js";
+function buildPartialLiquidationPrerequisites(tx, ctx) {
+  if (tx.repaidAmount === 0n) {
+    return [];
+  }
+  const suite = ctx.sdk.marketRegister.findByCreditManager(tx.creditManager);
+  return allowanceAndBalance({
+    token: suite.underlying,
+    owner: ctx.wallet,
+    spender: tx.creditManager,
+    required: tx.repaidAmount
+  });
+}
+export {
+  buildPartialLiquidationPrerequisites
+};

package/dist/esm/preview/prerequisites/buildPoolPrerequisites.js

@@ -0,0 +1,90 @@
+import { isAddressEqual } from "viem";
+import { NATIVE_ADDRESS } from "../../sdk/index.js";
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+import { allowanceAndBalance } from "./helpers.js";
+function buildPoolPrerequisites(tx, wallet) {
+  switch (tx.operation) {
+    // Deposit and Mint both pull the underlying from the caller into the pool;
+    // they only differ in which side (assets vs shares) the caller specifies.
+    // The exact underlying amount for Mint is resolved by the pool, so we can
+    // only require an allowance/balance against the known specified amount —
+    // here we approximate Mint by its shares amount (a lower bound on assets is
+    // not knowable from calldata alone).
+    case "Deposit":
+      if (tx.zapper) {
+        if (isAddressEqual(tx.tokenIn, NATIVE_ADDRESS)) {
+          return [
+            new BalancePrerequisite({
+              token: tx.tokenIn,
+              owner: wallet,
+              required: tx.assets
+            })
+          ];
+        }
+        return allowanceAndBalance({
+          token: tx.tokenIn,
+          owner: wallet,
+          spender: tx.zapper,
+          required: tx.assets
+        });
+      }
+      return allowanceAndBalance({
+        token: tx.underlying,
+        owner: wallet,
+        spender: tx.pool,
+        required: tx.assets
+      });
+    case "Mint":
+      return allowanceAndBalance({
+        token: tx.underlying,
+        owner: wallet,
+        spender: tx.pool,
+        required: tx.shares
+      });
+    // Redeem and Withdraw both burn LP shares from `owner`; they only differ in
+    // which side (shares vs assets) the caller specifies.
+    case "Redeem":
+      if (tx.zapper) {
+        return [
+          new BalancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            required: tx.shares
+          }),
+          new AllowancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            spender: tx.zapper,
+            required: tx.shares
+          })
+        ];
+      }
+      return lpSharePrerequisites(tx.pool, tx.owner, tx.shares, wallet);
+    case "Withdraw":
+      return lpSharePrerequisites(tx.pool, tx.owner, tx.assets, wallet);
+  }
+}
+function lpSharePrerequisites(pool, owner, required, wallet) {
+  const prereqs = [
+    new BalancePrerequisite({
+      token: pool,
+      owner,
+      required
+    })
+  ];
+  if (!isAddressEqual(owner, wallet)) {
+    prereqs.push(
+      new AllowancePrerequisite({
+        token: pool,
+        owner,
+        spender: wallet,
+        required
+      })
+    );
+  }
+  return prereqs;
+}
+export {
+  buildPoolPrerequisites
+};

package/dist/esm/preview/prerequisites/buildRWAPrerequisites.js

@@ -0,0 +1,35 @@
+import { AddressSet } from "../../sdk/index.js";
+import { RWAOpenRequirementsPrerequisite } from "./RWAOpenRequirementsPrerequisite.js";
+function buildRWAPrerequisites(multicall, creditManager, providedArgs, ctx) {
+  const { rwaFactory } = ctx.sdk.marketRegister.findByCreditManager(creditManager);
+  if (!rwaFactory) {
+    return [];
+  }
+  const rwaTokens = new AddressSet(rwaFactory.getTokens());
+  const candidates = new AddressSet();
+  for (const op of multicall) {
+    if (op.operation === "AddCollateral" || op.operation === "UpdateQuota") {
+      candidates.add(op.token);
+    }
+  }
+  const prereqs = [];
+  for (const token of candidates) {
+    if (!rwaTokens.has(token)) {
+      continue;
+    }
+    prereqs.push(
+      new RWAOpenRequirementsPrerequisite(
+        {
+          token,
+          creditManager,
+          factory: rwaFactory.address
+        },
+        providedArgs
+      )
+    );
+  }
+  return prereqs;
+}
+export {
+  buildRWAPrerequisites
+};

package/dist/esm/preview/prerequisites/checkPrerequisites.js

@@ -0,0 +1,61 @@
+import { parseOperationCalldata } from "../parse/index.js";
+import { buildCollateralPrerequisites } from "./buildCollateralPrerequisites.js";
+import { buildPartialLiquidationPrerequisites } from "./buildPartialLiquidationPrerequisites.js";
+import { buildPoolPrerequisites } from "./buildPoolPrerequisites.js";
+import { buildRWAPrerequisites } from "./buildRWAPrerequisites.js";
+async function checkPrerequisites(input, options) {
+  const { sdk, sender: wallet } = input;
+  const tx = parseOperationCalldata(input);
+  const ctx = {
+    sdk,
+    wallet,
+    blockNumber: options?.blockNumber
+  };
+  const prereqs = await buildPrerequisites(tx, ctx);
+  return Promise.all(prereqs.map((p) => p.verify(ctx)));
+}
+async function buildPrerequisites(tx, ctx) {
+  const { wallet } = ctx;
+  switch (tx.operation) {
+    case "Deposit":
+    case "Mint":
+    case "Redeem":
+    case "Withdraw":
+      return buildPoolPrerequisites(tx, wallet);
+    case "MultiCall":
+    case "BotMulticall":
+    case "OpenCreditAccount":
+    case "CloseCreditAccount":
+    case "LiquidateCreditAccount":
+      return buildCollateralPrerequisites(
+        tx.operation === "OpenCreditAccount" ? { creditManager: tx.creditManager, borrower: wallet } : {
+          creditManager: tx.creditManager,
+          creditAccount: tx.creditAccount
+        },
+        tx.multicall,
+        ctx
+      );
+    case "RWAOpenCreditAccount":
+      return [
+        ...await buildCollateralPrerequisites(
+          { creditManager: tx.creditManager, borrower: wallet },
+          tx.multicall,
+          ctx
+        ),
+        ...buildRWAPrerequisites(tx.multicall, tx.creditManager, tx.args, ctx)
+      ];
+    case "RWAMulticall":
+      return buildCollateralPrerequisites(
+        { creditManager: tx.creditManager, creditAccount: tx.creditAccount },
+        tx.multicall,
+        ctx
+      );
+    case "PartiallyLiquidateCreditAccount":
+      return buildPartialLiquidationPrerequisites(tx, ctx);
+    default:
+      return [];
+  }
+}
+export {
+  checkPrerequisites
+};

package/dist/esm/preview/prerequisites/helpers.js

@@ -0,0 +1,14 @@
+import {
+  AllowancePrerequisite
+} from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+function allowanceAndBalance(props) {
+  const { token, owner, spender, required } = props;
+  return [
+    new AllowancePrerequisite({ token, owner, spender, required }),
+    new BalancePrerequisite({ token, owner, required })
+  ];
+}
+export {
+  allowanceAndBalance
+};

package/dist/esm/preview/prerequisites/index.js

@@ -1,7 +1,6 @@
 export * from "./AllowancePrerequisite.js";
 export * from "./BalancePrerequisite.js";
-export * from "./buildPrerequisites.js";
+export * from "./checkPrerequisites.js";
 export * from "./Prerequisite.js";
-export * from "./prepareAction.js";
-export * from "./runPrerequisites.js";
+export * from "./RWAOpenRequirementsPrerequisite.js";
 export * from "./types.js";

package/dist/esm/preview/preview/applyInnerOperations.js

@@ -0,0 +1,122 @@
+import {
+  AbstractAdapterContract,
+  ERC4626AdapterContract
+} from "../../plugins/adapters/index.js";
+import {
+  AssetsMap,
+  MAX_UINT256,
+  MIN_INT96
+} from "../../sdk/index.js";
+import { applyRWAWrapUnwrap } from "./applyRWAWrapUnwrap.js";
+function makeInnerOperationsState() {
+  return {
+    balances: new AssetsMap(),
+    debt: 0n,
+    totalDebt: 0n,
+    collateralAdded: new AssetsMap(),
+    collateralWithdrawn: new AssetsMap(),
+    quotaChanges: []
+  };
+}
+function applyInnerOperations(sdk, multicall, state) {
+  let inBracket = false;
+  let storeSeen = false;
+  for (const op of multicall) {
+    switch (op.operation) {
+      case "AddCollateral":
+        state.collateralAdded.inc(op.token, op.amount);
+        state.balances.inc(op.token, op.amount);
+        break;
+      case "WithdrawCollateral": {
+        const running = state.balances.getOrZero(op.token);
+        const amount = op.amount === MAX_UINT256 ? running > 0n ? running : 0n : op.amount;
+        state.balances.dec(op.token, amount);
+        state.collateralWithdrawn.inc(op.token, amount);
+        break;
+      }
+      case "IncreaseBorrowedAmount":
+        state.debt += op.amount;
+        state.totalDebt += op.amount;
+        state.balances.inc(op.token, op.amount);
+        break;
+      case "DecreaseBorrowedAmount": {
+        const repaid = op.amount > state.totalDebt ? state.totalDebt : op.amount;
+        state.balances.dec(op.token, repaid);
+        state.totalDebt -= repaid;
+        if (state.debt > state.totalDebt) {
+          state.debt = state.totalDebt;
+        }
+        break;
+      }
+      case "UpdateQuota":
+        state.quotaChanges.push({ token: op.token, balance: op.change });
+        break;
+      case "StoreExpectedBalances":
+        if (storeSeen) {
+          throw new Error(
+            "malformed multicall: duplicate storeExpectedBalances call"
+          );
+        }
+        storeSeen = true;
+        inBracket = true;
+        for (const { token, balance } of op.deltas) {
+          state.balances.inc(token, balance);
+        }
+        break;
+      case "CompareBalances":
+        if (!inBracket) {
+          throw new Error(
+            "malformed multicall: compareBalances without a preceding storeExpectedBalances"
+          );
+        }
+        inBracket = false;
+        break;
+      case "Execute": {
+        const adapter = sdk.getContract(op.adapter);
+        if (inBracket) {
+          if (!(adapter instanceof AbstractAdapterContract)) {
+            throw new Error(
+              `call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`
+            );
+          }
+          adapter.previewBalanceChanges(state.balances, op.calldata);
+        } else if (isRWAShare(sdk, adapter)) {
+          applyRWAWrapUnwrap(adapter, op.calldata, state.balances);
+        }
+        break;
+      }
+    }
+  }
+  if (inBracket) {
+    throw new Error(
+      "malformed multicall: storeExpectedBalances without a matching compareBalances"
+    );
+  }
+}
+function isRWAShare(sdk, adapter) {
+  if (adapter instanceof ERC4626AdapterContract) {
+    const meta = sdk.tokensMeta.get(adapter.share);
+    return !!meta && sdk.tokensMeta.isRWAUnderlying(meta);
+  }
+  return false;
+}
+function applyQuotaChanges(initialQuotas, changes) {
+  const final = initialQuotas.clone();
+  for (const { token, balance: change } of changes) {
+    if (change === MIN_INT96) {
+      final.upsert(token, 0n);
+    } else {
+      const next = final.getOrZero(token) + change;
+      final.upsert(token, next > 0n ? next : 0n);
+    }
+  }
+  return {
+    quotas: final.toAssets(0n),
+    quotasChange: final.difference(initialQuotas).toAssets()
+  };
+}
+export {
+  applyInnerOperations,
+  applyQuotaChanges,
+  makeInnerOperationsState
+};

package/dist/esm/preview/preview/applyRWAWrapUnwrap.js

@@ -0,0 +1,50 @@
+import { decodeFunctionData } from "viem";
+import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
+function resolveWrapUnwrap(adapter, calldata, balances) {
+  const decoded = decodeFunctionData({
+    abi: ierc4626AdapterAbi,
+    data: calldata
+  });
+  const { asset, share } = adapter;
+  switch (decoded.functionName) {
+    case "deposit":
+      return { tokenIn: asset, tokenOut: share, amountIn: decoded.args[0] };
+    case "depositDiff": {
+      const [leftoverAmount] = decoded.args;
+      const running = balances.getOrZero(asset);
+      return {
+        tokenIn: asset,
+        tokenOut: share,
+        amountIn: running > leftoverAmount ? running - leftoverAmount : 0n
+      };
+    }
+    case "redeem":
+      return { tokenIn: share, tokenOut: asset, amountIn: decoded.args[0] };
+    case "redeemDiff": {
+      const [leftoverAmount] = decoded.args;
+      const running = balances.getOrZero(share);
+      return {
+        tokenIn: share,
+        tokenOut: asset,
+        amountIn: running > leftoverAmount ? running - leftoverAmount : 0n
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function applyRWAWrapUnwrap(adapter, calldata, balances) {
+  const resolved = resolveWrapUnwrap(adapter, calldata, balances);
+  if (!resolved) {
+    return;
+  }
+  const { tokenIn, tokenOut, amountIn } = resolved;
+  if (amountIn === 0n) {
+    return;
+  }
+  balances.dec(tokenIn, amountIn);
+  balances.inc(tokenOut, amountIn);
+}
+export {
+  applyRWAWrapUnwrap
+};

package/dist/esm/preview/preview/detectCloseOrRepay.js

@@ -0,0 +1,26 @@
+import { isAddressEqual } from "viem";
+import { MAX_UINT256 } from "../../sdk/index.js";
+function isCloseOrRepay(multicall) {
+  const repaysFullDebt = multicall.some(
+    (op) => op.operation === "DecreaseBorrowedAmount" && op.amount === MAX_UINT256
+  );
+  const withdrawsEverything = multicall.some(
+    (op) => op.operation === "WithdrawCollateral" && op.amount === MAX_UINT256
+  );
+  return repaysFullDebt && withdrawsEverything;
+}
+function classifyCloseOrRepay(multicall, underlying) {
+  for (const op of multicall) {
+    if (op.operation === "AddCollateral") {
+      return "repay";
+    }
+    if (op.operation === "WithdrawCollateral" && !isAddressEqual(op.token, underlying)) {
+      return "repay";
+    }
+  }
+  return "close";
+}
+export {
+  classifyCloseOrRepay,
+  isCloseOrRepay
+};

package/dist/esm/preview/preview/errors.js

@@ -0,0 +1,27 @@
+class InvalidTransactionValueError extends Error {
+  /** Transaction `msg.value`. */
+  value;
+  /** Amount of wrapped native token added as collateral. */
+  wethCollateral;
+  constructor(value, wethCollateral) {
+    super(
+      `transaction value ${value} exceeds WETH collateral ${wethCollateral}`
+    );
+    this.name = "InvalidTransactionValueError";
+    this.value = value;
+    this.wethCollateral = wethCollateral;
+  }
+}
+class UnsupportedOperationError extends Error {
+  /** The parsed operation kind (the `operation` discriminant). */
+  operation;
+  constructor(operation) {
+    super(`operation "${operation}" is not supported by previewOperation`);
+    this.name = "UnsupportedOperationError";
+    this.operation = operation;
+  }
+}
+export {
+  InvalidTransactionValueError,
+  UnsupportedOperationError
+};

package/dist/esm/preview/preview/index.js

@@ -0,0 +1,7 @@
+export * from "./applyInnerOperations.js";
+export * from "./detectCloseOrRepay.js";
+export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewCloseOrRepayCreditAccount.js";
+export * from "./previewOperation.js";
+export * from "./types.js";

package/dist/esm/preview/preview/previewAdjustCreditAccount.js

@@ -0,0 +1,74 @@
+import {
+  AP_WETH_TOKEN,
+  AssetsMap,
+  NO_VERSION
+} from "../../sdk/index.js";
+import {
+  applyInnerOperations,
+  applyQuotaChanges,
+  makeInnerOperationsState
+} from "./applyInnerOperations.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+async function previewAdjustCreditAccount(input, operation, options) {
+  const { sdk, value = 0n } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  let ca = options?.creditAccount;
+  if (!ca) {
+    ca = await sdk.accounts.getCreditAccountData(
+      operation.creditAccount,
+      options?.blockNumber
+    );
+  }
+  if (!ca) {
+    throw new Error(`credit account ${operation.creditAccount} not found`);
+  }
+  const initialBalances = new AssetsMap();
+  const initialQuotas = new AssetsMap();
+  for (const t of ca.tokens) {
+    if (t.balance > 1n) {
+      initialBalances.upsert(t.token, t.balance);
+    }
+    if (t.quota > 1n) {
+      initialQuotas.upsert(t.token, t.quota);
+    }
+  }
+  const state = makeInnerOperationsState();
+  state.balances = initialBalances.clone();
+  state.debt = ca.debt;
+  state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+  applyInnerOperations(sdk, operation.multicall, state);
+  const collateralAdded = unwrapNativeCollateral(
+    state.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  const { quotas, quotasChange } = applyQuotaChanges(
+    initialQuotas,
+    state.quotaChanges
+  );
+  const assets = state.balances.toAssets(1n);
+  const assetsChange = state.balances.difference(initialBalances).toAssets(1n);
+  const totalValue = assets.reduce(
+    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
+    0n
+  );
+  return {
+    operation: "AdjustCreditAccount",
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    collateralWithdrawn: state.collateralWithdrawn.toAssets(),
+    totalValue,
+    debt: state.debt,
+    debtChange: state.debt - ca.debt,
+    quotas,
+    quotasChange,
+    assets,
+    assetsChange
+  };
+}
+export {
+  previewAdjustCreditAccount
+};

package/dist/esm/preview/preview/previewCloseOrRepayCreditAccount.js

@@ -0,0 +1,76 @@
+import {
+  AP_WETH_TOKEN,
+  NO_VERSION
+} from "../../sdk/index.js";
+import {
+  applyInnerOperations,
+  makeInnerOperationsState
+} from "./applyInnerOperations.js";
+import { classifyCloseOrRepay } from "./detectCloseOrRepay.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+async function previewCloseOrRepayCreditAccount(input, operation, permanent, options) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const kind = classifyCloseOrRepay(operation.multicall, market.underlying);
+  return kind === "close" ? previewCloseCreditAccount(input, operation, permanent, options) : previewRepayCreditAccount(input, operation, permanent, options);
+}
+async function previewCloseCreditAccount(input, operation, permanent, options) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const { state } = await replayMulticall(sdk, operation, options);
+  return {
+    operation: "CloseCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    receivedAmount: state.collateralWithdrawn.getOrZero(market.underlying)
+  };
+}
+async function previewRepayCreditAccount(input, operation, permanent, options) {
+  const { sdk, value = 0n } = input;
+  const { ca, state } = await replayMulticall(sdk, operation, options);
+  const collateralAdded = unwrapNativeCollateral(
+    state.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  const initialTotalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+  return {
+    operation: "RepayCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    debtRepaid: initialTotalDebt - state.totalDebt,
+    collateralWithdrawn: state.collateralWithdrawn.toAssets()
+  };
+}
+async function replayMulticall(sdk, operation, options) {
+  let ca = options?.creditAccount;
+  if (!ca) {
+    ca = await sdk.accounts.getCreditAccountData(
+      operation.creditAccount,
+      options?.blockNumber
+    );
+  }
+  if (!ca) {
+    throw new Error(`credit account ${operation.creditAccount} not found`);
+  }
+  const state = makeInnerOperationsState();
+  for (const t of ca.tokens) {
+    if (t.balance > 1n) {
+      state.balances.upsert(t.token, t.balance);
+    }
+  }
+  state.debt = ca.debt;
+  state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+  applyInnerOperations(sdk, operation.multicall, state);
+  return { ca, state };
+}
+export {
+  previewCloseOrRepayCreditAccount
+};