@gearbox-protocol/sdk 14.12.0-next.3 → 14.12.0-next.30

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

@@ -0,0 +1,57 @@
+import { AP_WETH_TOKEN, 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 replay = await replayMulticall(sdk, operation, options);
+  const kind = classifyCloseOrRepay(operation.multicall, market.underlying);
+  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;
+  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: after.collateralWithdrawn.getOrZero(market.underlying),
+    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

@@ -0,0 +1,68 @@
+import {
+  AP_WETH_TOKEN,
+  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";
+async function previewOpenCreditAccount(input, operation) {
+  const { sdk, value = 0n } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const state = makeReplayState(
+    CreditAccountState.beforeOpen(operation.creditManager, market.underlying)
+  );
+  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)
+  );
+  error ??= unwrapError ?? priceError;
+  const assets = account.balances.toAssets(1n);
+  return {
+    operation: operation.operation,
+    creditManager: operation.creditManager,
+    target: inferTargetAsset(operation.multicall, account.balances),
+    collateral,
+    collateralValue,
+    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) {
+  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,75 @@
+import {
+  isPoolOperation,
+  parseOperationCalldata
+} from "../parse/index.js";
+import { buildDelayedPreview } from "./buildDelayedPreview.js";
+import { isCloseOrRepay } from "./detectCloseOrRepay.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 === "RWAOpenCreditAccount") {
+    return previewOpenCreditAccount(input, operation);
+  }
+  if (operation.operation === "CloseCreditAccount") {
+    const resolved = await resolveCreditAccount(input, operation, options);
+    return previewCloseOrRepayCreditAccount(input, operation, true, resolved);
+  }
+  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) {
+    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);
+  return {
+    operation: "DelayedCreditAccountOperation",
+    creditAccount: operation.creditAccount,
+    creditManager: operation.creditManager,
+    intent: delayed.intent,
+    instantPreview,
+    delayedPreview: buildDelayedPreview(
+      after.account,
+      before,
+      delayed,
+      convert
+    )
+  };
+}
+export {
+  previewOperation
+};

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

@@ -0,0 +1,18 @@
+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
+  );
+  return {
+    operation: operation.operation,
+    pool: operation.pool,
+    tokenIn: { token: tokenIn, balance: sim.amountIn },
+    tokenOut: { token: tokenOut, balance: sim.amountOut }
+  };
+}
+export {
+  previewPoolOperation
+};

package/dist/esm/preview/preview/replayInnerOperations.js

