@gearbox-protocol/sdk 14.12.0-next.4 → 14.12.0-next.41

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

@@ -1,40 +1,45 @@
 import { Prerequisite } from "./Prerequisite.js";
 class RWAOpenRequirementsPrerequisite extends Prerequisite {
-  #id;
-  #title;
   #detail;
-  constructor(props) {
+  #providedArgs;
+  constructor(detail, providedArgs) {
     super();
-    this.#id = props.id ?? `rwaOpenRequirements:${props.factory}:${props.token}`;
-    this.#title = props.title ?? "RWA account requirements fulfilled";
-    this.#detail = props.requirements;
-  }
-  get id() {
-    return this.#id;
-  }
-  get kind() {
-    return "rwaOpenRequirements";
-  }
-  get title() {
-    return this.#title;
-  }
-  get detail() {
-    return this.#detail;
-  }
-  /** Pre-resolved: no on-chain reads to contribute. */
-  calls() {
-    return [];
-  }
-  resolve() {
-    return this.satisfiedResult(this.#satisfied(), this.#detail);
-  }
-  /**
-   * Satisfied when the borrower has nothing left to do: no tokens pending
-   * issuer-side registration and no messages left to sign.
-   */
-  #satisfied() {
-    const { securitizeTokensToRegister, requiredSignatures } = this.#detail;
-    return securitizeTokensToRegister.length === 0 && requiredSignatures.length === 0;
+    this.#detail = { ...detail };
+    this.#providedArgs = providedArgs;
+  }
+  async check(ctx) {
+    const requirements = await ctx.sdk.accounts.getOpenAccountRequirements(
+      ctx.wallet,
+      this.#detail.creditManager,
+      { tokenOutAddress: this.#detail.token }
+    );
+    if (!requirements) {
+      return {
+        kind: "rwaOpenRequirements",
+        detail: this.#detail,
+        satisfied: true
+      };
+    }
+    const { rwaFactory } = ctx.sdk.marketRegister.findByCreditManager(
+      this.#detail.creditManager
+    );
+    if (!rwaFactory) {
+      throw new Error(
+        `no RWA factory found for credit manager ${this.#detail.creditManager}`
+      );
+    }
+    const missing = rwaFactory.getMissingRequirements(
+      requirements,
+      this.#providedArgs
+    );
+    return {
+      kind: "rwaOpenRequirements",
+      detail: { ...this.#detail, requirements, missing },
+      satisfied: !missing && requirements.securitizeTokensToRegister.length === 0
+    };
+  }
+  errorResult(error) {
+    return { kind: "rwaOpenRequirements", detail: this.#detail, error };
   }
 }
 export {

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

@@ -0,0 +1,72 @@
+import { isAddressEqual } from "viem";
+import {
+  AP_WETH_TOKEN,
+  AssetsMap,
+  NATIVE_ADDRESS,
+  NO_VERSION
+} from "../../sdk/index.js";
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+import { allowanceAndBalance } from "./helpers.js";
+async function buildCollateralPrerequisites(spenderOptions, multicall, ctx) {
+  const { sdk, wallet, value = 0n } = 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 && value === 0n) {
+    return [];
+  }
+  const prereqs = [];
+  if (value > 0n) {
+    prereqs.push(
+      new BalancePrerequisite({
+        token: NATIVE_ADDRESS,
+        owner: wallet,
+        required: value
+      })
+    );
+  }
+  if (required.size === 0) {
+    return prereqs;
+  }
+  const spender = await sdk.accounts.getApprovalAddress(spenderOptions);
+  const weth = sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION);
+  for (const [token, amount] of required.entries()) {
+    if (value > 0n && isAddressEqual(token, weth)) {
+      prereqs.push(
+        new AllowancePrerequisite({
+          token,
+          owner: wallet,
+          spender,
+          required: amount
+        })
+      );
+      if (amount > value) {
+        prereqs.push(
+          new BalancePrerequisite({
+            token,
+            owner: wallet,
+            required: amount - value
+          })
+        );
+      }
+      continue;
+    }
+    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,62 @@
+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,
+    value: input.value ?? 0n
+  };
+  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,8 +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 "./RWAOpenRequirementsPrerequisite.js";
-export * from "./runPrerequisites.js";
 export * from "./types.js";

package/dist/esm/preview/preview/CreditAccountState.js

@@ -0,0 +1,133 @@
+import { zeroAddress } from "viem";
+import {
+  AssetsMap,
+  MIN_INT96
+} from "../../sdk/index.js";
+class CreditAccountState {
+  creditAccount;
+  creditManager;
+  /**
+   * Credit manager underlying
+   */
+  underlying;
+  /**
+   * Per-token balances
+   */
+  balances;
+  /**
+   * Per-token quotas
+   */
+  quotas;
+  /**
+   * Debt principal
+   */
+  debt;
+  /**
+   * Total debt: principal + accrued interest + accrued fees.
+   * `decreaseDebt` amounts operate on total debt (interest and fees are
+   * repaid before principal), so principal alone is not enough to resolve
+   * either the underlying balance decrement or the final principal.
+   */
+  totalDebt;
+  constructor(props) {
+    this.creditAccount = props.creditAccount;
+    this.creditManager = props.creditManager;
+    this.underlying = props.underlying;
+    this.balances = props.balances ?? new AssetsMap();
+    this.quotas = props.quotas ?? new AssetsMap();
+    this.debt = props.debt ?? 0n;
+    this.totalDebt = props.totalDebt ?? 0n;
+  }
+  /**
+   * The account-opening seed: everything zero/empty. The account doesn't
+   * exist yet at preview time, so `creditAccount` is the zero address;
+   * opening previews take identity from the parsed operation instead.
+   */
+  static beforeOpen(creditManager, underlying) {
+    return new CreditAccountState({
+      creditAccount: zeroAddress,
+      creditManager,
+      underlying
+    });
+  }
+  /**
+   * Pre-state of an existing account from its on-chain data, with dust
+   * balances and quotas (≤ 1 wei) filtered out.
+   */
+  static fromCreditAccountData(ca) {
+    const balances = new AssetsMap();
+    const quotas = new AssetsMap();
+    for (const t of ca.tokens) {
+      if (t.balance > 1n) {
+        balances.upsert(t.token, t.balance);
+      }
+      if (t.quota > 1n) {
+        quotas.upsert(t.token, t.quota);
+      }
+    }
+    return new CreditAccountState({
+      creditAccount: ca.creditAccount,
+      creditManager: ca.creditManager,
+      underlying: ca.underlying,
+      balances,
+      quotas,
+      debt: ca.debt,
+      totalDebt: ca.debt + ca.accruedInterest + ca.accruedFees
+    });
+  }
+  clone() {
+    return new CreditAccountState({
+      creditAccount: this.creditAccount,
+      creditManager: this.creditManager,
+      underlying: this.underlying,
+      balances: this.balances.clone(),
+      quotas: this.quotas.clone(),
+      debt: this.debt,
+      totalDebt: this.totalDebt
+    });
+  }
+  /**
+   * Borrows `amount` of underlying: debt, total debt and the underlying
+   * balance all increase by it.
+   */
+  increaseDebt(amount) {
+    this.debt += amount;
+    this.totalDebt += amount;
+    this.balances.inc(this.underlying, amount);
+  }
+  /**
+   * Repays up to `amount` of underlying against the debt, clamped to the
+   * total debt (the facade never repays more than is owed). Interest and
+   * fees are repaid before principal (CreditLogic.calcDecrease), so
+   * principal only decreases once total debt drops below it. The underlying
+   * balance decreases by the repaid amount.
+   *
+   * @returns The actually repaid (post-clamp) amount.
+   */
+  repay(amount) {
+    const repaid = amount > this.totalDebt ? this.totalDebt : amount;
+    this.balances.dec(this.underlying, repaid);
+    this.totalDebt -= repaid;
+    if (this.debt > this.totalDebt) {
+      this.debt = this.totalDebt;
+    }
+    return repaid;
+  }
+  /**
+   * Applies a relative `updateQuota` change to the token's quota:
+   * `MIN_INT96` is the facade "disable quota" sentinel and zeroes it, other
+   * changes are added with the result clamped at zero (quotas cannot go
+   * negative on-chain).
+   */
+  updateQuota(token, change) {
+    if (change === MIN_INT96) {
+      this.quotas.upsert(token, 0n);
+      return;
+    }
+    const next = this.quotas.getOrZero(token) + change;
+    this.quotas.upsert(token, next > 0n ? next : 0n);
+  }
+}
+export {
+  CreditAccountState
+};

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/buildDelayedPreview.js

@@ -0,0 +1,130 @@
+import { isAddressEqual } from "viem";
+import { BigIntMath } from "../../common-utils/index.js";
+import { AssetsMap } from "../../sdk/index.js";
+import {
+  ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST
+} from "./types.js";
+function buildDelayedPreview(afterInstant, before, detected, convert, receivedToken) {
+  const { request, intent } = detected;
+  const post = afterInstant.clone();
+  const converter = makeSafeConverter(convert);
+  const claimed = applyClaim(post, request);
+  const collateralWithdrawn = new AssetsMap();
+  switch (intent?.type) {
+    case "CLOSE_ACCOUNT":
+      return buildClosePreview(post, converter, receivedToken);
+    case "DECREASE_LEVERAGE":
+      repayFromClaim(post, request.claimToken, converter.convert, claimed);
+      break;
+    case "WITHDRAW_COLLATERAL": {
+      const withdrawn = BigIntMath.min(
+        intent.withdrawAmount,
+        post.balances.getOrZero(intent.withdrawToken)
+      );
+      if (withdrawn > 0n) {
+        post.balances.dec(intent.withdrawToken, withdrawn);
+        collateralWithdrawn.upsert(intent.withdrawToken, withdrawn);
+      }
+      const claimSpentOnWithdrawal = isAddressEqual(
+        intent.withdrawToken,
+        request.claimToken
+      ) ? withdrawn : 0n;
+      repayFromClaim(
+        post,
+        request.claimToken,
+        converter.convert,
+        BigIntMath.max(claimed - claimSpentOnWithdrawal, 0n)
+      );
+      break;
+    }
+    default:
+      break;
+  }
+  return buildAdjustPreview(post, before, collateralWithdrawn, converter);
+}
+function makeSafeConverter(convert) {
+  let error;
+  return {
+    convert: (token, to, amount) => {
+      try {
+        return convert(token, to, amount);
+      } catch {
+        error ??= {
+          code: ERROR_UNPRICEABLE_TOKEN,
+          message: `cannot price token ${token}`
+        };
+        return 0n;
+      }
+    },
+    get error() {
+      return error;
+    }
+  };
+}
+function applyClaim(post, request) {
+  const claimed = post.balances.getOrZero(request.phantomToken);
+  post.balances.upsert(request.phantomToken, 0n);
+  post.quotas.upsert(request.phantomToken, 0n);
+  post.balances.inc(request.claimToken, claimed);
+  return claimed;
+}
+function repayFromClaim(post, claimToken, convert, amount) {
+  const spent = BigIntMath.min(amount, post.balances.getOrZero(claimToken));
+  if (spent <= 0n) {
+    return;
+  }
+  const received = convert(claimToken, post.underlying, spent);
+  post.balances.dec(claimToken, spent);
+  post.balances.inc(post.underlying, received);
+  post.repay(received);
+}
+function totalValueInUnderlying(post, convert, dust) {
+  return post.balances.sum(
+    (token, balance) => balance > dust ? convert(token, post.underlying, balance) : 0n
+  );
+}
+function buildClosePreview(post, converter, receivedToken) {
+  const totalValue = totalValueInUnderlying(post, converter.convert, 0n);
+  return {
+    operation: "CloseCreditAccount",
+    permanent: false,
+    creditManager: post.creditManager,
+    creditAccount: post.creditAccount,
+    // Oracle estimate computed in the underlying; RWA underlyings convert
+    // 1:1 with their vault asset, so the amount holds for `receivedToken`
+    receivedAmount: {
+      token: receivedToken,
+      balance: BigIntMath.max(totalValue - post.totalDebt, 0n)
+    },
+    error: converter.error
+  };
+}
+function buildAdjustPreview(post, before, collateralWithdrawn, converter) {
+  const totalValue = totalValueInUnderlying(
+    post,
+    converter.convert,
+    PREVIEW_DUST
+  );
+  return {
+    operation: "AdjustCreditAccount",
+    creditManager: post.creditManager,
+    creditAccount: post.creditAccount,
+    // the resume flow adds nothing from the wallet
+    collateralAdded: [],
+    collateralWithdrawn: collateralWithdrawn.toAssets(),
+    totalValue,
+    debt: post.debt,
+    // relative to the pre-transaction state: where the account will end up
+    // compared to now, once the withdrawal is claimed and the intent resumed
+    debtChange: post.debt - before.debt,
+    quotas: post.quotas.toAssets(0n),
+    quotasChange: post.quotas.difference(before.quotas).toAssets(),
+    assets: post.balances.toAssets(PREVIEW_DUST),
+    assetsChange: post.balances.difference(before.balances).toAssets(PREVIEW_DUST),
+    error: converter.error
+  };
+}
+export {
+  buildDelayedPreview
+};