@gearbox-protocol/sdk 14.12.0-next.11 → 14.12.0-next.13

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

@@ -1,10 +1,6 @@
 import { erc20Abi } from "viem";
-import { iMulticall3Abi } from "../../abi/iMulticall3.js";
 import { hexEq, NATIVE_ADDRESS } from "../../sdk/index.js";
-import {
-  Prerequisite,
-  toPrerequisiteError
-} from "./Prerequisite.js";
+import { Prerequisite } from "./Prerequisite.js";
 class BalancePrerequisite extends Prerequisite {
   #id;
   #title;
@@ -31,43 +27,28 @@ class BalancePrerequisite extends Prerequisite {
   get detail() {
     return this.#detail;
   }
-  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,
-        abi: erc20Abi,
-        functionName: "balanceOf",
-        args: [this.#detail.owner]
-      }
-    ];
-  }
-  resolve(slice) {
-    const res = slice[0];
-    if (!res || res.status === "failure") {
-      return this.errorResult(toPrerequisiteError(res?.error));
-    }
-    const actual = res.result;
+  async check(ctx) {
+    const actual = await this.#readBalance(ctx);
     return this.satisfiedResult(actual >= this.#detail.required, {
       ...this.#detail,
       actual
     });
   }
+  async #readBalance(ctx) {
+    if (hexEq(this.#detail.token, NATIVE_ADDRESS)) {
+      return ctx.sdk.client.getBalance({
+        address: this.#detail.owner,
+        blockNumber: ctx.blockNumber
+      });
+    }
+    return ctx.sdk.client.readContract({
+      address: this.#detail.token,
+      abi: erc20Abi,
+      functionName: "balanceOf",
+      args: [this.#detail.owner],
+      blockNumber: ctx.blockNumber
+    });
+  }
 }
 export {
   BalancePrerequisite

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

@@ -1,7 +1,4 @@
-import {
-  BaseError,
-  ContractFunctionRevertedError
-} from "viem";
+import { BaseError, ContractFunctionRevertedError } from "viem";
 function toPrerequisiteError(cause) {
   if (cause instanceof BaseError) {
     const reverted = cause.walk(
@@ -22,19 +19,16 @@ function toPrerequisiteError(cause) {
 }
 class Prerequisite {
   /**
-   * Verifies this prerequisite on its own using an `allowFailure` multicall.
-   * Prefer `verifyPrerequisites` to batch several checks into one round-trip.
+   * Verifies this prerequisite. Never rejects: any error thrown by
+   * {@link check} (revert, RPC/network failure, compressor error) is
+   * normalized into an `error` result.
    */
   async verify(ctx) {
-    const calls = this.calls(ctx);
-    const results = await ctx.sdk.client.multicall({
-      allowFailure: true,
-      contracts: calls,
-      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
-      // testnet forks pinned to a specific block.
-      blockNumber: ctx.blockNumber
-    });
-    return this.resolve(results);
+    try {
+      return await this.check(ctx);
+    } catch (cause) {
+      return this.errorResult(cause);
+    }
   }
   /** Builds a successful result; `detail` carries the on-chain `actual`. */
   satisfiedResult(satisfied, detail) {
@@ -46,18 +40,17 @@ class Prerequisite {
       satisfied
     };
   }
-  /** Builds a failed result from a decoded read error. */
-  errorResult(error) {
+  /** Builds a failed result from a raw read error (normalized internally). */
+  errorResult(cause) {
     return {
       id: this.id,
       kind: this.kind,
       title: this.title,
       detail: this.detail,
-      error
+      error: toPrerequisiteError(cause)
     };
   }
 }
 export {
-  Prerequisite,
-  toPrerequisiteError
+  Prerequisite
 };

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

@@ -3,11 +3,17 @@ class RWAOpenRequirementsPrerequisite extends Prerequisite {
   #id;
   #title;
   #detail;
+  #providedArgs;
   constructor(props) {
     super();
     this.#id = props.id ?? `rwaOpenRequirements:${props.factory}:${props.token}`;
     this.#title = props.title ?? "RWA account requirements fulfilled";
-    this.#detail = props.requirements;
+    this.#detail = {
+      token: props.token,
+      creditManager: props.creditManager,
+      factory: props.factory
+    };
+    this.#providedArgs = props.providedArgs;
   }
   get id() {
     return this.#id;
@@ -21,20 +27,35 @@ class RWAOpenRequirementsPrerequisite extends Prerequisite {
   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;
+  async check(ctx) {
+    const requirements = await ctx.sdk.accounts.getOpenAccountRequirements(
+      ctx.wallet,
+      this.#detail.creditManager,
+      { tokenOutAddress: this.#detail.token }
+    );
+    if (!requirements) {
+      return this.satisfiedResult(true, this.#detail);
+    }
+    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 this.satisfiedResult(
+      !missing && requirements.securitizeTokensToRegister.length === 0,
+      {
+        ...this.#detail,
+        requirements,
+        missing
+      }
+    );
   }
 }
 export {

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

@@ -0,0 +1,35 @@
+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,
+        allowanceTitle: "Collateral approved",
+        balanceTitle: "Sufficient collateral balance"
+      })
+    );
+  }
+  return prereqs;
+}
+export {
+  buildCollateralPrerequisites
+};

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

@@ -0,0 +1,18 @@
+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,
+    allowanceTitle: "Underlying approved to credit manager",
+    balanceTitle: "Sufficient underlying balance"
+  });
+}
+export {
+  buildPartialLiquidationPrerequisites
+};

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

@@ -0,0 +1,101 @@
+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,
+              title: "Sufficient token balance"
+            })
+          ];
+        }
+        return allowanceAndBalance({
+          token: tx.tokenIn,
+          owner: wallet,
+          spender: tx.zapper,
+          required: tx.assets,
+          allowanceTitle: "Token approved to zapper",
+          balanceTitle: "Sufficient token balance"
+        });
+      }
+      return allowanceAndBalance({
+        token: tx.underlying,
+        owner: wallet,
+        spender: tx.pool,
+        required: tx.assets,
+        allowanceTitle: "Token approved to pool",
+        balanceTitle: "Sufficient token balance"
+      });
+    case "Mint":
+      return allowanceAndBalance({
+        token: tx.underlying,
+        owner: wallet,
+        spender: tx.pool,
+        required: tx.shares,
+        allowanceTitle: "Token approved to pool",
+        balanceTitle: "Sufficient token balance"
+      });
+    // 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"
+          })
+        ];
+      }
+      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,
+      title: "Sufficient LP token balance"
+    })
+  ];
+  if (!isAddressEqual(owner, wallet)) {
+    prereqs.push(
+      new AllowancePrerequisite({
+        token: pool,
+        owner,
+        spender: wallet,
+        required,
+        title: "LP token approved to caller"
+      })
+    );
+  }
+  return prereqs;
+}
+export {
+  buildPoolPrerequisites
+};

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

