@gauntlet-xyz/sdk 2.3.0 → 3.0.1

package/src/evm/deposit.ts

@@ -8,6 +8,7 @@ import {
   VaultNotFoundError,
   UnsupportedAssetError,
   InvalidSlippageBPSError,
+  InvalidSyncDepositBoundError,
 } from '../errors';
 import {
   resolveAeraRuntimeContracts,
@@ -40,6 +41,8 @@ export interface EvmDepositParams {
   solverTip?: bigint;
   /** Maximum price age passed to async Aera provisioner requests. Defaults to 10 days. */
   maxPriceAge?: bigint;
+  /** Caller-reviewed minimum output for an explicit Aera synchronous deposit. */
+  minUnitsOut?: bigint;
 }
 
 /**
@@ -74,13 +77,15 @@ export async function getDepositTx(
   client: GauntletClient,
   params: EvmDepositParams
 ): Promise<PreparedTx[]> {
+  const slippageBps = params.slippageBps ?? DEFAULT_BPS;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > Number(MAX_BPS)) {
+    throw new InvalidSlippageBPSError(slippageBps);
+  }
   if (
-    params.slippageBps !== undefined &&
-    (!Number.isInteger(params.slippageBps) ||
-      params.slippageBps < 0 ||
-      params.slippageBps > Number(MAX_BPS))
+    params.minUnitsOut !== undefined &&
+    (typeof params.minUnitsOut !== 'bigint' || params.minUnitsOut <= 0n)
   ) {
-    throw new InvalidSlippageBPSError(params.slippageBps);
+    throw new InvalidSyncDepositBoundError();
   }
 
   const resolved = await resolveVault(client, params.vaultId, params.chainId);
@@ -105,6 +110,12 @@ export async function getDepositTx(
   }
 
   const requestedDepositMode = parseOperationMode(params.vaultId, params.depositMode);
+  if (
+    params.minUnitsOut !== undefined &&
+    (protocol !== 'aera' || requestedDepositMode !== 'sync')
+  ) {
+    throw new InvalidSyncDepositBoundError();
+  }
   let modifiedDepositMode: OperationMode;
   let aeraRuntime: AeraRuntimeContracts | undefined;
 
@@ -113,7 +124,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,
@@ -158,12 +170,13 @@ export async function getDepositTx(
     async: modifiedDepositMode === 'async',
     asset: token,
     publicClient,
-    slippageBps: params.slippageBps ?? DEFAULT_BPS,
+    slippageBps,
     solverTip: params.solverTip,
     maxPriceAge: params.maxPriceAge,
     aeraRuntime,
+    minUnitsOut: params.minUnitsOut,
   });
   steps.push(...depositSteps);
 
-  return await Promise.all(steps.map((step) => encodeTransactionWithAttribution(client, step)));
+  return Promise.all(steps.map((step) => encodeTransactionWithAttribution(client, step)));
 }

package/src/evm/depositQuote.ts

@@ -0,0 +1,137 @@
+import type { GauntletClient } from '../client';
+import { DEFAULT_BPS, MAX_BPS } from '../constants';
+import {
+  InvalidSlippageBPSError,
+  InvalidSyncDepositBoundError,
+  UnsupportedAssetError,
+  UnsupportedFeatureError,
+  VaultNotFoundError,
+} from '../errors';
+import {
+  applySlippageDown,
+  resolveAeraRuntimeContracts,
+  resolveAeraTokenModeSupport,
+} from './aeraContracts';
+import { getSyncDepositFeeBps, getSyncDepositQuoteValues } from './aeraContracts/v2';
+import { resolveOperationMode } from './operationMode';
+import { ContractVersion } from './types';
+import { resolveVault } from './vaults';
+
+export type SyncDepositQuote = Readonly<{
+  unitsOut: bigint;
+  minUnitsOut: bigint;
+  /** Deposit amount converted to the vault's numeraire, after the Instant Supply fee. */
+  numeraireOut: bigint;
+  /** Instant Supply fee applied to the deposited token amount, in basis points. */
+  feeBps: bigint;
+  /** Slippage tolerance used to derive `minUnitsOut`, in basis points. */
+  slippageBps: number;
+}>;
+
+export type SyncDepositQuoteParams = {
+  vaultId: string;
+  chainId?: number;
+  assetSymbol?: string;
+  amount: bigint;
+  slippageBps?: number;
+};
+
+export type SyncDepositRateParams = {
+  vaultId: string;
+  chainId?: number;
+  assetSymbol?: string;
+};
+
+export type SyncDepositRate = Readonly<{
+  /** Instant Supply fee, in basis points. Independent of the deposit amount. */
+  feeBps: bigint;
+}>;
+
+async function resolveSyncDepositContext(
+  client: GauntletClient,
+  params: SyncDepositRateParams,
+  readKind: 'quote' | 'rate'
+) {
+  const resolved = await resolveVault(client, params.vaultId, params.chainId);
+  if (!resolved) throw new VaultNotFoundError(params.vaultId, params.chainId);
+  if (resolved.protocol !== 'aera') {
+    throw new UnsupportedFeatureError(
+      readKind === 'quote'
+        ? 'Sync deposit quote is only available for Aera vaults'
+        : 'Sync deposit rate is only available for Aera vaults'
+    );
+  }
+
+  const { vault } = resolved;
+  const token =
+    vault.supplyToken.length > 1
+      ? vault.supplyToken.find(({ symbol }) => symbol === params.assetSymbol)
+      : vault.supplyToken[0];
+  if (!token) throw new UnsupportedAssetError(params.assetSymbol ?? 'unknown', params.vaultId);
+
+  const publicClient = client.getPublicClient(params.chainId ?? vault.chainId);
+  const runtime = await resolveAeraRuntimeContracts(publicClient, vault);
+  if (runtime.provisioner.version !== ContractVersion.V2) {
+    throw new UnsupportedFeatureError(
+      readKind === 'quote'
+        ? 'Sync deposit quote requires an Aera V2 provisioner'
+        : 'Sync deposit rate requires an Aera V2 provisioner'
+    );
+  }
+
+  const tokenModeSupport = await resolveAeraTokenModeSupport(publicClient, runtime, token.address, {
+    includeSyncModes: true,
+  });
+  resolveOperationMode(params.vaultId, 'sync', {
+    async: tokenModeSupport.asyncDeposit,
+    sync: tokenModeSupport.syncDeposit,
+  });
+
+  return { publicClient, vault, token, runtime };
+}
+
+/** Quotes an Aera synchronous deposit and its execution bounds. */
+export async function getSyncDepositQuote(
+  client: GauntletClient,
+  params: SyncDepositQuoteParams
+): Promise<SyncDepositQuote> {
+  const slippageBps = params.slippageBps ?? DEFAULT_BPS;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > Number(MAX_BPS)) {
+    throw new InvalidSlippageBPSError(slippageBps);
+  }
+
+  const { publicClient, vault, token, runtime } = await resolveSyncDepositContext(
+    client,
+    params,
+    'quote'
+  );
+
+  const { unitsOut, feeBps, numeraireOut } = await getSyncDepositQuoteValues(
+    publicClient,
+    runtime.provisioner.address,
+    runtime.feeCalculator.address,
+    runtime.feeCalculator.version,
+    vault.vaultAddress,
+    token.address,
+    params.amount
+  );
+  const minUnitsOut = applySlippageDown(unitsOut, slippageBps);
+  if (minUnitsOut <= 0n) throw new InvalidSyncDepositBoundError();
+
+  return { unitsOut, minUnitsOut, numeraireOut, feeBps, slippageBps };
+}
+
+/** Reads the live Instant Supply fee for a vault token, without requiring a deposit amount. */
+export async function getSyncDepositRate(
+  client: GauntletClient,
+  params: SyncDepositRateParams
+): Promise<SyncDepositRate> {
+  const { publicClient, runtime, token } = await resolveSyncDepositContext(client, params, 'rate');
+
+  const feeBps = await getSyncDepositFeeBps(
+    publicClient,
+    runtime.provisioner.address,
+    token.address
+  );
+  return { feeBps };
+}

