@gearbox-protocol/sdk 14.12.0-next.28 → 14.12.0-next.29

package/dist/cjs/plugins/adapters/contracts/AbstractAdapter.js

@@ -162,6 +162,18 @@ class AbstractAdapterContract extends import_sdk.BaseContract {
       `previewBalanceChanges is not supported for ${decoded.functionName} on ${this.contractType} adapter at ${this.address}`
     );
   }
+  /**
+   * When the given adapter calldata is a delayed-withdrawal request (a call
+   * created by the withdrawal compressor that mints a withdrawal phantom
+   * token), returns its descriptor; `undefined` for any other call.
+   *
+   * The base implementation returns `undefined`; delayed-withdrawal adapters
+   * (Securitize, Midas, Mellow) override it next to their
+   * {@link applyBalanceChanges} cases for the same methods.
+   */
+  parseDelayedWithdrawalRequest(_calldata) {
+    return void 0;
+  }
   /**
    * Diff-call semantics of a diff-style adapter call: the call spends the
    * consumed token down to the exact `leftoverAmount` encoded in its

package/dist/cjs/plugins/adapters/contracts/MellowERC4626VaultAdapterContract.js

@@ -108,6 +108,31 @@ class MellowERC4626VaultAdapterContract extends import_AbstractAdapter.AbstractA
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
+  /**
+   * Plain `redeem` on a Mellow multivault is a delayed-withdrawal request:
+   * it is only emitted by the withdrawal compressor (the router uses
+   * `redeemDiff`), spends the multivault shares and mints the withdrawal
+   * phantom token for the illiquid part. Mellow request calls cannot carry
+   * an intent, so `extraData` is always undefined.
+   *
+   * The withdrawal phantom token is only serialized by v311 adapters;
+   * on other versions it cannot be resolved offline and the request is not
+   * reported.
+   */
+  parseDelayedWithdrawalRequest(calldata) {
+    if (!this.#stakedPhantomToken || !this.#asset) {
+      return void 0;
+    }
+    const decoded = (0, import_viem.decodeFunctionData)({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeem") {
+      return void 0;
+    }
+    return {
+      phantomToken: this.#stakedPhantomToken,
+      claimToken: this.#asset,
+      extraData: void 0
+    };
+  }
   async applyBalanceChanges(balances, decoded) {
     const share = this.#vault ?? this.targetContract;
     switch (decoded.functionName) {

package/dist/cjs/plugins/adapters/contracts/MidasGatewayAdapterContract.js

@@ -97,6 +97,26 @@ class MidasGatewayAdapterContract extends import_AbstractAdapter.AbstractAdapter
       }))
     };
   }
+  /**
+   * `redeemRequest` (the only request call the withdrawal compressor emits)
+   * spends the mToken and mints the phantom token of the requested
+   * `tokenOut`, which is received when the redemption is claimed. The 3-arg
+   * overload carries the intent `extraData`.
+   */
+  parseDelayedWithdrawalRequest(calldata) {
+    const decoded = (0, import_viem.decodeFunctionData)({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeemRequest") {
+      return void 0;
+    }
+    const [tokenOut, , extraData] = decoded.args;
+    const phantomToken = this.allowedOutputTokens.find(
+      (t) => (0, import_viem.isAddressEqual)(t.token, tokenOut)
+    )?.phantomToken;
+    if (!phantomToken) {
+      return void 0;
+    }
+    return { phantomToken, claimToken: tokenOut, extraData };
+  }
   async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositInstantDiff": {
@@ -104,10 +124,9 @@ class MidasGatewayAdapterContract extends import_AbstractAdapter.AbstractAdapter
         this.setLeftover(balances, tokenIn, leftoverAmount);
         break;
       }
-      // redemptions spend the mToken down to the leftover, tokenOut arg is
-      // the received token
-      case "redeemInstantDiff":
-      case "redeemRequestDiff": {
+      // instant redemption spends the mToken down to the leftover, tokenOut
+      // arg is the received token
+      case "redeemInstantDiff": {
         const [, leftoverAmount] = decoded.args;
         this.setLeftover(balances, this.mToken, leftoverAmount);
         break;

package/dist/cjs/plugins/adapters/contracts/SecuritizeRedemptionGatewayAdapterContract.js

@@ -72,6 +72,24 @@ class SecuritizeRedemptionGatewayAdapterContract extends import_AbstractAdapter.
       redemptionPhantomToken: this.#redemptionPhantomToken ? this.labelAddress(this.#redemptionPhantomToken) : void 0
     };
   }
