@gauntlet-xyz/sdk 2.0.0 → 2.5.0

package/src/evm/deposit.ts

@@ -113,7 +113,8 @@ export async function getDepositTx(
     const tokenModeSupport = await resolveAeraTokenModeSupport(
       publicClient,
       aeraRuntime,
-      token.address
+      token.address,
+      { includeSyncModes: requestedDepositMode !== 'async' }
     );
     modifiedDepositMode = resolveOperationMode(params.vaultId, requestedDepositMode, {
       async: tokenModeSupport.asyncDeposit,

package/src/evm/index.ts

@@ -1,10 +1,30 @@
 export { getDepositTx } from './deposit';
 export { getDepositReceiverApprovalTx } from './depositReceiverApproval';
 export { getWithdrawTx } from './withdraw';
+export { getSyncWithdrawQuote } from './withdrawQuote';
+export { getAeraTokenModeSupport } from './tokenModes';
 export { getUserCurrentBalance } from './userCurrentBalance';
 export { getVaults, VaultId } from './vaults';
 export { ContractVersion } from './types';
 export { resolveAeraRuntimeContracts, resolveContractVersion } from './aeraContracts';
+export {
+  GauntletSDKError,
+  AccountRequiredError,
+  AccountMismatchError,
+  ChainMismatchError,
+  InvalidSlippageBPSError,
+  InvalidSolverTipError,
+  InvalidSyncWithdrawBoundError,
+  InvalidWithdrawParamsError,
+  RpcNotConfiguredError,
+  StalePriceError,
+  UnsupportedAssetError,
+  UnsupportedDepositModeError,
+  UnsupportedFeatureError,
+  UnsupportedProtocolError,
+  UnimplementedFeatureError,
+  VaultNotFoundError,
+} from '../errors';
 export {
   Rounding,
   convertTokenToUnits,
@@ -19,7 +39,18 @@ export {
 export type { EvmDepositParams } from './deposit';
 export type { EvmDepositReceiverApprovalParams } from './depositReceiverApproval';
 export type { EvmWithdrawParams } from './withdraw';
+export type {
+  SyncWithdrawQuote,
+  SyncWithdrawQuoteParams,
+  SyncWithdrawCapacity,
+  SyncWithdrawQuoteContext,
+  SyncWithdrawQuoteRequest,
+  SyncWithdrawQuoteBounds,
+} from './withdrawQuote';
+export type { AeraTokenModeSupportParams } from './tokenModes';
+export type { SyncRedeemRate } from './aeraContracts/v2';
 export type { EvmTxStep } from './adapters/types';
+export type { PreparedTx } from '../attribution';
 export type {
   VaultInfo,
   VaultDeployment,
@@ -31,3 +62,4 @@ export type { VaultFilter } from './vaults';
 export type { UserCurrentBalanceParams, UserCurrentBalance } from './userCurrentBalance';
 export type { AeraRuntimeContracts, AeraTokenModeSupport } from './aeraContracts';
 export type { NormalizedVaultPriceState } from './aeraContracts/priceAndFeeCalculator';
+export type { SyncWithdrawBound } from '../errors';

package/src/evm/tokenModes.ts

@@ -0,0 +1,54 @@
+import type { GauntletClient } from '../client';
+import { UnsupportedAssetError, UnsupportedFeatureError, VaultNotFoundError } from '../errors';
+import { resolveVault } from './vaults';
+import {
+  resolveAeraRuntimeContracts,
+  resolveAeraTokenModeSupport,
+  type AeraTokenModeSupport,
+} from './aeraContracts';
+
+export interface AeraTokenModeSupportParams {
+  vaultId: string;
+  /** EVM chain ID. Defaults to the vault's primary chain (Base for current multichain vaults). */
+  chainId?: number;
+  /** Required for multiasset vaults. */
+  assetSymbol?: string;
+}
+
+/**
+ * Reads which deposit/redeem modes (sync vs async) are currently enabled on-chain for a vault token.
+ *
+ * Use this to decide which entry points to offer a user (e.g. whether an instant withdraw is
+ * available) before any amount is entered. Mode availability includes the provisioner's token
+ * settings and live runtime gates. A paused V2 solving gate disables both sync modes.
+ *
+ * @throws {VaultNotFoundError} If the vault ID is not found.
+ * @throws {UnsupportedFeatureError} If the vault is not an Aera deployment.
+ * @throws {UnsupportedAssetError} If the asset symbol is not accepted by the vault.
+ */
+export async function getAeraTokenModeSupport(
+  client: GauntletClient,
+  params: AeraTokenModeSupportParams
+): Promise<AeraTokenModeSupport> {
+  const resolved = await resolveVault(client, params.vaultId, params.chainId);
+  if (!resolved) throw new VaultNotFoundError(params.vaultId);
+
+  const { vault, protocol } = resolved;
+  if (protocol !== 'aera') {
+    throw new UnsupportedFeatureError('Token mode support is only available for Aera vaults');
+  }
+
+  const chainId = params.chainId ?? vault.chainId;
+  const publicClient = client.getPublicClient(chainId);
+
+  const token =
+    vault.supplyToken.length > 1
+      ? vault.supplyToken.find((tInfo) => tInfo.symbol === params.assetSymbol)
+      : vault.supplyToken[0];
+  if (token === undefined) {
+    throw new UnsupportedAssetError(params.assetSymbol ?? 'unknown', params.vaultId);
+  }
+
+  const runtime = await resolveAeraRuntimeContracts(publicClient, vault);
+  return resolveAeraTokenModeSupport(publicClient, runtime, token.address);
+}

package/src/evm/withdraw.ts

@@ -1,15 +1,19 @@
 import type { Address } from 'viem';
 import type { GauntletClient } from '../client';
 import type { AdapterWithdrawParams } from './adapters/types';
+import type { SyncWithdrawQuoteBounds } from './withdrawQuote';
 import { getAdapter } from './adapters';
 import { encodeTransactionWithAttribution, PreparedTx } from '../attribution';
 import {
+  AccountMismatchError,
   AccountRequiredError,
   VaultNotFoundError,
   UnsupportedAssetError,
   InvalidSlippageBPSError,
+  InvalidWithdrawParamsError,
 } from '../errors';
 import {
+  requireAeraSyncRedeemRuntime,
   resolveAeraRuntimeContracts,
   resolveAeraTokenModeSupport,
   type AeraRuntimeContracts,
@@ -22,6 +26,7 @@ import {
   resolveSyncOnlyOperationMode,
   type OperationMode,
 } from './operationMode';
+import { ContractVersion } from './types';
 
 export type EvmWithdrawParams = {
   vaultId: string;
@@ -39,12 +44,94 @@ export type EvmWithdrawParams = {
   solverTip?: bigint;
   /** Maximum price age passed to async Aera provisioner requests. Defaults to 10 days. */
   maxPriceAge?: bigint;
+  /**
+   * Current sync quote bounds to pin instant withdraw transaction construction.
+   * Supplying bounds implies `depositMode: 'sync'`; explicit async requests are rejected.
+   */
+  syncWithdrawQuote?: SyncWithdrawQuoteBounds;
 } & (
   | { shares: bigint; amount?: never; entireAmount?: never }
   | { amount: bigint; shares?: never; entireAmount?: never }
-  | { entireAmount: true; shares?: never; amount?: never }
+  | { account?: Address; entireAmount: true; shares?: never; amount?: never }
 );
 
+function validateWithdrawParams(params: EvmWithdrawParams) {
+  const modes = [
+    'amount' in params && params.amount != null,
+    'shares' in params && params.shares != null,
+    'entireAmount' in params && params.entireAmount === true,
+  ].filter(Boolean).length;
+
+  if (modes !== 1) throw new InvalidWithdrawParamsError();
+}
+
+function sameAddress(left: Address, right: Address): boolean {
+  return left.toLowerCase() === right.toLowerCase();
+}
+
+function validateSyncWithdrawQuote({
+  params,
+  account,
+  chainId,
+  slippageBps,
+  tokenAddress,
+}: {
+  params: EvmWithdrawParams;
+  account: Address;
+  chainId: number;
+  slippageBps: number;
+  tokenAddress: Address;
+}) {
+  const quote = params.syncWithdrawQuote;
+  if (quote === undefined) return;
+
+  const { context } = quote;
+  if (
+    context.vaultId !== params.vaultId ||
+    context.chainId !== chainId ||
+    !sameAddress(context.tokenAddress, tokenAddress) ||
+    context.slippageBps !== slippageBps
+  ) {
+    throw new InvalidWithdrawParamsError();
+  }
+
+  if (context.account !== undefined && !sameAddress(context.account, account)) {
+    throw new InvalidWithdrawParamsError();
+  }
+
+  switch (context.request.mode) {
+    case 'amount':
+      if (
+        quote.kind !== 'withdraw' ||
+        !('amount' in params && params.amount != null) ||
+        context.request.amount !== params.amount ||
+        quote.tokensOut !== params.amount
+      ) {
+        throw new InvalidWithdrawParamsError();
+      }
+      return;
+    case 'shares':
+      if (
+        quote.kind !== 'redeem' ||
+        !('shares' in params && params.shares != null) ||
+        context.request.shares !== params.shares ||
+        quote.shares !== params.shares
+      ) {
+        throw new InvalidWithdrawParamsError();
+      }
+      return;
+    case 'entireAmount':
+      if (
+        quote.kind !== 'redeem' ||
+        !('entireAmount' in params && params.entireAmount) ||
+        !sameAddress(context.request.account, account)
+      ) {
+        throw new InvalidWithdrawParamsError();
+      }
+      return;
+  }
+}
+
 /**
  * Builds the ordered list of EVM transactions required to withdraw from a Gauntlet vault.
  *
@@ -76,6 +163,7 @@ export type EvmWithdrawParams = {
  * const txs = await getWithdrawTx(client, {
  *   vaultId: 'baseUsdcPrime',
  *   entireAmount: true,
+ *   account: walletAddress,
  * });
  * ```
  */
@@ -83,6 +171,8 @@ export async function getWithdrawTx(
   client: GauntletClient,
   params: EvmWithdrawParams
 ): Promise<PreparedTx[]> {
+  validateWithdrawParams(params);
+
   if (
     params.slippageBps !== undefined &&
     (!Number.isInteger(params.slippageBps) ||
@@ -99,6 +189,11 @@ export async function getWithdrawTx(
 
   const account = client.wallet?.account?.address;
   if (!account) throw new AccountRequiredError();
+  if ('entireAmount' in params && params.entireAmount && params.account !== undefined) {
+    if (!sameAddress(params.account, account)) {
+      throw new AccountMismatchError(account, params.account);
+    }
+  }
 
   const { vault, protocol } = resolved;
 
@@ -114,20 +209,48 @@ export async function getWithdrawTx(
   const adapter = getAdapter(protocol);
   const publicClient = client.getPublicClient(chainId);
   const requestedWithdrawMode = parseOperationMode(params.vaultId, params.depositMode);
+  const slippageBps =
+    params.slippageBps ?? params.syncWithdrawQuote?.context.slippageBps ?? DEFAULT_BPS;
   let modifiedDepositMode: OperationMode;
   let aeraRuntime: AeraRuntimeContracts | undefined;
 
+  if (params.syncWithdrawQuote !== undefined) {
+    if (protocol !== 'aera' || requestedWithdrawMode === 'async') {
+      throw new InvalidWithdrawParamsError();
+    }
+
+    validateSyncWithdrawQuote({
+      params,
+      account,
+      chainId,
+      slippageBps,
+      tokenAddress: token.address,
+    });
+  }
+
   if (protocol === 'aera') {
     aeraRuntime = await resolveAeraRuntimeContracts(publicClient, vault);
+    if (
+      aeraRuntime.provisioner.version === ContractVersion.V2 &&
+      (requestedWithdrawMode === 'sync' || params.syncWithdrawQuote !== undefined)
+    ) {
+      requireAeraSyncRedeemRuntime(aeraRuntime);
+    }
     const tokenModeSupport = await resolveAeraTokenModeSupport(
       publicClient,
       aeraRuntime,
-      token.address
+      token.address,
+      { includeSyncModes: requestedWithdrawMode !== 'async' }
     );
-    modifiedDepositMode = resolveOperationMode(params.vaultId, requestedWithdrawMode, {
-      async: tokenModeSupport.asyncRedeem,
-      sync: tokenModeSupport.syncRedeem,
-    });
+    modifiedDepositMode = resolveOperationMode(
+      params.vaultId,
+      params.syncWithdrawQuote !== undefined ? 'sync' : requestedWithdrawMode,
+      {
+        async: tokenModeSupport.asyncRedeem,
+        sync: tokenModeSupport.syncRedeem,
+      }
+    );
+    if (modifiedDepositMode === 'sync') requireAeraSyncRedeemRuntime(aeraRuntime);
   } else {
     modifiedDepositMode = resolveSyncOnlyOperationMode(params.vaultId, requestedWithdrawMode);
   }
@@ -139,10 +262,11 @@ export async function getWithdrawTx(
     async: modifiedDepositMode === 'async',
     asset: token,
     publicClient,
-    slippageBps: params.slippageBps ?? DEFAULT_BPS,
+    slippageBps,
     solverTip: params.solverTip,
     maxPriceAge: params.maxPriceAge,
     aeraRuntime,
+    syncWithdrawQuote: params.syncWithdrawQuote,
     ...('shares' in params && params.shares != null ? { shares: params.shares } : {}),
     ...('amount' in params && params.amount != null ? { amount: params.amount } : {}),
     ...('entireAmount' in params && params.entireAmount ? { entireAmount: true as const } : {}),

package/src/evm/withdrawQuote.ts

@@ -0,0 +1,360 @@
+import type { Address } from 'viem';
+import type { GauntletClient } from '../client';
+import {
+  AccountRequiredError,
+  InvalidSlippageBPSError,
+  InvalidWithdrawParamsError,
+  requireNonZeroSyncWithdrawBound,
+  UnsupportedAssetError,
+  UnsupportedFeatureError,
+  VaultNotFoundError,
+} from '../errors';
+import { DEFAULT_BPS, MAX_BPS } from '../constants';
+import { resolveVault } from './vaults';
+import {
+  applySlippageDown,
+  applySlippageUp,
+  requireAeraSyncRedeemRuntime,
+  resolveAeraRuntimeContracts,
+  resolveAeraTokenModeSupport,
+} from './aeraContracts';
+import { multiDepositorVaultAbi } from './abis/multiDepositorVault';
+import {
+  convertNumeraireToToken,
+  convertTokenToNumeraire,
+} from './aeraContracts/priceAndFeeCalculator';
+import {
+  getSyncRedeemEpochState,
+  getSyncRedeemRate,
+  getSyncRedeemTokenOut,
+  getSyncWithdrawUnitsIn,
+  getUserUnitsRefundableUntil,
+  type SyncRedeemRate,
+} from './aeraContracts/v2';
+import { resolveOperationMode } from './operationMode';
+
+/** Epoch capacity accounting for the global sync redeem cap. */
+export interface SyncWithdrawCapacity {
+  /** Effective epoch cap (min of relative and absolute), in numeraire. */
+  epochCapNumeraire: bigint;
+  /** Numeraire already redeemed globally in the current epoch. */
+  epochRedeemedNumeraire: bigint;
+  /** Remaining global sync redeem capacity this epoch, in numeraire. */
+  remainingNumeraire: bigint;
+  /** Remaining capacity expressed in the withdraw token. */
+  remainingTokens: bigint;
+  /** This redemption's size in numeraire (matches the on-chain epoch accounting). */
+  requestNumeraire: bigint;
+  /** True when this redemption alone exceeds remaining epoch capacity (the tx would revert). */
+  exceedsCapacity: boolean;
+}
+
+export type SyncWithdrawQuoteRequest =
+  | { mode: 'amount'; amount: bigint }
+  | { mode: 'shares'; shares: bigint }
+  | { mode: 'entireAmount'; account: Address };
+
+export interface SyncWithdrawQuoteContext {
+  vaultId: string;
+  chainId: number;
+  tokenAddress: Address;
+  /** Account used for balance and lock reads when the quote is account-scoped. */
+  account?: Address;
+  /** Slippage tolerance used to derive `minTokensOut` or `maxUnitsIn`. */
+  slippageBps: number;
+  /** Block snapshot used for all quote reads. */
+  blockNumber: bigint;
+  /** Exact sizing request that produced this quote. */
+  request: SyncWithdrawQuoteRequest;
+}
+
+interface SyncWithdrawQuoteDetails {
+  /** Vault units (shares) burned: exact for `'redeem'`, estimated for `'withdraw'`. */
+  shares: bigint;
+  /** Upper bound on shares burned after slippage (equals `shares` for `'redeem'`). */
+  maxUnitsIn: bigint;
+  /** Tokens received: exact (requested) for `'withdraw'`, estimated for `'redeem'`. */
+  tokensOut: bigint;
+  /** Lower bound on tokens received after slippage (equals `tokensOut` for `'withdraw'`). */
+  minTokensOut: bigint;
+  /** Live multiplier breakdown (base, dynamic premium, effective), in bps. */
+  rate: SyncRedeemRate;
+  capacity: SyncWithdrawCapacity;
+  /** Timestamp until which the account's units are locked; undefined when no account was quoted. */
+  unitsLockedUntil?: bigint;
+  /** Context that must match any transaction build using these quote bounds. */
+  context: SyncWithdrawQuoteContext;
+}
+
+/** Bounds consumed by one of the two on-chain sync withdraw entry points. */
+export type SyncWithdrawQuoteBounds =
+  | {
+      kind: 'redeem';
+      shares: bigint;
+      minTokensOut: bigint;
+      context: SyncWithdrawQuoteContext;
+    }
+  | {
+      kind: 'withdraw';
+      tokensOut: bigint;
+      maxUnitsIn: bigint;
+      context: SyncWithdrawQuoteContext;
+    };
+
+/**
+ * A live quote for an instant (sync) withdraw.
+ *
+ * `kind` distinguishes the two on-chain entry points:
+ * - `'redeem'`: exact shares burned, estimated tokens out (used for by-shares / entire-balance exits)
+ * - `'withdraw'`: exact tokens out, estimated shares burned (used for by-token-amount exits)
+ */
+export type SyncWithdrawQuote =
+  | (SyncWithdrawQuoteDetails & { kind: 'redeem' })
+  | (SyncWithdrawQuoteDetails & { kind: 'withdraw' });
+
+type SyncWithdrawQuoteBaseParams = {
+  vaultId: string;
+  /** EVM chain ID. Defaults to the vault's primary chain (Base for current multichain vaults). */
+  chainId?: number;
+  /** Required for multiasset vaults. */
+  assetSymbol?: string;
+  /** Optional for explicit amount/shares quotes; required for full-position quotes. */
+  account?: Address;
+  /**
+   * Slippage tolerance in basis points (e.g. 100 = 1%). Defaults to 100.
+   * A value of 10000 is invalid for share-sized quotes because it makes `minTokensOut` zero.
+   */
+  slippageBps?: number;
+};
+
+export type SyncWithdrawQuoteParams =
+  | (SyncWithdrawQuoteBaseParams & { shares: bigint; amount?: never; entireAmount?: never })
+  | (SyncWithdrawQuoteBaseParams & { amount: bigint; shares?: never; entireAmount?: never })
+  | (SyncWithdrawQuoteBaseParams & {
+      account: Address;
+      entireAmount: true;
+      shares?: never;
+      amount?: never;
+    });
+
+function validateSyncWithdrawQuoteParams(params: SyncWithdrawQuoteParams) {
+  const modes = [
+    'amount' in params && params.amount != null,
+    'shares' in params && params.shares != null,
+    'entireAmount' in params && params.entireAmount === true,
+  ].filter(Boolean).length;
+
+  if (modes !== 1) throw new InvalidWithdrawParamsError();
+  if ('entireAmount' in params && params.entireAmount === true && !params.account) {
+    throw new AccountRequiredError();
+  }
+}
+
+/**
+ * Builds a live quote for an instant (sync) withdraw without sending a transaction.
+ *
+ * Surfaces everything the on-chain `redeem`/`withdraw` would apply or check but that a plain
+ * transaction build does not pre-validate: the effective rate (including the price-age dynamic
+ * premium), slippage bounds, the global per-epoch redeem capacity, and whether the caller's units
+ * are still locked from a recent sync deposit.
+ *
+ * @throws {VaultNotFoundError} If the vault ID is not found.
+ * @throws {UnsupportedAssetError} If the asset symbol is not accepted by the vault.
+ * @throws {UnsupportedFeatureError} If the vault is not an Aera V2 deployment.
+ * @throws {UnsupportedDepositModeError} If sync redeem is not enabled for the token.
+ * @throws {StalePriceError} If the oracle price is too stale for an instant redeem.
+ */
+export async function getSyncWithdrawQuote(
+  client: GauntletClient,
+  params: SyncWithdrawQuoteParams
+): Promise<SyncWithdrawQuote> {
+  validateSyncWithdrawQuoteParams(params);
+
+  if (
+    params.slippageBps !== undefined &&
+    (!Number.isInteger(params.slippageBps) ||
+      params.slippageBps < 0 ||
+      params.slippageBps > Number(MAX_BPS))
+  ) {
+    throw new InvalidSlippageBPSError(params.slippageBps);
+  }
+  const slippageBps = params.slippageBps ?? DEFAULT_BPS;
+
+  const resolved = await resolveVault(client, params.vaultId, params.chainId);
+  if (!resolved) throw new VaultNotFoundError(params.vaultId);
+
+  const { vault, protocol } = resolved;
+  if (protocol !== 'aera') {
+    throw new UnsupportedFeatureError('Sync withdraw quote is only available for Aera vaults');
+  }
+
+  const chainId = params.chainId ?? vault.chainId;
+  const publicClient = client.getPublicClient(chainId);
+
+  const token =
+    vault.supplyToken.length > 1
+      ? vault.supplyToken.find((tInfo) => tInfo.symbol === params.assetSymbol)
+      : vault.supplyToken[0];
+  if (token === undefined) {
+    throw new UnsupportedAssetError(params.assetSymbol ?? 'unknown', params.vaultId);
+  }
+
+  const quoteBlock = await publicClient.getBlock();
+  if (quoteBlock.number === null) {
+    throw new UnsupportedFeatureError('Aera: sync withdraw quote requires a numbered block');
+  }
+  const quoteReadContext = {
+    blockNumber: quoteBlock.number,
+    blockTimestamp: BigInt(quoteBlock.timestamp),
+  };
+
+  const runtime = await resolveAeraRuntimeContracts(publicClient, vault, quoteReadContext);
+  requireAeraSyncRedeemRuntime(runtime);
+
+  const support = await resolveAeraTokenModeSupport(
+    publicClient,
+    runtime,
+    token.address,
+    quoteReadContext
+  );
+  resolveOperationMode(params.vaultId, 'sync', {
+    async: support.asyncRedeem,
+    sync: support.syncRedeem,
+  });
+
+  const provisioner = runtime.provisioner.address;
+  const feeCalculator = runtime.feeCalculator.address;
+  const feeVersion = runtime.feeCalculator.version;
+  const vaultAddress = vault.vaultAddress;
+
+  const rate = await getSyncRedeemRate(
+    publicClient,
+    provisioner,
+    vaultAddress,
+    token.address,
+    feeCalculator,
+    quoteReadContext
+  );
+
+  let kind: SyncWithdrawQuote['kind'];
+  let shares: bigint;
+  let tokensOut: bigint;
+  let minTokensOut: bigint;
+  let maxUnitsIn: bigint;
+  let request: SyncWithdrawQuoteRequest;
+
+  if ('amount' in params && params.amount != null) {
+    // Exact token out: shares burned is the estimate, bounded above by slippage.
+    kind = 'withdraw';
+    request = { mode: 'amount', amount: params.amount };
+    tokensOut = params.amount;
+    requireNonZeroSyncWithdrawBound(tokensOut, 'tokensOut');
+    minTokensOut = params.amount;
+    shares = await getSyncWithdrawUnitsIn(
+      publicClient,
+      provisioner,
+      feeCalculator,
+      feeVersion,
+      vaultAddress,
+      token.address,
+      params.amount,
+      rate.effectiveMultiplierBps,
+      quoteReadContext
+    );
+    maxUnitsIn = applySlippageUp(shares, slippageBps);
+    requireNonZeroSyncWithdrawBound(maxUnitsIn, 'maxUnitsIn');
+  } else {
+    // Exact shares in: tokens out is the estimate, bounded below by slippage.
+    kind = 'redeem';
+    if ('entireAmount' in params && params.entireAmount) {
+      if (!params.account) throw new AccountRequiredError();
+      request = { mode: 'entireAmount', account: params.account };
+      shares = await publicClient.readContract({
+        address: vaultAddress,
+        abi: multiDepositorVaultAbi,
+        functionName: 'balanceOf',
+        args: [params.account],
+        blockNumber: quoteReadContext.blockNumber,
+      });
+    } else if ('shares' in params && params.shares != null) {
+      request = { mode: 'shares', shares: params.shares };
+      shares = params.shares;
+    } else {
+      throw new InvalidWithdrawParamsError();
+    }
+    requireNonZeroSyncWithdrawBound(shares, 'unitsIn');
+    tokensOut = await getSyncRedeemTokenOut(
+      publicClient,
+      provisioner,
+      feeCalculator,
+      feeVersion,
+      vaultAddress,
+      token.address,
+      shares,
+      rate.effectiveMultiplierBps,
+      quoteReadContext
+    );
+    minTokensOut = applySlippageDown(tokensOut, slippageBps);
+    requireNonZeroSyncWithdrawBound(minTokensOut, 'minTokensOut');
+    maxUnitsIn = shares;
+  }
+
+  const [epoch, requestNumeraire, unitsLockedUntil] = await Promise.all([
+    getSyncRedeemEpochState(publicClient, provisioner, quoteReadContext),
+    convertTokenToNumeraire(
+      publicClient,
+      feeCalculator,
+      feeVersion,
+      vaultAddress,
+      token.address,
+      tokensOut,
+      quoteReadContext
+    ),
+    params.account
+      ? getUserUnitsRefundableUntil(publicClient, provisioner, params.account, quoteReadContext)
+      : Promise.resolve(undefined),
+  ]);
+
+  const remainingNumeraire =
+    epoch.epochCapNumeraire > epoch.epochRedeemedNumeraire
+      ? epoch.epochCapNumeraire - epoch.epochRedeemedNumeraire
+      : 0n;
+  const remainingTokens = await convertNumeraireToToken(
+    publicClient,
+    feeCalculator,
+    feeVersion,
+    vaultAddress,
+    token.address,
+    remainingNumeraire,
+    quoteReadContext
+  );
+
+  const quoteDetails: SyncWithdrawQuoteDetails = {
+    shares,
+    maxUnitsIn,
+    tokensOut,
+    minTokensOut,
+    rate,
+    capacity: {
+      epochCapNumeraire: epoch.epochCapNumeraire,
+      epochRedeemedNumeraire: epoch.epochRedeemedNumeraire,
+      remainingNumeraire,
+      remainingTokens,
+      requestNumeraire,
+      exceedsCapacity: requestNumeraire > remainingNumeraire,
+    },
+    unitsLockedUntil,
+    context: {
+      vaultId: params.vaultId,
+      chainId,
+      tokenAddress: token.address,
+      ...(params.account ? { account: params.account } : {}),
+      slippageBps,
+      blockNumber: quoteReadContext.blockNumber,
+      request,
+    },
+  };
+
+  if (kind === 'redeem') return { kind, ...quoteDetails };
+  return { kind, ...quoteDetails };
+}