@gearbox-protocol/sdk 14.12.0-next.9 → 14.12.0-test.1

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
+};

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, exitTokens) {
+  for (const op of multicall) {
+    if (op.operation === "AddCollateral") {
+      return "repay";
+    }
+    if (op.operation === "WithdrawCollateral" && !exitTokens.some((token) => isAddressEqual(op.token, token))) {
+      return "repay";
+    }
+  }
+  return "close";
+}
+export {
+  classifyCloseOrRepay,
+  isCloseOrRepay
+};

package/dist/esm/preview/preview/detectDelayedClaim.js

@@ -0,0 +1,30 @@
+import {
+  AbstractAdapterContract
+} from "../../plugins/adapters/index.js";
+function detectDelayedClaim(sdk, multicall) {
+  for (const op of multicall) {
+    if (op.operation !== "Execute") {
+      continue;
+    }
+    const adapter = sdk.getContract(op.adapter);
+    if (!(adapter instanceof AbstractAdapterContract)) {
+      continue;
+    }
+    const claim = adapter.parseDelayedWithdrawalClaim(op.calldata);
+    if (claim) {
+      return { adapter: op.adapter, redeemer: claim.redeemer };
+    }
+  }
+  return void 0;
+}
+async function resolveDelayedClaimIntent(sdk, multicall, blockNumber) {
+  const claim = detectDelayedClaim(sdk, multicall);
+  if (!claim) {
+    return void 0;
+  }
+  return sdk.redemptionLogger?.getDelayedIntent(claim.redeemer, blockNumber);
+}
+export {
+  detectDelayedClaim,
+  resolveDelayedClaimIntent
+};

package/dist/esm/preview/preview/detectDelayedOperation.js

@@ -0,0 +1,51 @@
+import { isAddressEqual } from "viem";
+import {
+  AbstractAdapterContract
+} from "../../plugins/adapters/index.js";
+import {
+  decodeDelayedIntent,
+  InvalidDelayedIntentError
+} from "../../sdk/index.js";
+function detectDelayedOperation(sdk, multicall) {
+  let bracketDeltas = [];
+  for (const op of multicall) {
+    if (op.operation === "StoreExpectedBalances") {
+      bracketDeltas = op.deltas;
+      continue;
+    }
+    if (op.operation === "CompareBalances") {
+      bracketDeltas = [];
+      continue;
+    }
+    if (op.operation !== "Execute") {
+      continue;
+    }
+    const adapter = sdk.getContract(op.adapter);
+    if (!(adapter instanceof AbstractAdapterContract)) {
+      continue;
+    }
+    const request = adapter.parseDelayedWithdrawalRequest(op.calldata);
+    if (!request) {
+      continue;
+    }
+    const mintsPhantom = bracketDeltas.some(
+      ({ token, balance }) => balance > 0n && isAddressEqual(token, request.phantomToken)
+    );
+    if (!mintsPhantom) {
+      continue;
+    }
+    let intent;
+    if (request.extraData && request.extraData !== "0x") {
+      try {
+        intent = decodeDelayedIntent(request.extraData);
+      } catch (e) {
+        throw new InvalidDelayedIntentError(request.extraData, e);
+      }
+    }
+    return { request, intent };
+  }
+  return void 0;
+}
+export {
+  detectDelayedOperation
+};

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

@@ -1,17 +1,3 @@
-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;
@@ -22,6 +8,5 @@ class UnsupportedOperationError extends Error {
   }
 }
 export {
-  InvalidTransactionValueError,
   UnsupportedOperationError
 };

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

@@ -1,3 +1,12 @@
+export * from "./buildDelayedPreview.js";
+export * from "./CreditAccountState.js";
+export * from "./detectCloseOrRepay.js";
+export * from "./detectDelayedClaim.js";
+export * from "./detectDelayedOperation.js";
 export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewCloseOrRepayCreditAccount.js";
 export * from "./previewOperation.js";
+export * from "./replayInnerOperations.js";
+export * from "./replayMulticall.js";
 export * from "./types.js";

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