+  /**
+   * `redeem` (the only request call the withdrawal compressor emits) spends
+   * the DS token and mints the redemption phantom token; the stable coin is
+   * received when the redemption is claimed. The 2-arg overload carries the
+   * intent `extraData`.
+   */
+  parseDelayedWithdrawalRequest(calldata) {
+    const decoded = (0, import_viem.decodeFunctionData)({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeem") {
+      return void 0;
+    }
+    const [, extraData] = decoded.args;
+    return {
+      phantomToken: this.redemptionPhantomToken,
+      claimToken: this.stableCoinToken,
+      extraData
+    };
+  }
   async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // no-op:
@@ -80,12 +98,6 @@ class SecuritizeRedemptionGatewayAdapterContract extends import_AbstractAdapter.
       case "redeem": {
         break;
       }
-      // diff-style redemption: spends the DS token down to the leftover
-      case "redeemDiff": {
-        const [leftoverAmount] = decoded.args;
-        this.setLeftover(balances, this.dsToken, leftoverAmount);
-        break;
-      }
       // no-op:
       // the redemption phantom token burn of a `claim(address[])` is
       // not recoverable from calldata (it lives in per-redeemer clone

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

@@ -150,6 +150,18 @@ class AbstractAdapterContract extends BaseContract {
       `previewBalanceChanges is not supported for ${decoded.functionName} on ${this.contractType} adapter at ${this.address}`
     );
   }
