@gearbox-protocol/sdk 14.12.0-next.1 → 14.12.0-next.10

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

@@ -1,41 +1,59 @@
 import { erc20Abi } from "viem";
+import { iMulticall3Abi } from "../../abi/iMulticall3.js";
+import { hexEq, NATIVE_ADDRESS } from "../../sdk/index.js";
 import {
   Prerequisite,
   toPrerequisiteError
 } from "./Prerequisite.js";
 class BalancePrerequisite extends Prerequisite {
-  _id;
-  _title;
-  _detail;
+  #id;
+  #title;
+  #detail;
   constructor(props) {
     super();
-    this._id = props.id ?? `balance:${props.token}:${props.owner}`;
-    this._title = props.title ?? "Sufficient balance";
-    this._detail = {
+    this.#id = props.id ?? `balance:${props.token}:${props.owner}`;
+    this.#title = props.title ?? "Sufficient balance";
+    this.#detail = {
       token: props.token,
       owner: props.owner,
       required: props.required
     };
   }
   get id() {
-    return this._id;
+    return this.#id;
   }
   get kind() {
     return "balance";
   }
   get title() {
-    return this._title;
+    return this.#title;
   }
   get detail() {
-    return this._detail;
+    return this.#detail;
   }
-  calls() {
+  calls(ctx) {
+    if (hexEq(this.#detail.token, NATIVE_ADDRESS)) {
+      const multicall3 = ctx.sdk.client.chain.contracts?.multicall3?.address;
+      if (!multicall3) {
+        throw new Error(
+          "multicall3 is not configured for this chain, cannot read native balance"
+        );
+      }
+      return [
+        {
+          address: multicall3,
+          abi: iMulticall3Abi,
+          functionName: "getEthBalance",
+          args: [this.#detail.owner]
+        }
+      ];
+    }
     return [
       {
-        address: this._detail.token,
+        address: this.#detail.token,
         abi: erc20Abi,
         functionName: "balanceOf",
-        args: [this._detail.owner]
+        args: [this.#detail.owner]
       }
     ];
   }
@@ -45,8 +63,8 @@ class BalancePrerequisite extends Prerequisite {
       return this.errorResult(toPrerequisiteError(res?.error));
     }
     const actual = res.result;
-    return this.satisfiedResult(actual >= this._detail.required, {
-      ...this._detail,
+    return this.satisfiedResult(actual >= this.#detail.required, {
+      ...this.#detail,
       actual
     });
   }

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

@@ -0,0 +1,42 @@
+import { Prerequisite } from "./Prerequisite.js";
+class RWAOpenRequirementsPrerequisite extends Prerequisite {
+  #id;
+  #title;
+  #detail;
+  constructor(props) {
+    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;
+  }
+}
+export {
+  RWAOpenRequirementsPrerequisite
+};

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

@@ -1,8 +1,19 @@
 import { isAddressEqual } from "viem";
+import {
+  AddressSet,
+  AssetsMap,
+  NATIVE_ADDRESS
+} from "../../sdk/index.js";
+import {
+  parseOperationCalldata
+} from "../parse/parseOperationCalldata.js";
 import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
 import { BalancePrerequisite } from "./BalancePrerequisite.js";
-function buildPrerequisites(tx, ctx) {
-  const { wallet } = ctx;
+import { RWAOpenRequirementsPrerequisite } from "./RWAOpenRequirementsPrerequisite.js";
+async function buildPrerequisites(input) {
+  const { sdk, sender: wallet, blockNumber } = input;
+  const tx = parseOperationCalldata(input);
+  const ctx = { sdk, wallet, blockNumber };
   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.
@@ -11,6 +22,29 @@ function buildPrerequisites(tx, ctx) {
     // here we approximate Mint by its shares amount (a lower bound on assets is
     // not knowable from calldata alone).
     case "Deposit":
+      if (tx.zapper) {
+        const prereqs = [];
+        if (!isAddressEqual(tx.tokenIn, NATIVE_ADDRESS)) {
+          prereqs.push(
+            new AllowancePrerequisite({
+              token: tx.tokenIn,
+              owner: wallet,
+              spender: tx.zapper,
+              required: tx.assets,
+              title: "Token approved to zapper"
+            })
+          );
+        }
+        prereqs.push(
+          new BalancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            required: tx.assets,
+            title: "Sufficient token balance"
+          })
+        );
+        return prereqs;
+      }
       return [
         new AllowancePrerequisite({
           token: tx.underlying,
@@ -45,6 +79,23 @@ function buildPrerequisites(tx, ctx) {
     // 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,
+            title: "Sufficient share token balance"
+          }),
+          new AllowancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            spender: tx.zapper,
+            required: tx.shares,
+            title: "Share token approved to zapper"
+          })
+        ];
+      }
       const prereqs = [
         new BalancePrerequisite({
           token: tx.pool,
@@ -93,7 +144,37 @@ function buildPrerequisites(tx, ctx) {
     case "OpenCreditAccount":
     case "CloseCreditAccount":
     case "LiquidateCreditAccount":
-      return collateralPrerequisites(tx.multicall, tx.creditManager, wallet);
+      return collateralPrerequisites(
+        tx.operation === "OpenCreditAccount" ? { creditManager: tx.creditManager, borrower: wallet } : {
+          creditManager: tx.creditManager,
+          creditAccount: tx.creditAccount
+        },
+        tx.multicall,
+        ctx
+      );
+    // RWA-factory operations: same collateral checks as facade operations,
+    // plus (for opening) the factory's open-account requirements. The parsed
+    // operation carries template (empty) `tokensToRegister`/`signaturesToCache`;
+    // the prerequisite detail provides the real values.
+    case "SecuritizeOpenCreditAccount":
+      return [
+        ...await collateralPrerequisites(
+          { creditManager: tx.creditManager, borrower: wallet },
+          tx.multicall,
+          ctx
+        ),
+        ...await rwaOpenRequirementsPrerequisites(
+          tx.multicall,
+          tx.creditManager,
+          ctx
+        )
+      ];
+    case "SecuritizeMulticall":
+      return collateralPrerequisites(
+        { creditManager: tx.creditManager, creditAccount: tx.creditAccount },
+        tx.multicall,
+        ctx
+      );
     case "PartiallyLiquidateCreditAccount": {
       const underlying = underlyingOf(ctx.sdk, tx.creditManager);
       if (!underlying || tx.repaidAmount === 0n) {
@@ -119,28 +200,28 @@ function buildPrerequisites(tx, ctx) {
       return [];
   }
 }
-function collateralPrerequisites(multicall, creditManager, wallet) {
-  const required = /* @__PURE__ */ new Map();
+async function collateralPrerequisites(spenderOptions, multicall, ctx) {
+  const { sdk, wallet } = ctx;
+  const required = new AssetsMap();
   for (const op of multicall) {
     if (op.operation !== "AddCollateral" || op.amount === 0n) {
       continue;
     }
-    const key = op.token.toLowerCase();
-    const existing = required.get(key);
-    required.set(key, {
-      token: op.token,
-      amount: (existing?.amount ?? 0n) + op.amount
-    });
+    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.values()) {
+  for (const [token, amount] of required.entries()) {
     prereqs.push(
       new AllowancePrerequisite({
         token,
         owner: wallet,
-        spender: creditManager,
+        spender,
         required: amount,
-        title: "Collateral approved to credit manager"
+        title: "Collateral approved"
       }),
       new BalancePrerequisite({
         token,
@@ -152,6 +233,41 @@ function collateralPrerequisites(multicall, creditManager, wallet) {
   }
   return prereqs;
 }
+async function rwaOpenRequirementsPrerequisites(multicall, creditManager, ctx) {
+  const { sdk, wallet } = ctx;
+  const { rwaFactory } = 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;
+    }
+    const requirements = await sdk.accounts.getOpenAccountRequirements(
+      wallet,
+      creditManager,
+      { tokenOutAddress: token }
+    );
+    if (requirements) {
+      prereqs.push(
+        new RWAOpenRequirementsPrerequisite({
+          requirements,
+          token,
+          factory: rwaFactory.address
+        })
+      );
+    }
+  }
+  return prereqs;
+}
 function underlyingOf(sdk, creditManager) {
   const suite = sdk.marketRegister.creditManagers.find(
     (cm) => isAddressEqual(cm.creditManager.address, creditManager)

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

@@ -3,5 +3,6 @@ export * from "./BalancePrerequisite.js";
 export * from "./buildPrerequisites.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/applyInnerOperations.js

@@ -0,0 +1,110 @@
+import { AbstractAdapterContract } from "../../plugins/adapters/index.js";
+import {
+  AssetsMap,
+  MAX_UINT256,
+  MIN_INT96
+} from "../../sdk/index.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.get(op.token) ?? 0n;
+        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":
+        if (inBracket) {
+          const adapter = sdk.getContract(op.adapter);
+          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);
+        }
+        break;
+    }
+  }
+  if (inBracket) {
+    throw new Error(
+      "malformed multicall: storeExpectedBalances without a matching compareBalances"
+    );
+  }
+}
+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.get(token) ?? 0n) + change;
+      final.upsert(token, next > 0n ? next : 0n);
+    }
+  }
+  const quotas = final.entries().filter(([, balance]) => balance > 0n).map(([token, balance]) => ({ token, balance }));
+  const quotasChange = final.entries().map(([token, balance]) => ({
+    token,
+    balance: balance - (initialQuotas.get(token) ?? 0n)
+  })).filter(({ balance }) => balance !== 0n);
+  return { quotas, quotasChange };
+}
+export {
+  applyInnerOperations,
+  applyQuotaChanges,
+  makeInnerOperationsState
+};

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,5 @@
+export * from "./applyInnerOperations.js";
+export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewOperation.js";
+export * from "./types.js";

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

@@ -0,0 +1,79 @@
+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();
+  for (const [token, balance] of initialBalances.entries()) {
+    state.balances.upsert(token, balance);
+  }
+  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(true);
+  const assetsChange = state.balances.entries().map(([token, balance]) => ({
+    token,
+    balance: balance - (initialBalances.get(token) ?? 0n)
+  })).filter(({ balance }) => balance !== 0n);
+  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/previewOpenCreditAccount.js

@@ -0,0 +1,51 @@
+import {
+  AP_WETH_TOKEN,
+  NO_VERSION
+} from "../../sdk/index.js";
+import {
+  applyInnerOperations,
+  makeInnerOperationsState
+} from "./applyInnerOperations.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+function previewOpenCreditAccount(input, operation) {
+  const { sdk, value = 0n } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const state = makeInnerOperationsState();
+  applyInnerOperations(sdk, operation.multicall, state);
+  let collateral = state.collateralAdded.toAssets();
+  const collateralValue = collateral.reduce(
+    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
+    0n
+  );
+  collateral = unwrapNativeCollateral(
+    collateral,
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  const assets = state.balances.entries().filter(([, balance]) => balance > 1n).map(([token, balance]) => ({ token, balance }));
+  return {
+    operation: operation.operation,
+    creditManager: operation.creditManager,
+    target: inferTargetAsset(operation.multicall, state.balances),
+    collateral,
+    collateralValue,
+    debt: state.debt,
+    // On opening, initial quotas are zero, so the raw changes are the quotas.
+    quotas: state.quotaChanges,
+    assets
+  };
+}
+function inferTargetAsset(multicall, balances) {
+  for (const op of multicall) {
+    if (op.operation === "UpdateQuota" && op.change > 0n) {
+      const balance = balances.get(op.token);
+      return balance ? { token: op.token, balance } : void 0;
+    }
+  }
+  return void 0;
+}
+export {
+  previewOpenCreditAccount
+};

package/dist/esm/preview/preview/previewOperation.js

@@ -0,0 +1,21 @@
+import { isPoolOperation, parseOperationCalldata } from "../parse/index.js";
+import { UnsupportedOperationError } from "./errors.js";
+import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
+import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
+import { previewPoolOperation } from "./previewPoolOperation.js";
+async function previewOperation(input, options) {
+  const operation = parseOperationCalldata(input);
+  if (isPoolOperation(operation)) {
+    return previewPoolOperation(input, operation, options);
+  }
+  if (operation.operation === "OpenCreditAccount" || operation.operation === "SecuritizeOpenCreditAccount") {
+    return previewOpenCreditAccount(input, operation);
+  }
+  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "SecuritizeMulticall") {
+    return previewAdjustCreditAccount(input, operation, options);
+  }
+  throw new UnsupportedOperationError(operation.operation);
+}
+export {
+  previewOperation
+};

package/dist/esm/preview/preview/previewPoolOperation.js

@@ -0,0 +1,53 @@
+import {
+  simulatePoolOperation
+} from "../simulate/index.js";
+async function previewPoolOperation(input, operation, options) {
+  const { sdk, to, calldata } = input;
+  const { tokenIn, tokenOut } = operation;
+  const sim = await simulatePoolOperation(
+    { sdk, operation, to, calldata },
+    options
+  );
+  if (sim.status === "success") {
+    return {
+      operation: operation.operation,
+      pool: operation.pool,
+      tokenIn: { token: tokenIn, balance: sim.amountIn },
+      tokenOut: { token: tokenOut, balance: sim.amountOut }
+    };
+  }
+  const { error } = sim;
+  switch (operation.operation) {
+    case "Deposit":
+      return {
+        operation: "Deposit",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, balance: operation.assets },
+        tokenOut: { token: tokenOut, error }
+      };
+    case "Mint":
+      return {
+        operation: "Mint",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, error },
+        tokenOut: { token: tokenOut, balance: operation.shares }
+      };
+    case "Withdraw":
+      return {
+        operation: "Withdraw",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, error },
+        tokenOut: { token: tokenOut, balance: operation.assets }
+      };
+    case "Redeem":
+      return {
+        operation: "Redeem",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, balance: operation.shares },
+        tokenOut: { token: tokenOut, error }
+      };
+  }
+}
+export {
+  previewPoolOperation
+};