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

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

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

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

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

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

@@ -0,0 +1,130 @@
+import { iPoolV310Abi } from "../../abi/310/generated.js";
+import { ierc20Abi } from "../../abi/iERC20.js";
+import { AddressMap } from "../../sdk/index.js";
+import { decodeSimulationError, PreviewSimulationError } from "./errors.js";
+import { watchedHolders } from "./holders.js";
+function previewRead(operation) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { functionName: "previewDeposit", amount: operation.assets };
+    case "Mint":
+      return { functionName: "previewMint", amount: operation.shares };
+    case "Withdraw":
+      return { functionName: "previewWithdraw", amount: operation.assets };
+    case "Redeem":
+      return { functionName: "previewRedeem", amount: operation.shares };
+  }
+}
+async function simulatePoolOpMulticall(input, options = {}) {
+  const { sdk, operation, wallet } = input;
+  const { blockNumber } = options;
+  const { underlying, pool } = operation;
+  const holders = watchedHolders(operation, wallet);
+  const tokens = [underlying, 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 { functionName, amount } = previewRead(operation);
+  const previewContract = {
+    address: pool,
+    abi: iPoolV310Abi,
+    functionName,
+    args: [amount]
+  };
+  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, previewContract]
+    });
+  } 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 {
+    balanceChanges: computePoolOpBalanceChanges(
+      operation,
+      wallet,
+      previewAmount,
+      before
+    ),
+    transfers: void 0
+  };
+}
+function balanceLegs(operation, wallet, previewAmount) {
+  const { underlying, pool, receiver } = operation;
+  switch (operation.operation) {
+    case "Deposit":
+      return [
+        { address: wallet, token: underlying, delta: -operation.assets },
+        { address: receiver, token: pool, delta: previewAmount }
+      ];
+    case "Mint":
+      return [
+        { address: wallet, token: underlying, delta: -previewAmount },
+        { address: receiver, token: pool, delta: operation.shares }
+      ];
+    case "Withdraw":
+      return [
+        { address: operation.owner, token: pool, delta: -previewAmount },
+        { address: receiver, token: underlying, delta: operation.assets }
+      ];
+    case "Redeem":
+      return [
+        { address: operation.owner, token: pool, delta: -operation.shares },
+        { address: receiver, token: underlying, delta: 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] });
+    }
+  }
+  return byAddress.values();
+}
+export {
+  computePoolOpBalanceChanges,
+  simulatePoolOpMulticall
+};

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

@@ -0,0 +1,82 @@
+import { simulateCalls } from "viem/actions";
+import { ierc20Abi } from "../../abi/iERC20.js";
+import { decodeSimulationError, PreviewSimulationError } from "./errors.js";
+import { extractERC20Transfers } from "./extractERC20Transfers.js";
+import { watchedHolders } from "./holders.js";
+async function simulatePoolOpV1(input, options = {}) {
+  const { sdk, operation, to, calldata, wallet } = input;
+  const { blockNumber } = options;
+  const { underlying, pool } = operation;
+  const holders = watchedHolders(operation, wallet);
+  const tokens = [underlying, pool];
+  const balanceOf = (token, holder) => ({
+    to: token,
+    abi: ierc20Abi,
+    functionName: "balanceOf",
+    args: [holder]
+  });
+  const balanceCalls = holders.flatMap(
+    (holder) => tokens.map((token) => balanceOf(token, holder))
+  );
+  let results;
+  try {
+    ({ results } = await simulateCalls(sdk.client, {
+      account: wallet,
+      // `undefined` lets viem simulate at `latest`; `blockNumber` is only set
+      // for testnet forks pinned to a specific block.
+      blockNumber,
+      calls: [...balanceCalls, { to, data: calldata }, ...balanceCalls]
+    }));
+  } catch (cause) {
+    throw new PreviewSimulationError([
+      {
+        source: "eth_simulateV1",
+        detail: decodeSimulationError({
+          error: cause instanceof Error ? cause : new Error(String(cause))
+        })
+      }
+    ]);
+  }
+  const sim = results;
+  const txIndex = balanceCalls.length;
+  const afterOffset = txIndex + 1;
+  const txResult = sim[txIndex];
+  if (!txResult || txResult.status === "failure") {
+    throw new PreviewSimulationError([
+      {
+        source: "eth_simulateV1",
+        detail: decodeSimulationError({
+          error: txResult?.error,
+          data: txResult?.data
+        })
+      }
+    ]);
+  }
+  const balanceChanges = [];
+  for (const [holderIndex, address] of holders.entries()) {
+    const changes = [];
+    for (const [tokenIndex, token] of tokens.entries()) {
+      const slot = holderIndex * tokens.length + tokenIndex;
+      const before = readBalance(sim[slot]);
+      const after = readBalance(sim[afterOffset + slot]);
+      const delta = after - before;
+      const magnitude = delta >= 0n ? delta : -delta;
+      if (magnitude > 1n) {
+        changes.push({ token, before, after, delta });
+      }
+    }
+    if (changes.length > 0) {
+      balanceChanges.push({ address, changes });
+    }
+  }
+  return {
+    transfers: extractERC20Transfers(txResult.logs ?? [], holders),
+    balanceChanges
+  };
+}
+function readBalance(result) {
+  return result?.status === "success" ? result.result : 0n;
+}
+export {
+  simulatePoolOpV1
+};

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