@@ -0,0 +1,57 @@
+import { AP_WETH_TOKEN, NO_VERSION } from "../../sdk/index.js";
+import { replayMulticall } from "./replayMulticall.js";
+import {
+  ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST
+} from "./types.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+async function previewAdjustCreditAccount(input, operation, options) {
+  const { sdk, value = 0n } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const {
+    before,
+    after,
+    error: replayError
+  } = await replayMulticall(sdk, operation, options);
+  const account = after.account;
+  let error = replayError;
+  const { assets: collateralAdded, error: unwrapError } = unwrapNativeCollateral(
+    after.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  error ??= unwrapError;
+  const assets = account.balances.toAssets(PREVIEW_DUST);
+  const assetsChange = account.balances.difference(before.balances).toAssets(PREVIEW_DUST);
+  const totalValue = assets.reduce((acc, { token, balance }) => {
+    try {
+      return acc + market.priceOracle.convert(token, market.underlying, balance);
+    } catch {
+      error ??= {
+        code: ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return acc;
+    }
+  }, 0n);
+  return {
+    operation: "AdjustCreditAccount",
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    collateralWithdrawn: after.collateralWithdrawn.toAssets(),
+    totalValue,
+    debt: account.debt,
+    debtChange: account.debt - before.debt,
+    quotas: account.quotas.toAssets(0n),
+    quotasChange: account.quotas.difference(before.quotas).toAssets(),
+    assets,
+    assetsChange,
+    error
+  };
+}
+export {
+  previewAdjustCreditAccount
+};

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

@@ -0,0 +1,76 @@
+import {
+  AP_WETH_TOKEN,
+  MAX_UINT256,
+  NO_VERSION
+} from "../../sdk/index.js";
+import { classifyCloseOrRepay } from "./detectCloseOrRepay.js";
+import {
+  replayMulticall
+} from "./replayMulticall.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+async function previewCloseOrRepayCreditAccount(input, operation, permanent, options) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const exitTokens = [market.underlying];
+  const meta = sdk.tokensMeta.get(market.underlying);
+  if (meta && sdk.tokensMeta.isRWAUnderlying(meta)) {
+    exitTokens.push(meta.asset);
+  }
+  const replay = await replayMulticall(sdk, operation, options);
+  const kind = classifyCloseOrRepay(operation.multicall, exitTokens);
+  return kind === "close" ? previewCloseCreditAccount(input, operation, permanent, replay) : previewRepayCreditAccount(input, operation, permanent, replay);
+}
+function previewCloseCreditAccount(input, operation, permanent, replay) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const { after, error } = replay;
+  let receivedToken = market.underlying;
+  for (const m of operation.multicall) {
+    if (m.operation === "WithdrawCollateral" && m.amount === MAX_UINT256) {
+      receivedToken = m.token;
+      break;
+    }
+  }
+  return {
+    operation: "CloseCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    // On a malformed multicall the withdrawn amount depends on best-effort
+    // replayed balances and may be unreliable
+    receivedAmount: {
+      token: receivedToken,
+      balance: after.collateralWithdrawn.getOrZero(receivedToken)
+    },
+    error
+  };
+}
+function previewRepayCreditAccount(input, operation, permanent, replay) {
+  const { sdk, value = 0n } = input;
+  const { before, after, error: replayError } = replay;
+  const { assets: collateralAdded, error: unwrapError } = unwrapNativeCollateral(
+    after.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  const error = replayError ?? unwrapError;
+  return {
+    operation: "RepayCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    debtRepaid: before.totalDebt - after.account.totalDebt,
+    // On a malformed multicall the MAX_UINT256 withdrawal sentinel resolves
+    // against best-effort replayed balances and may be unreliable
+    collateralWithdrawn: after.collateralWithdrawn.toAssets(),
+    error
+  };
+}
+export {
+  previewCloseOrRepayCreditAccount
+};

package/dist/esm/preview/preview/previewOpenCreditAccount.js

@@ -1,99 +1,57 @@
-import { AbstractAdapterContract } from "../../plugins/adapters/index.js";
 import {
   AP_WETH_TOKEN,
-  AssetsMap,
   NO_VERSION
 } from "../../sdk/index.js";
+import { CreditAccountState } from "./CreditAccountState.js";
+import {
+  makeReplayState,
+  replayInnerOperations
+} from "./replayInnerOperations.js";
+import {
+  ERROR_UNPRICEABLE_TOKEN
+} from "./types.js";
 import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
-function previewOpenCreditAccount(input, operation) {
+async function previewOpenCreditAccount(input, operation) {
   const { sdk, value = 0n } = input;
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
-  const collateralBalances = new AssetsMap();
-  const balances = new AssetsMap();
-  let debt = 0n;
-  const quotas = [];
-  let inBracket = false;
-  let storeSeen = false;
-  for (const op of operation.multicall) {
-    switch (op.operation) {
-      case "AddCollateral":
-        collateralBalances.inc(op.token, op.amount);
-        balances.inc(op.token, op.amount);
-        break;
-      case "WithdrawCollateral":
-        balances.dec(op.token, op.amount);
-        break;
-      case "IncreaseBorrowedAmount":
-        debt += op.amount;
-        balances.inc(op.token, op.amount);
-        break;
-      case "DecreaseBorrowedAmount":
-        debt -= op.amount;
-        balances.dec(op.token, op.amount);
-        break;
-      case "UpdateQuota":
-        quotas.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) {
-          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(balances, op.calldata);
-        }
-        break;
-    }
-  }
-  if (inBracket) {
-    throw new Error(
-      "malformed multicall: storeExpectedBalances without a matching compareBalances"
-    );
-  }
-  let collateral = collateralBalances.toAssets();
-  const collateralValue = collateral.reduce(
-    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
-    0n
+  const state = makeReplayState(
+    CreditAccountState.beforeOpen(operation.creditManager, market.underlying)
   );
-  collateral = unwrapNativeCollateral(
-    collateral,
+  let error = await replayInnerOperations(sdk, operation.multicall, state);
+  const account = state.account;
+  let priceError;
+  const collateralValue = state.collateralAdded.sum((token, balance) => {
+    try {
+      return market.priceOracle.convert(token, market.underlying, balance);
+    } catch {
+      priceError ??= {
+        code: ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return 0n;
+    }
+  });
+  const { assets: collateral, error: unwrapError } = unwrapNativeCollateral(
+    state.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
   );
-  const assets = balances.entries().filter(([, balance]) => balance > 1n).map(([token, balance]) => ({ token, balance }));
+  error ??= unwrapError ?? priceError;
+  const assets = account.balances.toAssets(1n);
   return {
     operation: operation.operation,
     creditManager: operation.creditManager,
-    target: inferTargetAsset(operation.multicall, balances),
+    target: inferTargetAsset(operation.multicall, account.balances),
     collateral,
     collateralValue,
-    debt,
-    quotas,
-    assets
+    debt: account.debt,
+    // On opening, initial quotas are zero, so the folded quotas are the
+    // applied changes.
+    quotas: account.quotas.toAssets(0n),
+    assets,
+    error
   };
 }
 function inferTargetAsset(multicall, balances) {

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

@@ -1,17 +1,95 @@
-import { isPoolOperation, parseOperationCalldata } from "../parse/index.js";
+import {
+  isPoolOperation,
+  parseOperationCalldata
+} from "../parse/index.js";
+import { buildDelayedPreview } from "./buildDelayedPreview.js";
+import { isCloseOrRepay } from "./detectCloseOrRepay.js";
+import { resolveDelayedClaimIntent } from "./detectDelayedClaim.js";
+import { detectDelayedOperation } from "./detectDelayedOperation.js";
 import { UnsupportedOperationError } from "./errors.js";
+import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
+import { previewCloseOrRepayCreditAccount } from "./previewCloseOrRepayCreditAccount.js";
 import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
 import { previewPoolOperation } from "./previewPoolOperation.js";
+import {
+  replayMulticall
+} from "./replayMulticall.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") {
+  if (operation.operation === "OpenCreditAccount" || operation.operation === "RWAOpenCreditAccount") {
     return previewOpenCreditAccount(input, operation);
   }
+  if (operation.operation === "CloseCreditAccount") {
+    const resolved = await resolveCreditAccount(input, operation, options);
+    const preview = await previewCloseOrRepayCreditAccount(
+      input,
+      operation,
+      true,
+      resolved
+    );
+    preview.intent = await resolveDelayedClaimIntent(
+      input.sdk,
+      operation.multicall,
+      options?.blockNumber
+    );
+    return preview;
+  }
+  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") {
+    const resolved = await resolveCreditAccount(input, operation, options);
+    return previewMulticallOperation(input, operation, resolved);
+  }
   throw new UnsupportedOperationError(operation.operation);
 }
+async function resolveCreditAccount(input, operation, options) {
+  let creditAccount = options?.creditAccount;
+  if (!creditAccount) {
+    creditAccount = await input.sdk.accounts.getCreditAccountData(
+      operation.creditAccount,
+      options?.blockNumber
+    );
+  }
+  if (!creditAccount) {
+    throw new Error(`credit account ${operation.creditAccount} not found`);
+  }
+  return { ...options, creditAccount };
+}
+async function previewMulticallOperation(input, operation, options) {
+  const { sdk } = input;
+  const instantPreview = isCloseOrRepay(operation.multicall) ? await previewCloseOrRepayCreditAccount(input, operation, false, options) : await previewAdjustCreditAccount(input, operation, options);
+  const delayed = detectDelayedOperation(sdk, operation.multicall);
+  if (!delayed) {
+    instantPreview.intent = await resolveDelayedClaimIntent(
+      sdk,
+      operation.multicall,
+      options?.blockNumber
+    );
+    return instantPreview;
+  }
+  const { before, after } = await replayMulticall(sdk, operation, options);
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const convert = (token, to, amount) => market.priceOracle.convert(token, to, amount);
+  const meta = sdk.tokensMeta.get(market.underlying);
+  const receivedToken = meta && sdk.tokensMeta.isRWAUnderlying(meta) ? meta.asset : market.underlying;
+  return {
+    operation: "DelayedCreditAccountOperation",
+    creditAccount: operation.creditAccount,
+    creditManager: operation.creditManager,
+    intent: delayed.intent,
+    instantPreview,
+    delayedPreview: buildDelayedPreview(
+      after.account,
+      before,
+      delayed,
+      convert,
+      receivedToken
+    )
+  };
+}
 export {
   previewOperation
 };