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

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

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

@@ -1,6 +1,4 @@
-import {
-  simulatePoolOperation
-} from "../simulate/index.js";
+import { simulatePoolOperation } from "../simulate/index.js";
 async function previewPoolOperation(input, operation, options) {
   const { sdk, to, calldata } = input;
   const { tokenIn, tokenOut } = operation;
@@ -8,45 +6,12 @@ async function previewPoolOperation(input, operation, options) {
     { 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 }
-      };
-  }
+  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

@@ -1,34 +1,28 @@
-import { isAddressEqual } from "viem";
-import { NATIVE_ADDRESS } from "../../sdk/index.js";
-import { InvalidTransactionValueError } from "./errors.js";
+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 collateral;
+    return { assets: collateral };
   }
-  let unwrapped = false;
-  const result = [];
-  for (const asset of collateral) {
-    const isWeth = !unwrapped && isAddressEqual(asset.token, wethToken);
-    if (!isWeth) {
-      result.push(asset);
-      continue;
-    }
-    if (asset.balance < nativeAmount) {
-      throw new InvalidTransactionValueError(nativeAmount, asset.balance);
-    }
-    result.push({ token: NATIVE_ADDRESS, balance: nativeAmount });
-    if (asset.balance > nativeAmount) {
-      result.push({
-        token: asset.token,
-        balance: asset.balance - nativeAmount
-      });
-    }
-    unwrapped = true;
+  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}`
+      }
+    };
   }
-  if (!unwrapped) {
-    throw new InvalidTransactionValueError(nativeAmount, 0n);
-  }
-  return result;
+  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/simulateOperation.js

@@ -1,7 +1,4 @@
-import {
-  isPoolOperation,
-  isRWAOperation
-} 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";

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

@@ -52,14 +52,11 @@ async function simulatePoolOperation(input, options = {}) {
       blockNumber,
       ...previewContract(operation)
     });
-    return {
-      status: "success",
-      ...amountsInOut(operation, previewAmount)
-    };
+    return amountsInOut(operation, previewAmount);
   } catch (cause) {
     const error = asPreviewSimulationError(cause, "multicall");
     logger?.error(error, "pool operation simulation failed");
-    return { status: "failure", error };
+    throw error;
   }
 }
 export {

package/dist/esm/rewards/rewards/extra-apy.js

@@ -20,23 +20,27 @@ function getKeyForPoolPointsInfo(i) {
 class PoolPointsAPI {
   constructor() {
   }
+  static defaultBackendUrl = "https://api.gearbox.foundation";
   static async getTotalTokensOnProtocol({
     tokensToCheck,
     tokensList,
-    network
+    network,
+    backendUrl = PoolPointsAPI.defaultBackendUrl
   }) {
     const list = [...new Set(tokensToCheck)];
     const res = await Promise.allSettled(
-      list.map((t) => PoolPointsAPI.getTokenTotal(t, network, tokensList))
+      list.map(
+        (t) => PoolPointsAPI.getTokenTotal(t, network, tokensList, backendUrl)
+      )
     );
     return res.map((r, i) => [
       list[i],
       r
     ]);
   }
-  static async getTokenTotal(token, network, tokensList) {
+  static async getTokenTotal(token, network, tokensList, backendUrl) {
     const chainId = chains[network]?.id;
-    const url = `https://api.gearbox.foundation/v1/getBalanceAt?asset=${token}&chainId=${chainId}`;
+    const url = `${backendUrl}/v1/getBalanceAt?asset=${token}&chainId=${chainId}`;
     const result = await axios.get(url);
     const balance = result.data.result.reduce(
       (sum, r) => r.effective_balance + sum,

package/dist/esm/sdk/MultichainSDK.js

@@ -1,3 +1,4 @@
+import { MultichainLiquidationsService } from "./accounts/index.js";
 import { getNetworkType } from "./chain/chains.js";
 import {
   SdkMissingChainStateError,
@@ -16,6 +17,11 @@ class MultichainSDK {
   #redstoneCache;
   #pythCache;
   #logger;
+  /**
+   * Namespace for liquidatable credit accounts discovery across all
+   * configured chains.
+   */
+  liquidations;
   constructor(options) {
     this.#chains = /* @__PURE__ */ new Map();
     this.#logger = options.logger;
@@ -43,6 +49,7 @@ class MultichainSDK {
       );
       this.#chains.set(network, sdk);
     }
+    this.liquidations = new MultichainLiquidationsService(this);
   }
   /**
    * Attach all configured chains in parallel.

package/dist/esm/sdk/OnchainSDK.js

@@ -5,7 +5,10 @@ import {
   parseEventLogs
 } from "viem";
 import {
-  CreditAccountsServiceV310
+  CreditAccountsServiceV310,
+  createRedemptionLogger,
+  createWithdrawalCompressor,
+  LiquidationsService
 } from "./accounts/index.js";
 import { ChainContractsRegister } from "./base/index.js";
 import { getChain } from "./chain/index.js";
@@ -66,6 +69,8 @@ class OnchainSDK extends ChainContractsRegister {
   #rwa;
   #marketRegister;
   #priceFeeds;
+  #withdrawalCompressor;
+  #redemptionLogger;
   /**
    * Gas limit applied to read-only `eth_call` requests.
    **/
@@ -82,6 +87,10 @@ class OnchainSDK extends ChainContractsRegister {
    * Namespace for pool operations.
    */
   pools;
+  /**
+   * Namespace for liquidatable credit accounts discovery.
+   */
+  liquidations;
   /**
    * @param network - Gearbox network type (e.g. `"Mainnet"`, `"Monad"`).
    * @param clientOptions - Connection options (RPC URLs, transport, or client).
@@ -108,6 +117,8 @@ class OnchainSDK extends ChainContractsRegister {
     }
     this.accounts = new CreditAccountsServiceV310(this);
     this.pools = new PoolService(this);
+    this.liquidations = new LiquidationsService(this);
+    this.#withdrawalCompressor = createWithdrawalCompressor(this);
   }
   /**
    * Initialises the SDK by reading live on-chain state.
@@ -254,6 +265,9 @@ class OnchainSDK extends ChainContractsRegister {
     this.#marketRegister.hydrate(state);
     this.#rwa = new RWARegistry(this);
     this.#rwa.setState(state.rwa);
+    if (state.withdrawals) {
+      this.#withdrawalCompressor?.hydrate(state.withdrawals);
+    }
     for (const [name, plugin] of TypedObjectUtils.entries(this.plugins)) {
       const pluginState = state.plugins[name];
       if (plugin.hydrate && pluginState) {
@@ -318,6 +332,7 @@ class OnchainSDK extends ChainContractsRegister {
       addressProvider: this.addressProvider.state,
       ...this.marketRegister.state,
       rwa: this.#rwa.state,
+      withdrawals: this.#withdrawalCompressor?.state,
       plugins: Object.fromEntries(
         TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [
           name,
@@ -534,6 +549,23 @@ class OnchainSDK extends ChainContractsRegister {
     const [routerAddr, routerV] = routerEntry;
     return createRouter(this, routerAddr, routerV);
   }
+  /**
+   * Withdrawal compressor contract for the current chain, or `undefined`
+   * when no withdrawal compressor is supported on it.
+   **/
+  get withdrawalCompressor() {
+    return this.#withdrawalCompressor;
+  }
+  /**
+   * `RedemptionLogger` contract for the current chain, or `undefined` when
+   * it is not deployed on it. Created lazily on first access: the contract
+   * is resolved from the address provider, which is only available after
+   * the SDK is attached or hydrated.
+   **/
+  get redemptionLogger() {
+    this.#redemptionLogger ??= createRedemptionLogger(this);
+    return this.#redemptionLogger;
+  }
 }
 export {
   OnchainSDK,