@@ -0,0 +1,33 @@
+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,63 @@
+import {
+  parseOperationCalldata
+} from "../parse/parseOperationCalldata.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) {
+  const { sdk, sender: wallet, blockNumber } = input;
+  const tx = parseOperationCalldata(input);
+  const ctx = { sdk, wallet, blockNumber };
+  const prereqs = await buildPrerequisites(tx, ctx);
+  return Promise.all(
+    // Each prereq pairs its own kind with its detail, so the widened
+    // `verify` return is safe to narrow back to the discriminated union.
+    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,23 @@
+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,
+      title: props.allowanceTitle
+    }),
+    new BalancePrerequisite({
+      token,
+      owner,
+      required,
+      title: props.balanceTitle
+    })
+  ];
+}
+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/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/index.js

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

package/dist/esm/preview/preview/previewCloseOrRepay.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 previewCloseOrRepay(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 {
+  previewCloseOrRepay
+};

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

@@ -1,6 +1,8 @@
 import { isPoolOperation, parseOperationCalldata } from "../parse/index.js";
+import { isCloseOrRepay } from "./detectCloseOrRepay.js";
 import { UnsupportedOperationError } from "./errors.js";
 import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
+import { previewCloseOrRepay } from "./previewCloseOrRepay.js";
 import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
 import { previewPoolOperation } from "./previewPoolOperation.js";
 async function previewOperation(input, options) {
@@ -8,10 +10,16 @@ async function previewOperation(input, options) {
   if (isPoolOperation(operation)) {
     return previewPoolOperation(input, operation, options);
   }
-  if (operation.operation === "OpenCreditAccount" || operation.operation === "SecuritizeOpenCreditAccount") {
+  if (operation.operation === "OpenCreditAccount" || operation.operation === "RWAOpenCreditAccount") {
     return previewOpenCreditAccount(input, operation);
   }
-  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "SecuritizeMulticall") {
+  if (operation.operation === "CloseCreditAccount") {
+    return previewCloseOrRepay(input, operation, true, options);
+  }
+  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") {
+    if (isCloseOrRepay(operation.multicall)) {
+      return previewCloseOrRepay(input, operation, false, options);
+    }
     return previewAdjustCreditAccount(input, operation, options);
   }
   throw new UnsupportedOperationError(operation.operation);