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

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

@@ -0,0 +1,77 @@
+import {
+  AddressMap
+} from "../../sdk/index.js";
+import { extractExpectedBalanceChanges } from "./extractExpectedBalanceChanges.js";
+function previewOpenCreditAccount(input, operation) {
+  const { sdk, to, calldata } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const collateralByToken = new AddressMap();
+  const balances = new AddressMap();
+  const addBalance = (token, amount) => {
+    balances.upsert(token, (balances.get(token) ?? 0n) + amount);
+  };
+  let debt = 0n;
+  const quotas = [];
+  for (const op of operation.multicall) {
+    switch (op.operation) {
+      case "AddCollateral": {
+        const balance = collateralByToken.get(op.token)?.balance ?? 0n;
+        collateralByToken.upsert(op.token, {
+          token: op.token,
+          balance: balance + op.amount
+        });
+        addBalance(op.token, op.amount);
+        break;
+      }
+      case "WithdrawCollateral":
+        addBalance(op.token, -op.amount);
+        break;
+      case "IncreaseBorrowedAmount":
+        debt += op.amount;
+        addBalance(op.token, op.amount);
+        break;
+      case "DecreaseBorrowedAmount":
+        debt -= op.amount;
+        addBalance(op.token, -op.amount);
+        break;
+      case "UpdateQuota":
+        quotas.push({ token: op.token, balance: op.change });
+        break;
+    }
+  }
+  const collateral = collateralByToken.values();
+  const collateralValue = collateral.reduce(
+    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
+    0n
+  );
+  const parsed = sdk.parseFunctionDataV2(to, calldata);
+  const innerCalls = parsed.rawArgs.calls ?? [];
+  const deltas = extractExpectedBalanceChanges(innerCalls) ?? [];
+  for (const { token, balance } of deltas) {
+    addBalance(token, balance);
+  }
+  const assets = balances.entries().filter(([, balance]) => balance > 1n).map(([token, balance]) => ({ token, balance }));
+  return {
+    operation: operation.operation,
+    target: inferTargetAsset(operation.multicall, balances),
+    collateral,
+    collateralValue,
+    debt,
+    quotas,
+    assets
+  };
+}
+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,17 @@
+import { isPoolOperation, parseOperationCalldata } from "../parse/index.js";
+import { UnsupportedOperationError } from "./errors.js";
+import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
+import { previewPoolOperation } from "./previewPoolOperation.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") {
+    return previewOpenCreditAccount(input, operation);
+  }
+  throw new UnsupportedOperationError(operation.operation);
+}
+export {
+  previewOperation
+};

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

@@ -0,0 +1,53 @@
+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
+  );
+  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 }
+      };
+  }
+}
+export {
+  previewPoolOperation
+};

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,18 @@
-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,60 +30,31 @@ function previewContract(operation) {
     args: [amount]
   };
 }
+function amountsInOut(operation, previewAmount) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { amountIn: operation.assets, amountOut: previewAmount };
+    case "Mint":
+      return { amountIn: previewAmount, amountOut: operation.shares };
+    case "Withdraw":
+      return { amountIn: previewAmount, amountOut: operation.assets };
+    case "Redeem":
+      return { amountIn: operation.shares, amountOut: previewAmount };
+  }
+}
 async function simulatePoolOperation(input, options = {}) {
-  const { sdk, operation, wallet } = input;
+  const { sdk, operation } = 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;
+    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 {
       status: "success",
-      balanceChanges: computePoolOpBalanceChanges(
-        operation,
-        wallet,
-        previewAmount,
-        before
-      )
+      ...amountsInOut(operation, previewAmount)
     };
   } catch (cause) {
     const error = asPreviewSimulationError(cause, "multicall");
@@ -108,59 +62,6 @@ async function simulatePoolOperation(input, options = {}) {
     return { status: "failure", error };
   }
 }
