@gearbox-protocol/sdk 14.11.3 → 14.12.0-next.10

package/dist/esm/plugins/adapters/contracts/MidasRedemptionVaultAdapterContract.js

@@ -2,7 +2,9 @@ import {
   iMidasRedemptionVaultAdapterAbi,
   iMidasRedemptionVaultGatewayAbi
 } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -59,6 +61,18 @@ class MidasRedemptionVaultAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      // redemption spends the mToken down to the leftover, tokenOut arg is
+      // the received token
+      case "redeemInstantDiff": {
+        const [, leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.mToken, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   MidasRedemptionVaultAdapterContract

package/dist/esm/plugins/adapters/contracts/PendleRouterAdapterContract.js

@@ -1,5 +1,7 @@
 import { iPendleRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -94,6 +96,64 @@ class PendleRouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapDiffTokenForPt":
+      case "addLiquiditySingleTokenDiff": {
+        const [, , , diffInput] = decoded.args;
+        return [
+          {
+            tokenIn: diffInput.tokenIn,
+            leftoverAmount: diffInput.leftoverTokenIn
+          }
+        ];
+      }
+      case "swapDiffPtForToken": {
+        const [market, leftoverPt] = decoded.args;
+        const pt = this.#mustFindPendleToken(market, 0 /* PT */);
+        return [{ tokenIn: pt, leftoverAmount: leftoverPt }];
+      }
+      case "removeLiquiditySingleTokenDiff": {
+        const [market, leftoverLp] = decoded.args;
+        const lp = this.#mustFindPendleToken(market, 1 /* LP */);
+        return [{ tokenIn: lp, leftoverAmount: leftoverLp }];
+      }
+      case "redeemDiffPyToToken": {
+        const candidates = this.allowedPairs.filter(
+          (p) => (p.pendleTokenType === void 0 || p.pendleTokenType === 0 /* PT */) && (balances.get(p.pendleToken) ?? 0n) > 1n
+        );
+        const ptTokens = new Set(
+          candidates.map((p) => p.pendleToken.toLowerCase())
+        );
+        if (ptTokens.size !== 1) {
+          throw new Error(
+            `cannot recover PT token for redeemDiffPyToToken on pendle adapter at ${this.address}: ${ptTokens.size} candidates`
+          );
+        }
+        const [, leftoverPt] = decoded.args;
+        return [
+          {
+            tokenIn: candidates[0].pendleToken,
+            leftoverAmount: leftoverPt
+          }
+        ];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
+  #mustFindPendleToken(market, type) {
+    const marketLC = market.toLowerCase();
+    const pair = this.allowedPairs.find(
+      (p) => p.market.toLowerCase() === marketLC && (p.pendleTokenType === void 0 || p.pendleTokenType === type)
+    );
+    if (!pair) {
+      throw new Error(
+        `pendle pair for market ${market} not found on adapter at ${this.address}`
+      );
+    }
+    return pair.pendleToken;
+  }
 }
 export {
   PendlePairStatus,

package/dist/esm/plugins/adapters/contracts/SecuritizeOnRampAdapterContract.js

@@ -1,4 +1,6 @@
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -43,6 +45,17 @@ class SecuritizeOnRampAdapterContract extends AbstractAdapterContract {
       liquidityToken: this.#liquidityToken ? this.labelAddress(this.#liquidityToken) : void 0
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      // swaps the liquidity token into dsToken
+      case "swapDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.liquidityToken, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   SecuritizeOnRampAdapterContract

package/dist/esm/plugins/adapters/contracts/SecuritizeSwapAdapterContract.js

@@ -1,9 +1,21 @@
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-const abi = [];
+const abi = [
+  {
+    type: "function",
+    name: "buyExactInDiff",
+    inputs: [
+      { name: "leftoverAmount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
 const protocolAbi = [];
 class SecuritizeSwapAdapterContract extends AbstractAdapterContract {
   #dsToken;
@@ -40,6 +52,17 @@ class SecuritizeSwapAdapterContract extends AbstractAdapterContract {
       stableCoinToken: this.#stableCoinToken ? this.labelAddress(this.#stableCoinToken) : void 0
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      // buys dsToken with the stablecoin
+      case "buyExactInDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.stableCoinToken, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   SecuritizeSwapAdapterContract

package/dist/esm/plugins/adapters/contracts/StakingRewardsAdapterContract.js

@@ -1,5 +1,7 @@
 import { iStakingRewardsAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -79,6 +81,23 @@ class StakingRewardsAdapterContract extends AbstractAdapterContract {
       referral: this.#referral
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "stakeDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.stakingToken, leftoverAmount }];
+      }
+      case "withdrawDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.stakedPhantomToken, leftoverAmount }];
+      }
+      // no accrued rewards on a freshly opened account
+      case "getReward":
+        return [];
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   StakingRewardsAdapterContract

package/dist/esm/plugins/adapters/contracts/TraderJoeRouterAdapterContract.js

@@ -1,5 +1,7 @@
 import { iTraderJoeRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import { MissingSerializedParamsError } from "../../../sdk/index.js";
 import { iTraderJoeRouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -58,6 +60,16 @@ class TraderJoeRouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapDiffTokensForTokens": {
+        const [leftoverAmount, , path] = decoded.args;
+        return [{ tokenIn: path.tokenPath[0], leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   TraderJoePoolVersion,

package/dist/esm/plugins/adapters/contracts/UniswapV2AdapterContract.js

@@ -72,6 +72,16 @@ class UniswapV2AdapterContract extends AbstractAdapterContract {
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "UniswapSwap", ...swapFromTransfers(transfers) };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapDiffTokensForTokens": {
+        const [leftoverAmount, , path] = decoded.args;
+        return [{ tokenIn: path[0], leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   UniswapV2AdapterContract

package/dist/esm/plugins/adapters/contracts/UniswapV3AdapterContract.js

@@ -50,6 +50,26 @@ class UniswapV3AdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "exactDiffInputSingle": {
+        const [params] = decoded.args;
+        return [
+          {
+            tokenIn: params.tokenIn,
+            leftoverAmount: params.leftoverAmount
+          }
+        ];
+      }
+      case "exactDiffInput": {
+        const [params] = decoded.args;
+        const tokenIn = `0x${params.path.replace("0x", "").slice(0, 40)}`;
+        return [{ tokenIn, leftoverAmount: params.leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
   stringifyFunctionParams(params) {
     switch (params.functionName) {
       case "exactInputSingle": {

package/dist/esm/plugins/adapters/contracts/UniswapV4AdapterContract.js

@@ -2,7 +2,9 @@ import {
   iUniswapV4AdapterAbi,
   iUniswapV4GatewayAbi
 } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import { MissingSerializedParamsError } from "../../../sdk/index.js";
 import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -61,6 +63,21 @@ class UniswapV4AdapterContract extends AbstractAdapterContract {
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "UniswapSwap", ...swapFromTransfers(transfers) };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapExactInputSingleDiff": {
+        const [poolKey, zeroForOne, leftoverAmount] = decoded.args;
+        return [
+          {
+            tokenIn: zeroForOne ? poolKey.token0 : poolKey.token1,
+            leftoverAmount
+          }
+        ];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   UniswapV4AdapterContract

package/dist/esm/plugins/adapters/contracts/UpshiftVaultAdapterContract.js

@@ -2,7 +2,9 @@ import {
   iUpshiftVaultAdapterAbi,
   iUpshiftVaultGatewayAbi
 } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -52,6 +54,20 @@ class UpshiftVaultAdapterContract extends AbstractAdapterContract {
       stakedPhantomToken: this.#stakedPhantomToken ? this.labelAddress(this.#stakedPhantomToken) : void 0
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "depositDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.asset, leftoverAmount }];
+      }
+      case "redeemDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.vault, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   UpshiftVaultAdapterContract

package/dist/esm/plugins/adapters/contracts/VelodromeV2AdapterContract.js

@@ -1,5 +1,7 @@
 import { iVelodromeV2RouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import { MissingSerializedParamsError } from "../../../sdk/index.js";
 import { iVelodromeV2RouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -51,6 +53,16 @@ class VelodromeV2RouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapDiffTokensForTokens": {
+        const [leftoverAmount, , routes] = decoded.args;
+        return [{ tokenIn: routes[0].from, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   VelodromeV2RouterAdapterContract

package/dist/esm/plugins/adapters/contracts/WstETHV1AdapterContract.js

@@ -1,5 +1,7 @@
 import { iwstEthv1AdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -44,6 +46,21 @@ class WstETHV1AdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "wrapDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.stETH, leftoverAmount }];
+      }
+      // wstETH is the adapter's target contract
+      case "unwrapDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.targetContract, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   WstETHV1AdapterContract

package/dist/esm/preview/index.js

@@ -0,0 +1,3 @@
+export * from "./prerequisites/index.js";
+export * from "./preview/index.js";
+export * from "./trace/index.js";

package/dist/esm/preview/package.json

@@ -0,0 +1 @@
+{"type": "module","sideEffects":false}

package/dist/esm/preview/parse/classifyInnerOperations.js

@@ -0,0 +1,81 @@
+import { AbstractAdapterContract } from "../../plugins/adapters/index.js";
+function classifyInnerOperations(calls, props) {
+  const { sdk, underlying } = props;
+  const result = [];
+  for (const call of calls) {
+    const contract = sdk.getContract(call.target);
+    if (contract instanceof AbstractAdapterContract || contract === void 0) {
+      result.push({
+        operation: "Execute",
+        adapter: call.target,
+        adapterType: call.contractType,
+        version: call.version,
+        label: call.label,
+        adapterFunctionName: call.functionName,
+        adapterArgs: call.rawArgs,
+        calldata: call.calldata
+      });
+      continue;
+    }
+    const op = classifyFacadeInnerCall(call, underlying);
+    if (op) {
+      result.push(op);
+    }
+  }
+  return result;
+}
+function classifyFacadeInnerCall(call, underlying) {
+  const functionName = call.functionName.split("(")[0];
+  const { rawArgs } = call;
+  switch (functionName) {
+    case "increaseDebt":
+      return {
+        operation: "IncreaseBorrowedAmount",
+        token: underlying,
+        amount: rawArgs.amount
+      };
+    case "decreaseDebt":
+      return {
+        operation: "DecreaseBorrowedAmount",
+        token: underlying,
+        amount: rawArgs.amount
+      };
+    case "addCollateral":
+    case "addCollateralWithPermit":
+      return {
+        operation: "AddCollateral",
+        token: rawArgs.token,
+        amount: rawArgs.amount
+      };
+    case "withdrawCollateral":
+      return {
+        operation: "WithdrawCollateral",
+        token: rawArgs.token,
+        amount: rawArgs.amount,
+        to: rawArgs.to
+      };
+    case "updateQuota":
+      return {
+        operation: "UpdateQuota",
+        token: rawArgs.token,
+        change: rawArgs.quotaChange
+      };
+    case "storeExpectedBalances": {
+      const balanceDeltas = rawArgs.balanceDeltas;
+      return {
+        operation: "StoreExpectedBalances",
+        deltas: balanceDeltas.map(({ token, amount }) => ({
+          token,
+          balance: amount
+        }))
+      };
+    }
+    case "compareBalances":
+      return { operation: "CompareBalances" };
+    default:
+      return null;
+  }
+}
+export {
+  classifyInnerOperations
+};

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

@@ -0,0 +1,24 @@
+import { UnsupportedZapperFunctionError } from "../../sdk/index.js";
+class UnsupportedTargetError extends Error {
+  target;
+  constructor(target) {
+    super(`unsupported transaction target: ${target}`);
+    this.name = "UnsupportedTargetError";
+    this.target = target;
+  }
+}
+class UnsupportedPoolFunctionError extends Error {
+  pool;
+  functionName;
+  constructor(pool, functionName) {
+    super(`unsupported pool function "${functionName}" on ${pool}`);
+    this.name = "UnsupportedPoolFunctionError";
+    this.pool = pool;
+    this.functionName = functionName;
+  }
+}
+export {
+  UnsupportedPoolFunctionError,
+  UnsupportedTargetError,
+  UnsupportedZapperFunctionError
+};

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

@@ -0,0 +1,7 @@
+export * from "./classifyInnerOperations.js";
+export * from "./errors.js";
+export * from "./parseFacadeOperationCalldata.js";
+export * from "./parseOperationCalldata.js";
+export * from "./parsePoolOperationCalldata.js";
+export * from "./parseRWAFactoryOperationCalldata.js";
+export * from "./types.js";

package/dist/esm/preview/parse/parseFacadeOperationCalldata.js

@@ -0,0 +1,84 @@
+import { isAddressEqual, zeroAddress } from "viem";
+import { classifyInnerOperations } from "./classifyInnerOperations.js";
+function parseFacadeOperationCalldata(props) {
+  const { sdk, facade, calldata } = props;
+  const parsed = sdk.parseFunctionDataV2(facade.address, calldata);
+  const functionName = parsed.functionName.split("(")[0];
+  const { rawArgs } = parsed;
+  const suite = sdk.marketRegister.creditManagers.find(
+    (cm) => isAddressEqual(cm.creditFacade.address, facade.address)
+  );
+  if (!suite) {
+    throw new Error(`no credit suite found for facade ${facade.address}`);
+  }
+  const metadata = {
+    creditManager: suite.creditManager.address,
+    creditFacade: facade.address
+  };
+  const innerCalls = rawArgs.calls ?? [];
+  const multicall = classifyInnerOperations(innerCalls, {
+    sdk,
+    underlying: suite.underlying
+  });
+  switch (functionName) {
+    case "multicall":
+      return {
+        ...metadata,
+        operation: "MultiCall",
+        creditAccount: rawArgs.creditAccount,
+        multicall
+      };
+    case "botMulticall":
+      return {
+        ...metadata,
+        operation: "BotMulticall",
+        creditAccount: rawArgs.creditAccount,
+        multicall
+      };
+    case "openCreditAccount":
+      return {
+        ...metadata,
+        operation: "OpenCreditAccount",
+        creditAccount: zeroAddress,
+        onBehalfOf: rawArgs.onBehalfOf,
+        referralCode: rawArgs.referralCode,
+        multicall
+      };
+    case "closeCreditAccount":
+      return {
+        ...metadata,
+        operation: "CloseCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        multicall
+      };
+    case "liquidateCreditAccount":
+      return {
+        ...metadata,
+        operation: "LiquidateCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        to: rawArgs.to,
+        // `token` and `remainingFunds` are only emitted on-chain during
+        // liquidation, so they are not recoverable from raw calldata.
+        token: zeroAddress,
+        remainingFunds: 0n,
+        multicall
+      };
+    case "partiallyLiquidateCreditAccount":
+      return {
+        ...metadata,
+        operation: "PartiallyLiquidateCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        token: rawArgs.token,
+        repaidAmount: rawArgs.repaidAmount,
+        minSeizedAmount: rawArgs.minSeizedAmount,
+        to: rawArgs.to
+      };
+    default:
+      throw new Error(
+        `unsupported credit facade function "${parsed.functionName}" on ${facade.address}`
+      );
+  }
+}
+export {
+  parseFacadeOperationCalldata
+};

package/dist/esm/preview/parse/parseOperationCalldata.js

@@ -0,0 +1,66 @@
+import {
+  CreditFacadeV310Contract,
+  isRWAFactory,
+  PoolV310Contract,
+  ZapperContract
+} from "../../sdk/index.js";
+import { UnsupportedTargetError } from "./errors.js";
+import { parseFacadeOperationCalldata } from "./parseFacadeOperationCalldata.js";
+import { parsePoolOperationCalldata } from "./parsePoolOperationCalldata.js";
+import { parseRWAFactoryOperationCalldata } from "./parseRWAFactoryOperationCalldata.js";
+function parseOperationCalldata(input) {
+  const { sdk, to, calldata, value, sender } = input;
+  const contract = sdk.getContract(to);
+  if (contract instanceof PoolV310Contract) {
+    return parsePoolOperationCalldata({ sdk, pool: contract, calldata });
+  }
+  if (contract instanceof ZapperContract) {
+    const parsed = contract.parseOperation(calldata, value);
+    if (parsed.operation === "Deposit") {
+      const op2 = {
+        operation: "Deposit",
+        pool: parsed.pool,
+        receiver: parsed.receiver,
+        assets: parsed.assets,
+        underlying: parsed.underlying,
+        tokenIn: contract.tokenIn.addr,
+        tokenOut: contract.tokenOut.addr,
+        zapper: parsed.zapper,
+        referralCode: parsed.referralCode
+      };
+      return op2;
+    }
+    const op = {
+      operation: "Redeem",
+      pool: parsed.pool,
+      receiver: parsed.receiver,
+      // The zapper burns the caller's share tokens, so the share owner is the
+      // transaction sender.
+      owner: sender,
+      shares: parsed.shares,
+      underlying: parsed.underlying,
+      tokenIn: contract.tokenOut.addr,
+      tokenOut: contract.tokenIn.addr,
+      zapper: parsed.zapper
+    };
+    return op;
+  }
+  if (contract instanceof CreditFacadeV310Contract) {
+    return parseFacadeOperationCalldata({
+      sdk,
+      facade: contract,
+      calldata
+    });
+  }
+  if (contract && isRWAFactory(contract)) {
+    return parseRWAFactoryOperationCalldata({
+      sdk,
+      factory: contract,
+      calldata
+    });
+  }
+  throw new UnsupportedTargetError(to);
+}
+export {
+  parseOperationCalldata
+};