@@ -1,69 +1,40 @@
-import { isAddressEqual } from "viem";
-import { simulateCalls } from "viem/actions";
-import { ierc20Abi } from "../../abi/iERC20.js";
-import { decodeSimulationError } from "./decodeSimulationError.js";
-import { extractERC20Transfers } from "./extractERC20Transfers.js";
-async function simulatePoolOperation(input) {
-  const { sdk, operation, to, calldata, wallet, blockNumber } = input;
-  const { underlying, pool } = operation;
-  const receiverIsWallet = isAddressEqual(operation.receiver, wallet);
-  const holders = receiverIsWallet ? [wallet] : [wallet, operation.receiver];
-  const tokens = [underlying, pool];
-  const balanceOf = (token, holder) => ({
-    to: token,
-    abi: ierc20Abi,
-    functionName: "balanceOf",
-    args: [holder]
-  });
-  const balanceCalls = holders.flatMap(
-    (holder) => tokens.map((token) => balanceOf(token, holder))
+import { ETH_SIMULATE_V1_NETWORKS } from "./constants.js";
+import {
+  asPreviewSimulationError,
+  combinePreviewSimulationErrors
+} from "./errors.js";
+import { simulatePoolOpMulticall } from "./simulatePoolOpMulticall.js";
+import { simulatePoolOpV1 } from "./simulatePoolOpV1.js";
+async function simulatePoolOperation(input, options = {}) {
+  const { sdk } = input;
+  const { logger } = options;
+  const useSimulateV1 = options.useSimulateV1 ?? ETH_SIMULATE_V1_NETWORKS.has(sdk.networkType);
+  logger?.debug(
+    { wallet: input.wallet, to: input.to },
+    "simulating pool operation"
   );
-  const { results } = await simulateCalls(sdk.client, {
-    account: wallet,
-    // `undefined` lets viem simulate at `latest`; `blockNumber` is only set for
-    // testnet forks pinned to a specific block.
-    blockNumber,
-    calls: [...balanceCalls, { to, data: calldata }, ...balanceCalls]
-  });
-  const sim = results;
-  const txIndex = balanceCalls.length;
-  const afterOffset = txIndex + 1;
-  const txResult = sim[txIndex];
-  if (!txResult || txResult.status === "failure") {
-    return {
-      status: "failure",
-      error: decodeSimulationError({
-        error: txResult?.error,
-        data: txResult?.data
-      })
-    };
+  const [v1, multicall] = await Promise.allSettled([
+    useSimulateV1 ? simulatePoolOpV1(input, options) : void 0,
+    simulatePoolOpMulticall(input, options)
+  ]);
+  if (v1.status === "fulfilled" && v1.value) {
+    return { status: "success", ...v1.value };
   }
-  const balanceChanges = [];
-  for (const [holderIndex, address] of holders.entries()) {
-    const changes = [];
-    for (const [tokenIndex, token] of tokens.entries()) {
-      const slot = holderIndex * tokens.length + tokenIndex;
-      const before = readBalance(sim[slot]);
-      const after = readBalance(sim[afterOffset + slot]);
-      const delta = after - before;
-      const magnitude = delta >= 0n ? delta : -delta;
-      if (magnitude > 1n) {
-        changes.push({ token, before, after, delta });
-      }
-    }
-    if (changes.length > 0) {
-      balanceChanges.push({ address, changes });
+  if (multicall.status === "fulfilled") {
+    if (v1.status === "rejected") {
+      logger?.debug(
+        asPreviewSimulationError(v1.reason, "eth_simulateV1"),
+        "eth_simulateV1 flow failed; falling back to multicall result"
+      );
     }
+    return { status: "success", ...multicall.value };
   }
-  return {
-    status: "success",
-    transfers: extractERC20Transfers(txResult.logs ?? [], holders),
-    balanceChanges,
-    gasUsed: txResult.gasUsed
-  };
-}
-function readBalance(result) {
-  return result?.status === "success" ? result.result : 0n;
+  const error = combinePreviewSimulationErrors(
+    v1.status === "rejected" ? asPreviewSimulationError(v1.reason, "eth_simulateV1") : void 0,
+    asPreviewSimulationError(multicall.reason, "multicall")
+  );
+  logger?.error(error, "pool operation simulation failed");
+  return { status: "failure", error };
 }
 export {
   simulatePoolOperation

package/dist/esm/{history → preview/trace}/errors.js

@@ -22,28 +22,6 @@ class WithdrawCollateralAlignmentError extends Error {
     this.name = "WithdrawCollateralAlignmentError";
   }
 }
-class ProtocolCallNotFoundError extends Error {
-  targetContract;
-  executeIndex;
-  constructor(targetContract, executeIndex) {
-    super(
-      `protocol call to ${targetContract} not found in trace for Execute #${executeIndex}`
-    );
-    this.name = "ProtocolCallNotFoundError";
-    this.targetContract = targetContract;
-    this.executeIndex = executeIndex;
-  }
-}
-class AdapterTraceAlignmentError extends Error {
-  constructor(expected, actual) {
-    super(`found ${actual} adapter traces for ${expected} execute events`);
-    this.expected = expected;
-    this.actual = actual;
-    this.name = "AdapterTracesAlignmentError";
-  }
-  expected;
-  actual;
-}
 class UnexpectedFacadeEventOrderError extends Error {
   constructor(e) {
     super(
@@ -63,8 +41,6 @@ class UnknownFacadeCallError extends Error {
   }
 }
 export {
-  AdapterTraceAlignmentError,
-  ProtocolCallNotFoundError,
   TransferAlignmentError,
   UnexpectedFacadeEventOrderError,
   UnknownAdapterError,

package/dist/esm/preview/trace/extractAdapterCallTraces.js

@@ -0,0 +1,40 @@
+import {
+  decodeAbiParameters,
+  isAddressEqual,
+  toFunctionSelector
+} from "viem";
+import {
+  resolveProtocolCall
+} from "../../common-utils/utils/trace.js";
+const WITHDRAW_PHANTOM_TOKEN_SELECTOR = toFunctionSelector(
+  "withdrawPhantomToken(address,uint256)"
+);
+const GET_PHANTOM_TOKEN_INFO_SELECTOR = toFunctionSelector(
+  "getPhantomTokenInfo()"
+);
+function isSynthesizedPhantomWithdrawal(siblings, index) {
+  const node = siblings[index];
+  if (node.type !== "CALL" || node.input.slice(0, 10).toLowerCase() !== WITHDRAW_PHANTOM_TOKEN_SELECTOR) {
+    return false;
+  }
+  const [token] = decodeAbiParameters(
+    [{ type: "address" }, { type: "uint256" }],
+    `0x${node.input.slice(10)}`
+  );
+  for (let i = 0; i < index; i++) {
+    const sib = siblings[i];
+    if (sib.type === "STATICCALL" && sib.input.slice(0, 10).toLowerCase() === GET_PHANTOM_TOKEN_INFO_SELECTOR && isAddressEqual(sib.to, token)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractAdapterCallTraces(facadeTrace) {
+  const subtraces = facadeTrace.calls ?? [];
+  return subtraces.filter(
+    (sub, index) => resolveProtocolCall(sub) !== void 0 && !isSynthesizedPhantomWithdrawal(subtraces, index)
+  );
+}
+export {
+  extractAdapterCallTraces
+};

package/dist/esm/{history → preview/trace}/extractTransfers.js

@@ -3,14 +3,14 @@ import {
   isAddressEqual,
   parseEventLogs
 } from "viem";
-import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
-import { ierc20Abi } from "../abi/iERC20.js";
-import { AddressMap } from "../sdk/index.js";
+import { iCreditFacadeV310Abi } from "../../abi/310/generated.js";
+import { ierc20Abi } from "../../abi/iERC20.js";
+import { AddressMap } from "../../sdk/index.js";
 import { UnexpectedFacadeEventOrderError } from "./errors.js";
 function extractTransfers(logs, creditAccount, pool, creditFacade) {
   const ranges = buildOperationRanges(logs, creditFacade, creditAccount);
   let currentEntries = [];
-  const executeResults = [];
+  const executeTransfers = [];
   const directTransfers = [];
   const phantomTokens = new AddressMap();
   const withdrawCollateralEvents = [];
@@ -19,20 +19,17 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
     const facadeEvent = tryDecodeFacadeEvent(log, creditFacade);
     if (facadeEvent) {
       if (isExecute(facadeEvent, creditAccount)) {
-        executeResults.push({
-          transfers: currentEntries,
-          targetContract: facadeEvent.args.targetContract
-        });
+        executeTransfers.push(currentEntries);
       } else if (isLiquidation(facadeEvent, creditAccount)) {
         liquidationRemainingFunds = facadeEvent.args.remainingFunds;
       } else if (isWithdrawPhantomToken(facadeEvent, creditAccount)) {
-        const phantomExec = executeResults.pop();
-        if (!phantomExec) {
+        const phantomTransfers = executeTransfers.pop();
+        if (!phantomTransfers) {
           throw new Error(
             `WithdrawPhantomToken without preceding Execute at logIndex ${facadeEvent.logIndex}`
           );
         }
-        const rawDeposit = phantomExec.transfers.find(
+        const rawDeposit = phantomTransfers.find(
           (t) => isAddressEqual(t.to, creditAccount)
         );
         if (!rawDeposit) {
@@ -67,11 +64,11 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
       currentEntries.push({ token, amount: value, from, to });
     }
     if (isAddressEqual(to, creditAccount) && !isInRange(log.logIndex, ranges)) {
-      directTransfers.push({ token, from, amount: value });
+      directTransfers.push({ token, amount: value, from, to });
     }
   }
   return {
-    executeResults,
+    executeTransfers,
     directTransfers,
     liquidationRemainingFunds,
     phantomTokens,

package/dist/esm/{history → preview/trace}/findFacadeCalls.js

@@ -2,9 +2,11 @@ import {
   decodeFunctionResult,
   isAddressEqual
 } from "viem";
-import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
+import { iCreditFacadeV310Abi } from "../../abi/310/generated.js";
+import {
+  collectTraces
+} from "../../common-utils/utils/trace.js";
 import { UnknownFacadeCallError } from "./errors.js";
-import { collectTraces } from "./trace-utils.js";
 const FACADE_CALL_TYPES = {
   multicall: "MultiCall",
   botMulticall: "BotMulticall",

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

@@ -0,0 +1,5 @@
+export * from "./errors.js";
+export * from "./extractAdapterCallTraces.js";
+export * from "./extractTransfers.js";
+export * from "./findFacadeCalls.js";
+export * from "./types.js";

package/dist/esm/rewards/rewards/api.js

@@ -11,7 +11,8 @@ class RewardAmountAPI {
     pools,
     account,
     network,
-    reportError
+    reportError,
+    apiKey
   }) {
     const [merkleXYZLMResponse] = await Promise.allSettled([
       MerkleXYZApi.fetchWithFallback(
@@ -20,7 +21,8 @@ class RewardAmountAPI {
             chainId: chains[network].id,
             user: getAddress(account)
           }
-        })
+        }),
+        apiKey
       )
     ]);
     const merkleXYZLm = RewardAmountAPI.extractFulfilled(

package/dist/esm/rewards/rewards/merkl-api.js

@@ -4,11 +4,17 @@ class MerkleXYZApi {
   }
   static defaultDomain = "https://api.merkl.xyz";
   static angleDomain = "https://api-merkl.angle.money";
-  static fetchWithFallback = async (getUrl) => {
+  static apiKeyHeader = "X-API-Key";
+  static fetchWithFallback = async (getUrl, apiKey) => {
+    const headers = apiKey ? { [MerkleXYZApi.apiKeyHeader]: apiKey } : void 0;
     try {
-      return await axios.get(getUrl(MerkleXYZApi.defaultDomain));
+      return await axios.get(getUrl(MerkleXYZApi.defaultDomain), {
+        headers
+      });
     } catch {
-      return await axios.get(getUrl(MerkleXYZApi.angleDomain));
+      return await axios.get(getUrl(MerkleXYZApi.angleDomain), {
+        headers
+      });
     }
   };
   static getUserRewardsUrl = (options) => (domain) => `${domain}/v4/users/${options.params.user}/rewards?chainId=${options.params.chainId}`;