+  /**
+   * When the given adapter calldata is a delayed-withdrawal request (a call
+   * created by the withdrawal compressor that mints a withdrawal phantom
+   * token), returns its descriptor; `undefined` for any other call.
+   *
+   * The base implementation returns `undefined`; delayed-withdrawal adapters
+   * (Securitize, Midas, Mellow) override it next to their
+   * {@link applyBalanceChanges} cases for the same methods.
+   */
+  parseDelayedWithdrawalRequest(_calldata) {
+    return void 0;
+  }
   /**
    * Diff-call semantics of a diff-style adapter call: the call spends the
    * consumed token down to the exact `leftoverAmount` encoded in its

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

@@ -1,5 +1,6 @@
 import {
-  decodeAbiParameters
+  decodeAbiParameters,
+  decodeFunctionData
 } from "viem";
 import {
   MissingSerializedParamsError
@@ -89,6 +90,31 @@ class MellowERC4626VaultAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
+  /**
+   * Plain `redeem` on a Mellow multivault is a delayed-withdrawal request:
+   * it is only emitted by the withdrawal compressor (the router uses
+   * `redeemDiff`), spends the multivault shares and mints the withdrawal
+   * phantom token for the illiquid part. Mellow request calls cannot carry
+   * an intent, so `extraData` is always undefined.
+   *
+   * The withdrawal phantom token is only serialized by v311 adapters;
+   * on other versions it cannot be resolved offline and the request is not
+   * reported.
+   */
+  parseDelayedWithdrawalRequest(calldata) {
+    if (!this.#stakedPhantomToken || !this.#asset) {
+      return void 0;
+    }
+    const decoded = decodeFunctionData({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeem") {
+      return void 0;
+    }
+    return {
+      phantomToken: this.#stakedPhantomToken,
+      claimToken: this.#asset,
+      extraData: void 0
+    };
+  }
   async applyBalanceChanges(balances, decoded) {
     const share = this.#vault ?? this.targetContract;
     switch (decoded.functionName) {

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

@@ -1,5 +1,7 @@
 import {
-  decodeAbiParameters
+  decodeAbiParameters,
+  decodeFunctionData,
+  isAddressEqual
 } from "viem";
 import {
   MissingSerializedParamsError
@@ -81,6 +83,26 @@ class MidasGatewayAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  /**
+   * `redeemRequest` (the only request call the withdrawal compressor emits)
+   * spends the mToken and mints the phantom token of the requested
+   * `tokenOut`, which is received when the redemption is claimed. The 3-arg
+   * overload carries the intent `extraData`.
+   */
+  parseDelayedWithdrawalRequest(calldata) {
+    const decoded = decodeFunctionData({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeemRequest") {
+      return void 0;
+    }
+    const [tokenOut, , extraData] = decoded.args;
+    const phantomToken = this.allowedOutputTokens.find(
+      (t) => isAddressEqual(t.token, tokenOut)
+    )?.phantomToken;
+    if (!phantomToken) {
+      return void 0;
+    }
+    return { phantomToken, claimToken: tokenOut, extraData };
+  }
   async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositInstantDiff": {
@@ -88,10 +110,9 @@ class MidasGatewayAdapterContract extends AbstractAdapterContract {
         this.setLeftover(balances, tokenIn, leftoverAmount);
         break;
       }
-      // redemptions spend the mToken down to the leftover, tokenOut arg is
-      // the received token
-      case "redeemInstantDiff":
-      case "redeemRequestDiff": {
+      // instant redemption spends the mToken down to the leftover, tokenOut
+      // arg is the received token
+      case "redeemInstantDiff": {
         const [, leftoverAmount] = decoded.args;
         this.setLeftover(balances, this.mToken, leftoverAmount);
         break;

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

@@ -1,5 +1,6 @@
 import {
-  decodeAbiParameters
+  decodeAbiParameters,
+  decodeFunctionData
 } from "viem";
 import {
   MissingSerializedParamsError
@@ -53,6 +54,24 @@ class SecuritizeRedemptionGatewayAdapterContract extends AbstractAdapterContract
       redemptionPhantomToken: this.#redemptionPhantomToken ? this.labelAddress(this.#redemptionPhantomToken) : void 0
     };
   }
+  /**
+   * `redeem` (the only request call the withdrawal compressor emits) spends
+   * the DS token and mints the redemption phantom token; the stable coin is
+   * received when the redemption is claimed. The 2-arg overload carries the
+   * intent `extraData`.
+   */
+  parseDelayedWithdrawalRequest(calldata) {
+    const decoded = decodeFunctionData({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeem") {
+      return void 0;
+    }
+    const [, extraData] = decoded.args;
+    return {
+      phantomToken: this.redemptionPhantomToken,
+      claimToken: this.stableCoinToken,
+      extraData
+    };
+  }
   async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // no-op:
@@ -61,12 +80,6 @@ class SecuritizeRedemptionGatewayAdapterContract extends AbstractAdapterContract
       case "redeem": {
         break;
       }
-      // diff-style redemption: spends the DS token down to the leftover
-      case "redeemDiff": {
-        const [leftoverAmount] = decoded.args;
-        this.setLeftover(balances, this.dsToken, leftoverAmount);
-        break;
-      }
       // no-op:
       // the redemption phantom token burn of a `claim(address[])` is
       // not recoverable from calldata (it lives in per-redeemer clone

package/dist/types/plugins/adapters/contracts/AbstractAdapter.d.ts

@@ -3,7 +3,7 @@ import { type CallTrace } from "../../../common-utils/utils/trace.js";
 import type { AssetsMap, OnchainSDK, ParsedCallV2, RelaxedBaseParams } from "../../../sdk/index.js";
 import { BaseContract } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
-import type { AdapterContractStateHuman, AdapterContractType, AdapterProtocolOperation } from "../types.js";
+import type { AdapterContractStateHuman, AdapterContractType, AdapterProtocolOperation, DelayedWithdrawalRequest } from "../types.js";
 export interface ConcreteAdapterContractOptions {
     baseParams: RelaxedBaseParams;
 }
@@ -64,6 +64,16 @@ export declare class AbstractAdapterContract<const abi extends Abi | readonly un
      * @throws When the adapter (or the specific function) has no balance-changes support
      */
     protected applyBalanceChanges(_balances: AssetsMap, decoded: DecodeFunctionDataReturnType<abi>): Promise<void>;
+    /**
+     * When the given adapter calldata is a delayed-withdrawal request (a call
+     * created by the withdrawal compressor that mints a withdrawal phantom
+     * token), returns its descriptor; `undefined` for any other call.
+     *
+     * The base implementation returns `undefined`; delayed-withdrawal adapters
+     * (Securitize, Midas, Mellow) override it next to their
+     * {@link applyBalanceChanges} cases for the same methods.
+     */
+    parseDelayedWithdrawalRequest(_calldata: Hex): DelayedWithdrawalRequest | undefined;
     /**
      * Diff-call semantics of a diff-style adapter call: the call spends the
      * consumed token down to the exact `leftoverAmount` encoded in its

package/dist/types/plugins/adapters/contracts/MellowERC4626VaultAdapterContract.d.ts

@@ -1,6 +1,7 @@
-import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import { type Address, type DecodeFunctionDataReturnType, type Hex } from "viem";
 import { type AssetsMap, type OnchainSDK, type ParsedCallV2 } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
+import type { DelayedWithdrawalRequest } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -677,6 +678,18 @@ export declare class MellowERC4626VaultAdapterContract extends AbstractAdapterCo
      * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L32-L38
      */
     classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    /**
+     * Plain `redeem` on a Mellow multivault is a delayed-withdrawal request:
+     * it is only emitted by the withdrawal compressor (the router uses
+     * `redeemDiff`), spends the multivault shares and mints the withdrawal
+     * phantom token for the illiquid part. Mellow request calls cannot carry
+     * an intent, so `extraData` is always undefined.
+     *
+     * The withdrawal phantom token is only serialized by v311 adapters;
+     * on other versions it cannot be resolved offline and the request is not
+     * reported.
+     */
+    parseDelayedWithdrawalRequest(calldata: Hex): DelayedWithdrawalRequest | undefined;
     protected applyBalanceChanges(balances: AssetsMap, decoded: DecodeFunctionDataReturnType<abi>): Promise<void>;
 }
 export {};

package/dist/types/plugins/adapters/contracts/MidasGatewayAdapterContract.d.ts

@@ -1,5 +1,6 @@
-import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import { type Address, type DecodeFunctionDataReturnType, type Hex } from "viem";
 import { type AssetsMap, type OnchainSDK } from "../../../sdk/index.js";
+import type { DelayedWithdrawalRequest } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -784,6 +785,13 @@ export declare class MidasGatewayAdapterContract extends AbstractAdapterContract
             phantomToken: string;
         }[] | undefined;
     };
+    /**
+     * `redeemRequest` (the only request call the withdrawal compressor emits)
+     * spends the mToken and mints the phantom token of the requested
+     * `tokenOut`, which is received when the redemption is claimed. The 3-arg
+     * overload carries the intent `extraData`.
+     */
+    parseDelayedWithdrawalRequest(calldata: Hex): DelayedWithdrawalRequest | undefined;
     protected applyBalanceChanges(balances: AssetsMap, decoded: DecodeFunctionDataReturnType<abi>): Promise<void>;
 }
 export {};

package/dist/types/plugins/adapters/contracts/SecuritizeRedemptionGatewayAdapterContract.d.ts

@@ -1,5 +1,6 @@
-import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import { type Address, type DecodeFunctionDataReturnType, type Hex } from "viem";
 import { type AssetsMap, type OnchainSDK } from "../../../sdk/index.js";
+import type { DelayedWithdrawalRequest } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -438,6 +439,13 @@ export declare class SecuritizeRedemptionGatewayAdapterContract extends Abstract
         stableCoinToken: string | undefined;
         redemptionPhantomToken: string | undefined;
     };
+    /**
+     * `redeem` (the only request call the withdrawal compressor emits) spends
+     * the DS token and mints the redemption phantom token; the stable coin is
+     * received when the redemption is claimed. The 2-arg overload carries the
+     * intent `extraData`.
+     */
+    parseDelayedWithdrawalRequest(calldata: Hex): DelayedWithdrawalRequest | undefined;
     protected applyBalanceChanges(balances: AssetsMap, decoded: DecodeFunctionDataReturnType<abi>): Promise<void>;
 }
 export {};

package/dist/types/plugins/adapters/types.d.ts

@@ -1,4 +1,4 @@
-import type { AbiParameter, Address } from "viem";
+import type { AbiParameter, Address, Hex } from "viem";
 import type { OnchainSDK, PluginsMap } from "../../sdk/index.js";
 import type { BaseContractStateHuman } from "../../sdk/types/state-human.js";
 import type { AdaptersPlugin } from "./AdaptersPlugin.js";
@@ -68,6 +68,27 @@ export interface AdapterProtocolOperation {
      */
     functionArgs: Record<string, unknown>;
 }
+/**
+ * Descriptor of a delayed-withdrawal request performed by an adapter call
+ * (constructed by the withdrawal compressor): the source token is spent now and
+ * the withdrawal phantom token is minted in its place; the claim token is
+ * received later, when the withdrawal matures and is claimed.
+ */
+export interface DelayedWithdrawalRequest {
+    /**
+     * Withdrawal phantom token minted by this request
+     */
+    phantomToken: Address;
+    /**
+     * Token received when the withdrawal is claimed
+     */
+    claimToken: Address;
+    /**
+     * Raw extraData arg that may encode a DelayedIntent; absent on adapters
+     * whose request methods carry none (e.g. Mellow)
+     */
+    extraData?: Hex;
+}
 /**
  * True when the plugin map `P` contains the {@link AdaptersPlugin} under any key
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "14.12.0-next.28",
+  "version": "14.12.0-next.29",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {