@gauntlet-xyz/sdk 2.5.0 → 3.0.1

package/src/api/index.ts

@@ -19,7 +19,10 @@ export type {
   TimeseriesMeta,
   TimeWindowOptions,
   TokenRef,
+  TvlBreakdownMode,
   TvlResponse,
+  TvlTimeseriesPoint,
+  TvlTimeseriesResponse,
   UserActivity,
   UserActivityResponse,
   UserAllPositionsResponse,
@@ -28,7 +31,12 @@ export type {
   UserPositionsTimeseriesResponse,
   VaultDetail,
   VaultDetailResponse,
+  VaultAllocations,
+  VaultAllocationsResponse,
   VaultMetrics,
+  VaultsOptions,
+  VaultGroupTimeseriesPoint,
+  VaultGroupTimeseriesResponse,
   VaultTimeseriesPoint,
   VaultTimeseriesResponse,
 } from './client';

package/src/client.ts

@@ -20,6 +20,9 @@ export enum AttributionMode {
 
 export type ChainId = string | number;
 
+/** The static vault manifest bundled with this SDK release; the GauntletClient default. */
+export const bundledVaultManifest = bundledManifest as VaultManifest;
+
 export interface GauntletClientConfig {
   /** Gaia API key, sent as `x-api-key` on `client.api` requests. Anonymous access is rate-limited. */
   apiKey?: string;
@@ -68,7 +71,7 @@ export class GauntletClient {
   /** Typed client for the Gaia REST API (vaults, positions, activity, tvl, prices). */
   readonly api: GauntletApi;
 
-  private _manifest: VaultManifest = bundledManifest as VaultManifest;
+  private _manifest: VaultManifest = bundledVaultManifest;
 
   constructor(config: GauntletClientConfig) {
     this.apiKey = config.apiKey;

package/src/constants.ts

@@ -17,6 +17,7 @@ export const CHAIN_NAMES: Record<number, string> = {
   8453: 'base',
   42161: 'arbitrum',
   10: 'optimism',
+  5042: 'arc',
 };
 
 // Approximate 3-day block lookback per chain based on avg block time.
@@ -25,6 +26,7 @@ export const BLOCKS_3_DAYS: Record<number, bigint> = {
   8453: 129_600n,
   42161: 1_036_800n,
   10: 129_600n,
+  5042: 518_400n,
 };
 export const DEFAULT_BLOCKS_3_DAYS = 129_600n;
 

package/src/errors.ts

@@ -202,3 +202,10 @@ export class InvalidSlippageBPSError extends GauntletSDKError {
     this.slippage = slippage;
   }
 }
+
+export class InvalidSyncDepositBoundError extends GauntletSDKError {
+  constructor() {
+    super('Sync deposit minUnitsOut requires explicit sync mode and must be greater than zero');
+    this.name = 'InvalidSyncDepositBoundError';
+  }
+}

package/src/evm/adapters/aera.ts

@@ -225,6 +225,7 @@ export const aeraAdapter: EvmProtocolAdapter = {
       solverTip = DEFAULT_SOLVER_TIP,
       maxPriceAge = DEFAULT_MAX_PRICE_AGE,
       aeraRuntime,
+      minUnitsOut: requestedMinUnitsOut,
     } = params;
 
     const runtime = requireAeraRuntime(aeraRuntime);
@@ -238,17 +239,19 @@ export const aeraAdapter: EvmProtocolAdapter = {
       throw new UnsupportedFeatureError('Aera: sync operations on V1');
     }
 
-    const tokensInForUnits = isAsync ? subtractSolverTip(amount, solverTip) : amount;
-    const vaultUnits = await getDepositUnitsOut({
-      publicClient,
-      runtime,
-      vault: vault.vaultAddress,
-      token: asset.address,
-      tokensIn: tokensInForUnits,
-      isAsync,
-    });
-
-    const minUnitsOut = applySlippageDown(vaultUnits, slippageBps);
+    const minUnitsOut =
+      requestedMinUnitsOut ??
+      applySlippageDown(
+        await getDepositUnitsOut({
+          publicClient,
+          runtime,
+          vault: vault.vaultAddress,
+          token: asset.address,
+          tokensIn: isAsync ? subtractSolverTip(amount, solverTip) : amount,
+          isAsync,
+        }),
+        slippageBps
+      );
 
     if (isAsync) {
       const deadline = getRequestDeadline(vault.expirationDays);

package/src/evm/adapters/types.ts

@@ -38,6 +38,8 @@ export interface AdapterDepositParams {
   /** Maximum price age passed to async Aera provisioner requests. Defaults to 10 days. */
   maxPriceAge?: bigint;
   aeraRuntime?: AeraRuntimeContracts;
+  /** Caller-reviewed minimum output for an explicit synchronous deposit. */
+  minUnitsOut?: bigint;
 }
 
 export type AdapterWithdrawParams = {

package/src/evm/aeraContracts/v2.ts

@@ -4,11 +4,14 @@ import {
   type GetContractReturnType,
   type PublicClient,
   getContract,
+  zeroAddress,
 } from 'viem';
+import { erc20Abi } from '../abis/erc20';
 import { priceAndFeeCalculatorV2Abi } from '../abis/priceAndFeeCalculatorV2';
 import { provisionerV2Abi } from '../abis/provisionerV2';
 import {
   Rounding,
+  convertTokenToNumeraire,
   convertTokenToUnitsIfActive,
   convertUnitsToTokenIfActive,
 } from './priceAndFeeCalculator';
@@ -74,7 +77,31 @@ async function getTokenDetails(
   });
 }
 
-async function getDepositUnitsOut({
+/**
+ * Returns the vault's currently known sync-redeem liquidity in tokens.
+ *
+ * When a pull-funds pointer is configured, the provisioner may source more tokens during the
+ * redemption, so the vault's current token balance is not a reliable liquidity limit.
+ */
+export async function getKnownSyncRedeemLiquidityTokens(
+  client: PublicClient,
+  vault: Address,
+  token: Address,
+  hasPullFundsSubmitData: boolean,
+  options: SyncRedeemReadOptions = {}
+): Promise<bigint | undefined> {
+  if (hasPullFundsSubmitData) return undefined;
+
+  return client.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: 'balanceOf',
+    args: [vault],
+    ...readAtBlock(options),
+  });
+}
+
+async function getDepositQuote({
   client,
   provisioner,
   feeCalculator,
@@ -94,12 +121,12 @@ async function getDepositUnitsOut({
   tokensIn: bigint;
   multiplierIndex: 4 | 6;
   options?: SyncRedeemReadOptions;
-}): Promise<bigint> {
+}): Promise<{ unitsOut: bigint; multiplierBps: bigint }> {
   const tokenDetails = await getTokenDetails(client, provisioner, token, options);
-  const multiplier = BigInt(tokenDetails[multiplierIndex]);
-  const adjustedTokensIn = (tokensIn * multiplier) / MAX_BPS;
+  const multiplierBps = BigInt(tokenDetails[multiplierIndex]);
+  const adjustedTokensIn = (tokensIn * multiplierBps) / MAX_BPS;
 
-  return convertTokenToUnitsIfActive(
+  const unitsOut = await convertTokenToUnitsIfActive(
     client,
     feeCalculator,
     feeCalculatorVersion,
@@ -109,6 +136,8 @@ async function getDepositUnitsOut({
     Rounding.Floor,
     options
   );
+
+  return { unitsOut, multiplierBps };
 }
 
 async function getRedeemTokenOut({
@@ -198,20 +227,22 @@ export interface SyncRedeemRate {
 }
 
 /**
- * Reads the live sync redeem rate, replicating the provisioner's effective-multiplier
- * derivation (base multiplier minus a price-age-proportional dynamic premium).
+ * Reads the live sync redeem rate and whether pull-funds calldata is configured.
+ *
+ * Both values come from the same token-details read, avoiding another RPC request when a quote
+ * needs to determine whether the vault balance is a reliable liquidity limit.
  *
  * @throws {StalePriceError} If the oracle price is older than the configured max age,
  *   in which case the on-chain sync redeem would revert.
  */
-export async function getSyncRedeemRate(
+export async function getSyncRedeemRateContext(
   client: PublicClient,
   provisioner: Address,
   vault: Address,
   token: Address,
   feeCalculator: Address,
   options: SyncRedeemReadOptions = {}
-): Promise<SyncRedeemRate> {
+): Promise<{ rate: SyncRedeemRate; hasPullFundsSubmitData: boolean }> {
   const readContext = await resolveReadContext(client, options);
   const [tokenDetails, syncRedeemDetails, anchorTimestamp] = await client.multicall({
     contracts: [
@@ -256,12 +287,28 @@ export async function getSyncRedeemRate(
       : ((blockTimestamp - priceTimestamp) * maxDynamicPremiumBps + maxPriceAge - 1n) / maxPriceAge;
 
   return {
-    baseMultiplierBps,
-    dynamicPremiumBps,
-    effectiveMultiplierBps: baseMultiplierBps - dynamicPremiumBps,
+    rate: {
+      baseMultiplierBps,
+      dynamicPremiumBps,
+      effectiveMultiplierBps: baseMultiplierBps - dynamicPremiumBps,
+    },
+    hasPullFundsSubmitData: tokenDetails[9] !== zeroAddress,
   };
 }
 
+/** Preserves the existing rate-only API for callers that do not need pull-funds state. */
+export async function getSyncRedeemRate(
+  client: PublicClient,
+  provisioner: Address,
+  vault: Address,
+  token: Address,
+  feeCalculator: Address,
+  options: SyncRedeemReadOptions = {}
+): Promise<SyncRedeemRate> {
+  return (await getSyncRedeemRateContext(client, provisioner, vault, token, feeCalculator, options))
+    .rate;
+}
+
 async function getSyncRedeemMultiplier(
   client: PublicClient,
   provisioner: Address,
@@ -315,7 +362,7 @@ export async function getAsyncDepositUnitsOut(
   token: Address,
   tokensIn: bigint
 ): Promise<bigint> {
-  return getDepositUnitsOut({
+  const quote = await getDepositQuote({
     client,
     provisioner,
     feeCalculator,
@@ -325,9 +372,10 @@ export async function getAsyncDepositUnitsOut(
     tokensIn,
     multiplierIndex: 4,
   });
+  return quote.unitsOut;
 }
 
-export async function getSyncDepositUnitsOut(
+const getSyncDepositQuote = (
   client: PublicClient,
   provisioner: Address,
   feeCalculator: Address,
@@ -335,8 +383,8 @@ export async function getSyncDepositUnitsOut(
   vault: Address,
   token: Address,
   tokensIn: bigint
-): Promise<bigint> {
-  return getDepositUnitsOut({
+) =>
+  getDepositQuote({
     client,
     provisioner,
     feeCalculator,
@@ -346,6 +394,66 @@ export async function getSyncDepositUnitsOut(
     tokensIn,
     multiplierIndex: 6,
   });
+
+export async function getSyncDepositUnitsOut(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokensIn: bigint
+): Promise<bigint> {
+  const quote = await getSyncDepositQuote(
+    client,
+    provisioner,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    tokensIn
+  );
+  return quote.unitsOut;
+}
+
+export async function getSyncDepositQuoteValues(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokensIn: bigint
+): Promise<{ unitsOut: bigint; feeBps: bigint; numeraireOut: bigint }> {
+  const { unitsOut, multiplierBps } = await getSyncDepositQuote(
+    client,
+    provisioner,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    tokensIn
+  );
+  const numeraireOut = await convertTokenToNumeraire(
+    client,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    (tokensIn * multiplierBps) / MAX_BPS
+  );
+  return { unitsOut, feeBps: MAX_BPS - multiplierBps, numeraireOut };
+}
+
+/** Reads the live Instant Supply fee for a vault token, independent of the deposit amount. */
+export async function getSyncDepositFeeBps(
+  client: PublicClient,
+  provisioner: Address,
+  token: Address,
+  options: SyncRedeemReadOptions = {}
+): Promise<bigint> {
+  const tokenDetails = await getTokenDetails(client, provisioner, token, options);
+  return MAX_BPS - BigInt(tokenDetails[6]);
 }
 
 export async function getAsyncRedeemTokenOut(

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;
 
@@ -159,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,7 +1,8 @@
 export { getDepositTx } from './deposit';
 export { getDepositReceiverApprovalTx } from './depositReceiverApproval';
+export { getSyncDepositQuote, getSyncDepositRate } from './depositQuote';
 export { getWithdrawTx } from './withdraw';
-export { getSyncWithdrawQuote } from './withdrawQuote';
+export { getSyncWithdrawQuote, getSyncWithdrawRate } from './withdrawQuote';
 export { getAeraTokenModeSupport } from './tokenModes';
 export { getUserCurrentBalance } from './userCurrentBalance';
 export { getVaults, VaultId } from './vaults';
@@ -14,6 +15,7 @@ export {
   ChainMismatchError,
   InvalidSlippageBPSError,
   InvalidSolverTipError,
+  InvalidSyncDepositBoundError,
   InvalidSyncWithdrawBoundError,
   InvalidWithdrawParamsError,
   RpcNotConfiguredError,
@@ -38,6 +40,12 @@ 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,
@@ -46,6 +54,7 @@ export type {
   SyncWithdrawQuoteContext,
   SyncWithdrawQuoteRequest,
   SyncWithdrawQuoteBounds,
+  SyncWithdrawRateParams,
 } from './withdrawQuote';
 export type { AeraTokenModeSupportParams } from './tokenModes';
 export type { SyncRedeemRate } from './aeraContracts/v2';

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',