package/src/evm/index.ts

@@ -1,10 +1,32 @@
 export { getDepositTx } from './deposit';
 export { getDepositReceiverApprovalTx } from './depositReceiverApproval';
+export { getSyncDepositQuote, getSyncDepositRate } from './depositQuote';
 export { getWithdrawTx } from './withdraw';
+export { getSyncWithdrawQuote, getSyncWithdrawRate } 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,
+  InvalidSyncDepositBoundError,
+  InvalidSyncWithdrawBoundError,
+  InvalidWithdrawParamsError,
+  RpcNotConfiguredError,
+  StalePriceError,
+  UnsupportedAssetError,
+  UnsupportedDepositModeError,
+  UnsupportedFeatureError,
+  UnsupportedProtocolError,
+  UnimplementedFeatureError,
+  VaultNotFoundError,
+} from '../errors';
 export {
   Rounding,
   convertTokenToUnits,
@@ -18,8 +40,26 @@ export {
 
 export type { EvmDepositParams } from './deposit';
 export type { EvmDepositReceiverApprovalParams } from './depositReceiverApproval';
+export type {
+  SyncDepositQuote,
+  SyncDepositQuoteParams,
+  SyncDepositRate,
+  SyncDepositRateParams,
+} from './depositQuote';
 export type { EvmWithdrawParams } from './withdraw';
+export type {
+  SyncWithdrawQuote,
+  SyncWithdrawQuoteParams,
+  SyncWithdrawCapacity,
+  SyncWithdrawQuoteContext,
+  SyncWithdrawQuoteRequest,
+  SyncWithdrawQuoteBounds,
+  SyncWithdrawRateParams,
+} 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 +71,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/userCurrentBalance.ts

@@ -4,6 +4,7 @@ import type { EvmVaultDeployment } from './types';
 import { ChainMismatchError, UnsupportedProtocolError, VaultNotFoundError } from '../errors';
 import { getMultiDepositorVault, resolveAeraRuntimeContracts } from './aeraContracts';
 import { convertUnitsToToken } from './aeraContracts/priceAndFeeCalculator';
+import { getUserUnitsRefundableUntil } from './aeraContracts/v2';
 import { provisionerV2Abi } from './abis/provisionerV2';
 import { ContractVersion } from './types';
 import { BLOCKS_3_DAYS, CHAIN_NAMES, DEFAULT_BLOCKS_3_DAYS, LOG_PAGE_SIZE } from '../constants';
@@ -59,6 +60,8 @@ export interface UserCurrentBalanceParams {
 export interface UserCurrentBalance {
   /** Chain identifier, e.g. "base" */
   chain: string;
+  /** EVM chain id of the deployment, e.g. 8453 */
+  chainId: number;
   token: Address;
   decimals: number;
   /** Assets queued via async deposit, not yet earning */
@@ -67,6 +70,8 @@ export interface UserCurrentBalance {
   balance: bigint;
   /** Assets queued via async withdraw, not yet claimable */
   pendingWithdraw: bigint;
+  /** Timestamp until which this account cannot redeem vault units. */
+  unitsLockedUntil?: bigint;
 }
 
 // V2 legacy wrapper calls can emit both receiver-aware and legacy events for one request.
@@ -101,6 +106,9 @@ async function queryDeploymentBalance(
   ]);
   const provisionerAddress = runtime.provisioner.address;
   const isV2 = runtime.provisioner.version === ContractVersion.V2;
+  const unitsLockedUntilPromise = isV2
+    ? getUserUnitsRefundableUntil(publicClient, provisionerAddress, address)
+    : Promise.resolve(undefined);
 
   const balance = await convertUnitsToToken(
     publicClient,
@@ -218,14 +226,17 @@ async function queryDeploymentBalance(
           pendingWithdrawUnits
         )
       : 0n;
+  const unitsLockedUntil = await unitsLockedUntilPromise;
 
   return {
     chain: CHAIN_NAMES[deployment.chainId] ?? `chain-${deployment.chainId}`,
+    chainId: deployment.chainId,
     token: token.address,
     decimals: token.decimals,
     pendingDeposit,
     balance,
     pendingWithdraw,
+    ...(unitsLockedUntil !== undefined ? { unitsLockedUntil } : {}),
   };
 }
 
@@ -256,7 +267,7 @@ async function queryDeploymentBalance(
  *   vaultId: 'baseUsdcPrime',
  *   address: '0xYourWalletAddress',
  * });
- * // [{ chain: 'base', token: '0x...', decimals: 6, balance: 100_000_000n, pendingDeposit: 0n, pendingWithdraw: 0n }]
+ * // [{ chain: 'base', chainId: 8453, token: '0x...', decimals: 6, balance: 100_000_000n, pendingDeposit: 0n, pendingWithdraw: 0n }]
  * ```
  */
 export async function getUserCurrentBalance(

package/src/evm/vaults.ts

@@ -8,16 +8,9 @@ export enum VaultId {
   EthUsdcPrime = 'ethUsdcPrime',
   AeraUsdAlpha = 'gtusda',
   EthUsdcPrimeV2 = 'ethUsdcPrimeV2',
-  AeraUsdAlphaStaging = 'stgusda',
-  AeraUsdAlphaDev = 'devusda',
-  AeraUsdAlphaDevDeux = 'devusda2',
   AeraLeveredFalconX = 'gpaafalconx',
-  AeraLeveredFalconXStaging = 'pytstg',
   AeraSyrupUsdc = 'gpsyrupusdc',
-  AeraSyrupUsdcStaging = 'syruppytstg',
   AeraBtcYield = 'gtbtc',
-  AeraBtcYieldStaging = 'gtbtcstaging',
-  AeraLeveredUsccStaging = 'gtusccstg',
   AeraLeveredUscc = 'gtuscc',
   AeraLend = 'gtlend',
   AeraKastEth = 'kasteth',

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 } : {}),