-function balanceLegs(operation, wallet, previewAmount) {
-  const { pool, receiver } = operation;
-  switch (operation.operation) {
-    case "Deposit":
-      return [
-        { address: wallet, token: operation.tokenIn, delta: -operation.assets },
-        { address: receiver, token: pool, delta: previewAmount }
-      ];
-    case "Mint":
-      return [
-        { address: wallet, token: operation.tokenIn, delta: -previewAmount },
-        { address: receiver, token: pool, delta: operation.shares }
-      ];
-    case "Withdraw":
-      return [
-        { address: operation.owner, token: pool, delta: -previewAmount },
-        {
-          address: receiver,
-          token: operation.tokenOut,
-          delta: operation.assets
-        }
-      ];
-    case "Redeem":
-      return [
-        { address: operation.owner, token: pool, delta: -operation.shares },
-        { address: receiver, token: operation.tokenOut, 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,
   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/market/rwa/securitize/SecuritizeRWAFactory.js

@@ -54,17 +54,21 @@ class SecuritizeRWAFactory extends BaseContract {
   parseFunctionParamsV2(params, strict) {
     switch (params.functionName) {
       case "openCreditAccount": {
-        const [creditManager, calls] = params.args;
+        const [creditManager, calls, tokensToRegister, signaturesToCache] = params.args;
         return {
           creditManager,
-          calls: this.register.parseMultiCallV2([...calls], strict)
+          calls: this.register.parseMultiCallV2([...calls], strict),
+          tokensToRegister,
+          signaturesToCache
         };
       }
       case "multicall": {
-        const [creditAccount, calls] = params.args;
+        const [creditAccount, calls, tokensToRegister, signaturesToCache] = params.args;
         return {
           creditAccount,
-          calls: this.register.parseMultiCallV2([...calls], strict)
+          calls: this.register.parseMultiCallV2([...calls], strict),
+          tokensToRegister,
+          signaturesToCache
         };
       }
       default:
@@ -126,6 +130,12 @@ class SecuritizeRWAFactory extends BaseContract {
       })
     };
   }
+  /**
+   * {@inheritDoc IRWAFactory.getTokens}
+   */
+  getTokens() {
+    return this.dsTokens.map((t) => t.address);
+  }
   /**
    * {@inheritDoc IRWAFactory.getInvestor}
    */

package/dist/esm/sdk/market/rwa/types.js

@@ -1,7 +1,10 @@
 import { RWA_FACTORY_SECURITIZE } from "./securitize/index.js";
 const RWA_FACTORY_TYPES = [RWA_FACTORY_SECURITIZE];
-function isRWAFactory(factory, type) {
-  return factory.contractType === type;
+function isRWAFactory(contract, type) {
+  if (type) {
+    return contract.contractType === type;
+  }
+  return contract.contractType.startsWith("RWA_FACTORY::");
 }
 export {
   RWA_FACTORY_TYPES,

package/dist/esm/sdk/market/zapper/ZapperContract.js

@@ -32,7 +32,6 @@ class ZapperContract extends BaseContract {
     const { rawArgs } = parsed;
     const pool = this.pool;
     const zapper = this.address;
-    const token = this.tokenIn.addr;
     const underlying = this.sdk.marketRegister.findByPool(pool).underlying;
     const receiver = rawArgs.receiver;
     if (parsed.functionName.startsWith("deposit")) {
@@ -42,7 +41,6 @@ class ZapperContract extends BaseContract {
         zapper,
         receiver,
         assets: rawArgs.tokenInAmount ?? value ?? 0n,
-        token,
         underlying,
         referralCode: rawArgs.referralCode
       };
@@ -54,7 +52,6 @@ class ZapperContract extends BaseContract {
         zapper,
         receiver,
         shares: rawArgs.tokenOutAmount,
-        token,
         underlying
       };
     }

package/dist/types/history/types.d.ts

@@ -18,10 +18,10 @@ export type HistoryAdapterExt = TraceAdapterExt & {
 export type HistoryFacadeMetadata = FacadeOperationMetadata & OperationMetadata;
 export type AdapterOperation = BaseAdapterOperation<HistoryAdapterExt>;
 export type InnerOperation = BaseInnerOperation<HistoryAdapterExt>;
-export type MulticallOperation = Omit<BaseMulticallOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type OpenCreditAccountOperation = Omit<BaseOpenCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type CloseCreditAccountOperation = Omit<BaseCloseCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type LiquidateCreditAccountOperation = Omit<BaseLiquidateCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
+export type MulticallOperation = BaseMulticallOperation<HistoryAdapterExt> & OperationMetadata;
+export type OpenCreditAccountOperation = BaseOpenCreditAccountOperation<HistoryAdapterExt> & OperationMetadata;
+export type CloseCreditAccountOperation = BaseCloseCreditAccountOperation<HistoryAdapterExt> & OperationMetadata;
+export type LiquidateCreditAccountOperation = BaseLiquidateCreditAccountOperation<HistoryAdapterExt> & OperationMetadata;
 export type PartialLiquidationOperation = BasePartialLiquidationOperation & OperationMetadata;
 export type DirectTokenTransferOperation = BaseDirectTokenTransferOperation & OperationMetadata;
 export type OuterFacadeOperation = MulticallOperation | OpenCreditAccountOperation | CloseCreditAccountOperation | LiquidateCreditAccountOperation | PartialLiquidationOperation;

package/dist/types/preview/index.d.ts

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

package/dist/types/preview/parse/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./classifyInnerOperations.js";
 export * from "./errors.js";
-export * from "./extractExpectedBalanceChanges.js";
 export * from "./parseFacadeOperationCalldata.js";
 export * from "./parseOperationCalldata.js";
 export * from "./parsePoolOperationCalldata.js";

package/dist/types/preview/parse/parseRWAFactoryOperationCalldata.d.ts

@@ -1,23 +1,22 @@
-import { type Hex } from "viem";
-import { type OnchainSDK, type SecuritizeRWAFactory } from "../../sdk/index.js";
-import type { OuterFacadeOperation } from "./types.js";
+import type { Hex } from "viem";
+import { type IRWAFactory, type OnchainSDK } from "../../sdk/index.js";
+import type { RWAOperation } from "./types-rwa.js";
 export interface ParseRWAFactoryOperationCalldataProps {
     sdk: OnchainSDK;
     /** Resolved RWA factory contract for the transaction target. */
-    factory: SecuritizeRWAFactory;
+    factory: IRWAFactory;
     calldata: Hex;
 }
 /**
  * Decodes a RWA-factory entry-point call into the matching
- * {@link OuterFacadeOperation}.
+ * {@link RWAOperation}.
  *
  * RWA credit accounts are opened and managed through the market's RWA factory
- * (see `CreditAccountsServiceV310`) rather than the credit facade, but the inner
- * `calls` share the credit-facade multicall shape, so classification is
+ * (see `CreditAccountsServiceV310`) rather than the credit facade, but the
+ * inner `calls` share the credit-facade multicall shape, so classification is
  * identical to {@link parseFacadeOperationCalldata}.
  *
- * The RWA factory calldata does not carry `onBehalfOf`, `referralCode` or the
- * new account address (all derived on-chain), so those are left as
- * `zeroAddress`/`0n`.
+ * Dispatches on the factory's contract type; supporting a new factory type
+ * requires a new branch here plus new operation types in `types-rwa.ts`.
  */
-export declare function parseRWAFactoryOperationCalldata(props: ParseRWAFactoryOperationCalldataProps): OuterFacadeOperation;
+export declare function parseRWAFactoryOperationCalldata(props: ParseRWAFactoryOperationCalldataProps): RWAOperation;

package/dist/types/preview/parse/types-facades.d.ts

@@ -71,25 +71,10 @@ export interface FacadeOperationMetadata {
     creditManager: Address;
     creditFacade: Address;
 }
-/**
- * Signed token balance delta recovered from a router-generated
- * `storeExpectedBalances` call (the `BalanceDelta` struct). `amount` is the
- * signed `int256` delta, so it may be negative.
- */
-export interface ExpectedBalanceChange {
-    token: Address;
-    delta: bigint;
-}
 export interface MulticallOperation<Ext extends object = {}> extends FacadeOperationMetadata {
     operation: "MultiCall" | "BotMulticall";
     creditAccount: Address;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
 }
 export interface OpenCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
     operation: "OpenCreditAccount";
@@ -97,23 +82,11 @@ export interface OpenCreditAccountOperation<Ext extends object = {}> extends Fac
     onBehalfOf: Address;
     referralCode: bigint;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
 }
 export interface CloseCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
     operation: "CloseCreditAccount";
     creditAccount: Address;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
 }
 export interface LiquidateCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
     operation: "LiquidateCreditAccount";
@@ -122,12 +95,6 @@ export interface LiquidateCreditAccountOperation<Ext extends object = {}> extend
     token: Address;
     remainingFunds: bigint;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
 }
 export interface PartialLiquidationOperation extends FacadeOperationMetadata {
     operation: "PartiallyLiquidateCreditAccount";

package/dist/types/preview/parse/types-pools.d.ts

@@ -23,6 +23,12 @@ export interface PoolDepositOperation {
      * deposits, or the zapper's input token for zapper-routed deposits.
      */
     tokenIn: Address;
+    /**
+     * Token minted to the receiver: the pool's diesel token for direct
+     * deposits, or the zapper's output token (e.g. a farmed/staked diesel
+     * wrapper) for zapper-routed deposits.
+     */
+    tokenOut: Address;
     /** Zapper contract the call is sent to; `undefined` for direct deposits. */
     zapper?: Address;
     /** Referral code, present only for `depositWithReferral` calls. */
@@ -48,6 +54,11 @@ export interface PoolMintOperation {
      * mints, or the zapper's input token for zapper-routed mints.
      */
     tokenIn: Address;
+    /**
+     * Token minted to the receiver: the pool's diesel token for direct mints,
+     * or the zapper's output token for zapper-routed mints.
+     */
+    tokenOut: Address;
     /** Zapper contract the call is sent to; `undefined` for direct mints. */
     zapper?: Address;
     /** Referral code, present only for `mintWithReferral` calls. */
@@ -71,6 +82,12 @@ export interface PoolWithdrawOperation {
     assets: bigint;
     /** Underlying token of the source pool. */
     underlying: Address;
+    /**
+     * Token burned from `owner`: the pool's diesel token for direct
+     * withdrawals, or the zapper's share-side token for zapper-routed
+     * withdrawals.
+     */
+    tokenIn: Address;
     /**
      * Token actually returned to the receiver: the pool underlying for direct
      * withdrawals, or the zapper's output token for zapper-routed withdrawals.
@@ -95,10 +112,20 @@ export interface PoolRedeemOperation {
     receiver: Address;
     /** Address whose pool shares are burned. */
     owner: Address;
-    /** Pool shares (diesel) burned. */
+    /**
+     * Amount of {@link PoolRedeemOperation.tokenIn} burned: pool shares
+     * (diesel) for direct redeems, or the zapper's share-side token amount for
+     * zapper-routed redeems.
+     */
     shares: bigint;
     /** Underlying token of the source pool. */
     underlying: Address;
+    /**
+     * Token burned from `owner`: the pool's diesel token for direct redeems, or
+     * the zapper's share-side token (e.g. a farmed/staked diesel wrapper) for
+     * zapper-routed redeems.
+     */
+    tokenIn: Address;
     /**
      * Token actually returned to the receiver: the pool underlying for direct
      * redeems, or the zapper's output token for zapper-routed redeems.
@@ -113,3 +140,4 @@ export interface PoolRedeemOperation {
  * field).
  */
 export type PoolOperation = PoolDepositOperation | PoolMintOperation | PoolWithdrawOperation | PoolRedeemOperation;
+export type PoolOperationType = PoolOperation["operation"];