@@ -0,0 +1,137 @@
+import {
+  AbstractAdapterContract,
+  ERC4626AdapterContract
+} from "../../plugins/adapters/index.js";
+import { AssetsMap, MAX_UINT256 } from "../../sdk/index.js";
+import { applyRWAWrapUnwrap } from "./applyRWAWrapUnwrap.js";
+import {
+  ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+  ERROR_MALFORMED_BRACKET,
+  ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+  ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+  ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP
+} from "./types.js";
+function makeReplayState(account) {
+  return {
+    account,
+    collateralAdded: new AssetsMap(),
+    collateralWithdrawn: new AssetsMap()
+  };
+}
+async function replayInnerOperations(sdk, multicall, state) {
+  let inBracket = false;
+  let error;
+  for (const op of multicall) {
+    let opError;
+    switch (op.operation) {
+      case "AddCollateral":
+        applyAddCollateral(state, op);
+        break;
+      case "WithdrawCollateral":
+        applyWithdrawCollateral(state, op);
+        break;
+      case "IncreaseBorrowedAmount":
+        state.account.increaseDebt(op.amount);
+        break;
+      case "DecreaseBorrowedAmount":
+        state.account.repay(op.amount);
+        break;
+      case "UpdateQuota":
+        state.account.updateQuota(op.token, op.change);
+        break;
+      case "StoreExpectedBalances":
+        if (inBracket) {
+          opError = {
+            code: ERROR_MALFORMED_BRACKET,
+            message: "nested storeExpectedBalances/compareBalances bracket"
+          };
+        }
+        inBracket = true;
+        for (const { token, balance } of op.deltas) {
+          state.account.balances.inc(token, balance);
+        }
+        break;
+      case "CompareBalances":
+        if (!inBracket) {
+          opError = {
+            code: ERROR_MALFORMED_BRACKET,
+            message: "compareBalances without a preceding storeExpectedBalances"
+          };
+        }
+        inBracket = false;
+        break;
+      case "Execute":
+        opError = await applyExecute(
+          sdk,
+          op,
+          inBracket,
+          state.account.balances
+        );
+        break;
+    }
+    error ??= opError;
+  }
+  if (inBracket) {
+    error ??= {
+      code: ERROR_MALFORMED_BRACKET,
+      message: "storeExpectedBalances without a matching compareBalances"
+    };
+  }
+  return error;
+}
+function applyAddCollateral(state, op) {
+  state.collateralAdded.inc(op.token, op.amount);
+  state.account.balances.inc(op.token, op.amount);
+}
+function applyWithdrawCollateral(state, op) {
+  const running = state.account.balances.getOrZero(op.token);
+  const amount = op.amount === MAX_UINT256 ? running > 0n ? running : 0n : op.amount;
+  state.account.balances.dec(op.token, amount);
+  state.collateralWithdrawn.inc(op.token, amount);
+}
+async function applyExecute(sdk, op, inBracket, balances) {
+  const adapter = sdk.getContract(op.adapter);
+  if (!inBracket) {
+    if (!isRWAShare(sdk, adapter)) {
+      return {
+        code: ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+        message: `call to ${op.adapter} outside of a storeExpectedBalances/compareBalances bracket`
+      };
+    }
+    try {
+      applyRWAWrapUnwrap(adapter, op.calldata, balances);
+      return void 0;
+    } catch (e) {
+      return {
+        code: ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+        message: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  if (!(adapter instanceof AbstractAdapterContract)) {
+    return {
+      code: ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+      message: `call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`
+    };
+  }
+  try {
+    await adapter.previewBalanceChanges(balances, op.calldata);
+    return void 0;
+  } catch (e) {
+    return {
+      code: ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+      message: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function isRWAShare(sdk, adapter) {
+  if (adapter instanceof ERC4626AdapterContract) {
+    const meta = sdk.tokensMeta.get(adapter.share);
+    return !!meta && sdk.tokensMeta.isRWAUnderlying(meta);
+  }
+  return false;
+}
+export {
+  makeReplayState,
+  replayInnerOperations
+};

package/dist/esm/preview/preview/replayMulticall.js

@@ -0,0 +1,16 @@
+import { CreditAccountState } from "./CreditAccountState.js";
+import {
+  makeReplayState,
+  replayInnerOperations
+} from "./replayInnerOperations.js";
+async function replayMulticall(sdk, operation, options) {
+  const before = CreditAccountState.fromCreditAccountData(
+    options.creditAccount
+  );
+  const after = makeReplayState(before.clone());
+  const error = await replayInnerOperations(sdk, operation.multicall, after);
+  return { before, after, error };
+}
+export {
+  replayMulticall
+};

package/dist/esm/preview/preview/types.js

@@ -0,0 +1,18 @@
+const ERROR_MALFORMED_BRACKET = 1001;
+const ERROR_ADAPTER_CALL_OUTSIDE_BRACKET = 1002;
+const ERROR_NON_ADAPTER_CALL_IN_BRACKET = 1003;
+const ERROR_UNPREVIEWABLE_ADAPTER_CALL = 1004;
+const ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP = 1005;
+const ERROR_INVALID_TRANSACTION_VALUE = 1006;
+const ERROR_UNPRICEABLE_TOKEN = 2001;
+const PREVIEW_DUST = 10n;
+export {
+  ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+  ERROR_INVALID_TRANSACTION_VALUE,
+  ERROR_MALFORMED_BRACKET,
+  ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+  ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+  ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+  ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST
+};

package/dist/esm/preview/preview/unwrapNativeCollateral.js

@@ -0,0 +1,29 @@
+import { AssetsMap, NATIVE_ADDRESS } from "../../sdk/index.js";
+import {
+  ERROR_INVALID_TRANSACTION_VALUE
+} from "./types.js";
+function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
+  if (nativeAmount === 0n) {
+    return { assets: collateral };
+  }
+  const balances = new AssetsMap(collateral);
+  const wethBalance = balances.get(wethToken) ?? 0n;
+  if (wethBalance < nativeAmount) {
+    return {
+      assets: collateral,
+      error: {
+        code: ERROR_INVALID_TRANSACTION_VALUE,
+        message: `transaction value ${nativeAmount} exceeds WETH collateral ${wethBalance}`
+      }
+    };
+  }
+  balances.upsert(
+    wethToken,
+    wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount
+  );
+  balances.inc(NATIVE_ADDRESS, nativeAmount);
+  return { assets: balances.toAssets() };
+}
+export {
+  unwrapNativeCollateral
+};

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

@@ -2,9 +2,11 @@ import { PreviewSimulationError } from "./errors.js";
 import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulateOperation } from "./simulateOperation.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
+import { simulateRWAOperation } from "./simulateRWAOperation.js";
 export {
   PreviewSimulationError,
   simulateFacadeOperation,
   simulateOperation,
-  simulatePoolOperation
+  simulatePoolOperation,
+  simulateRWAOperation
 };

package/dist/esm/preview/simulate/simulateOperation.js

@@ -1,11 +1,15 @@
-import { isPoolOperation } from "../parse/index.js";
+import { isPoolOperation, isRWAOperation } from "../parse/index.js";
 import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
+import { simulateRWAOperation } from "./simulateRWAOperation.js";
 async function simulateOperation(input, options) {
   const { operation } = input;
   if (isPoolOperation(operation)) {
     return simulatePoolOperation({ ...input, operation }, options);
   }
+  if (isRWAOperation(operation)) {
+    return simulateRWAOperation({ ...input, operation }, options);
+  }
   return simulateFacadeOperation({ ...input, operation }, options);
 }
 export {

package/dist/esm/preview/simulate/simulatePoolOperation.js

@@ -1,13 +1,6 @@
 import { iPoolV310Abi } from "../../abi/310/generated.js";
-import { ierc20Abi } from "../../abi/iERC20.js";
 import { iZapperAbi } from "../../abi/iZapper.js";
-import { AddressMap } from "../../sdk/index.js";
-import {
-  asPreviewSimulationError,
-  decodeSimulationError,
-  PreviewSimulationError
-} from "./errors.js";
-import { watchedHolders } from "./holders.js";
+import { asPreviewSimulationError } from "./errors.js";
 function previewRead(operation) {
   switch (operation.operation) {
     case "Deposit":
@@ -20,16 +13,6 @@ function previewRead(operation) {
       return { functionName: "previewRedeem", amount: operation.shares };
   }
 }
-function outsideToken(operation) {
-  switch (operation.operation) {
-    case "Deposit":
-    case "Mint":
-      return operation.tokenIn;
-    case "Withdraw":
-    case "Redeem":
-      return operation.tokenOut;
-  }
-}
 function previewContract(operation) {
   const { functionName, amount } = previewRead(operation);
   if (operation.zapper) {
@@ -47,120 +30,35 @@ function previewContract(operation) {
     args: [amount]
   };
 }
-async function simulatePoolOperation(input, options = {}) {
-  const { sdk, operation, wallet } = input;
-  const { blockNumber, logger } = options;
-  const { pool } = operation;
-  try {
-    const holders = watchedHolders(operation, wallet);
-    const tokens = [outsideToken(operation), pool];
-    const balanceCalls = holders.flatMap(
-      (holder) => tokens.map((token) => ({ holder, token }))
-    );
-    const balanceContracts = balanceCalls.map(
-      ({ holder, token }) => ({
-        address: token,
-        abi: ierc20Abi,
-        functionName: "balanceOf",
-        args: [holder]
-      })
-    );
-    const preview = previewContract(operation);
-    let results;
-    try {
-      results = await sdk.client.multicall({
-        allowFailure: false,
-        // `undefined` lets viem read at `latest`; `blockNumber` is only set for
-        // testnet forks pinned to a specific block.
-        blockNumber,
-        contracts: [...balanceContracts, preview]
-      });
-    } catch (cause) {
-      throw new PreviewSimulationError([
-        {
-          source: "multicall",
-          detail: decodeSimulationError({
-            error: cause instanceof Error ? cause : new Error(String(cause))
-          })
-        }
-      ]);
-    }
-    const previewAmount = results[balanceContracts.length];
-    const balances = new AddressMap();
-    for (const [i, { holder, token }] of balanceCalls.entries()) {
-      const tokenBalances = balances.get(holder) ?? new AddressMap();
-      tokenBalances.upsert(token, results[i]);
-      balances.upsert(holder, tokenBalances);
-    }
-    const before = (token, holder) => balances.get(holder)?.get(token) ?? 0n;
-    return {
-      status: "success",
-      balanceChanges: computePoolOpBalanceChanges(
-        operation,
-        wallet,
-        previewAmount,
-        before
-      )
-    };
-  } catch (cause) {
-    const error = asPreviewSimulationError(cause, "multicall");
-    logger?.error(error, "pool operation simulation failed");
-    return { status: "failure", error };
-  }
-}
-function balanceLegs(operation, wallet, previewAmount) {
-  const { pool, receiver } = operation;
+function amountsInOut(operation, previewAmount) {
   switch (operation.operation) {
     case "Deposit":
-      return [
-        { address: wallet, token: operation.tokenIn, delta: -operation.assets },
-        { address: receiver, token: pool, delta: previewAmount }
-      ];
+      return { amountIn: operation.assets, amountOut: previewAmount };
     case "Mint":
-      return [
-        { address: wallet, token: operation.tokenIn, delta: -previewAmount },
-        { address: receiver, token: pool, delta: operation.shares }
-      ];
+      return { amountIn: previewAmount, amountOut: operation.shares };
     case "Withdraw":
-      return [
-        { address: operation.owner, token: pool, delta: -previewAmount },
-        {
-          address: receiver,
-          token: operation.tokenOut,
-          delta: operation.assets
-        }
-      ];
+      return { amountIn: previewAmount, amountOut: operation.assets };
     case "Redeem":
-      return [
-        { address: operation.owner, token: pool, delta: -operation.shares },
-        { address: receiver, token: operation.tokenOut, delta: previewAmount }
-      ];
+      return { amountIn: operation.shares, amountOut: previewAmount };
   }
 }
-function computePoolOpBalanceChanges(operation, wallet, previewAmount, before) {
-  const byAddress = new AddressMap();
-  for (const { address, token, delta } of balanceLegs(
-    operation,
-    wallet,
-    previewAmount
-  )) {
-    const beforeBalance = before(token, address);
-    const change = {
-      token,
-      before: beforeBalance,
-      after: beforeBalance + delta,
-      delta
-    };
-    const existing = byAddress.get(address);
-    if (existing) {
-      existing.changes.push(change);
-    } else {
-      byAddress.upsert(address, { address, changes: [change] });
-    }
+async function simulatePoolOperation(input, options = {}) {
+  const { sdk, operation } = input;
+  const { blockNumber, logger } = options;
+  try {
+    const previewAmount = await sdk.client.readContract({
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber,
+      ...previewContract(operation)
+    });
+    return amountsInOut(operation, previewAmount);
+  } catch (cause) {
+    const error = asPreviewSimulationError(cause, "multicall");
+    logger?.error(error, "pool operation simulation failed");
+    throw error;
   }
-  return byAddress.values();
 }
 export {
-  computePoolOpBalanceChanges,
   simulatePoolOperation
 };

package/dist/esm/preview/simulate/simulateRWAOperation.js

@@ -0,0 +1,6 @@
+async function simulateRWAOperation(_input, _options) {
+  throw new Error("not yet implemented");
+}
+export {
+  simulateRWAOperation
+};

package/dist/esm/sdk/OnchainSDK.js

@@ -5,7 +5,8 @@ import {
   parseEventLogs
 } from "viem";
 import {
-  CreditAccountsServiceV310
+  CreditAccountsServiceV310,
+  createWithdrawalCompressor
 } from "./accounts/index.js";
 import { ChainContractsRegister } from "./base/index.js";
 import { getChain } from "./chain/index.js";
@@ -534,6 +535,14 @@ class OnchainSDK extends ChainContractsRegister {
     const [routerAddr, routerV] = routerEntry;
     return createRouter(this, routerAddr, routerV);
   }
+  /**
+   * Lazily returns a withdrawal compressor contract for the current chain.
+   *
+   * @throws If no withdrawal compressor is supported on the current chain.
+   **/
+  get withdrawalCompressor() {
+    return createWithdrawalCompressor(this);
+  }
 }
 export {
   OnchainSDK,