@gauntlet-xyz/sdk 1.0.6 → 2.3.0

package/src/evm/deposit.ts

@@ -6,11 +6,22 @@ import { encodeTransactionWithAttribution, PreparedTx } from '../attribution';
 import {
   AccountRequiredError,
   VaultNotFoundError,
-  UnsupportedDepositModeError,
   UnsupportedAssetError,
   InvalidSlippageBPSError,
 } from '../errors';
+import {
+  resolveAeraRuntimeContracts,
+  resolveAeraTokenModeSupport,
+  type AeraRuntimeContracts,
+} from './aeraContracts';
 import { resolveVault } from './vaults';
+import { DEFAULT_BPS, MAX_BPS } from '../constants';
+import {
+  parseOperationMode,
+  resolveOperationMode,
+  resolveSyncOnlyOperationMode,
+  type OperationMode,
+} from './operationMode';
 
 export interface EvmDepositParams {
   vaultId: string;
@@ -19,12 +30,16 @@ export interface EvmDepositParams {
   chainId?: number;
   // Required for multiasset vaults, not utilized yet
   assetSymbol?: string;
-  /** Request async (queued) deposit. Only valid for vaults with depositMode 'async' or 'both'. */
+  /** Request async (queued) or sync deposit. Availability is read from live vault configuration. */
   depositMode?: string;
   // So a developer is able to specify a separate receiver than the tx sender
   receiver?: Address;
   /** Slippage tolerance in basis points (e.g. 100 = 1%). Defaults to 100. */
   slippageBps?: number;
+  /** Solver tip passed to async Aera provisioner requests. Defaults to 0. */
+  solverTip?: bigint;
+  /** Maximum price age passed to async Aera provisioner requests. Defaults to 10 days. */
+  maxPriceAge?: bigint;
 }
 
 /**
@@ -61,7 +76,9 @@ export async function getDepositTx(
 ): Promise<PreparedTx[]> {
   if (
     params.slippageBps !== undefined &&
-    (!Number.isInteger(params.slippageBps) || params.slippageBps < 0 || params.slippageBps > 10000)
+    (!Number.isInteger(params.slippageBps) ||
+      params.slippageBps < 0 ||
+      params.slippageBps > Number(MAX_BPS))
   ) {
     throw new InvalidSlippageBPSError(params.slippageBps);
   }
@@ -76,18 +93,6 @@ export async function getDepositTx(
 
   const { vault, protocol } = resolved;
 
-  if (params.depositMode === 'sync' && vault.depositMode === 'async') {
-    throw new UnsupportedDepositModeError(params.vaultId, 'sync', vault.depositMode);
-  }
-  if (params.depositMode === 'async' && vault.depositMode === 'sync') {
-    throw new UnsupportedDepositModeError(params.vaultId, 'async', vault.depositMode);
-  }
-  let modifiedDepositMode = params.depositMode;
-  if (params.depositMode === undefined) {
-    modifiedDepositMode = vault.depositMode === 'both' ? 'async' : vault.depositMode;
-  }
-
-  const spender = vault.provisionerAddress ?? vault.vaultAddress;
   const adapter = getAdapter(protocol);
   const publicClient = client.getPublicClient(chainId);
   const token =
@@ -99,6 +104,30 @@ export async function getDepositTx(
     throw new UnsupportedAssetError(params.assetSymbol ?? 'unknown', params.vaultId);
   }
 
+  const requestedDepositMode = parseOperationMode(params.vaultId, params.depositMode);
+  let modifiedDepositMode: OperationMode;
+  let aeraRuntime: AeraRuntimeContracts | undefined;
+
+  if (protocol === 'aera') {
+    aeraRuntime = await resolveAeraRuntimeContracts(publicClient, vault);
+    const tokenModeSupport = await resolveAeraTokenModeSupport(
+      publicClient,
+      aeraRuntime,
+      token.address
+    );
+    modifiedDepositMode = resolveOperationMode(params.vaultId, requestedDepositMode, {
+      async: tokenModeSupport.asyncDeposit,
+      sync: tokenModeSupport.syncDeposit,
+    });
+  } else {
+    modifiedDepositMode = resolveSyncOnlyOperationMode(params.vaultId, requestedDepositMode);
+  }
+
+  const spender =
+    protocol === 'aera' && modifiedDepositMode === 'async'
+      ? aeraRuntime!.provisioner.address
+      : vault.vaultAddress;
+
   // NOTE: this could be moved to the buildDeposit level
   const { sufficient } = await adapter.checkAllowance({
     publicClient,
@@ -129,7 +158,10 @@ export async function getDepositTx(
     async: modifiedDepositMode === 'async',
     asset: token,
     publicClient,
-    slippageBps: params.slippageBps,
+    slippageBps: params.slippageBps ?? DEFAULT_BPS,
+    solverTip: params.solverTip,
+    maxPriceAge: params.maxPriceAge,
+    aeraRuntime,
   });
   steps.push(...depositSteps);
 

package/src/evm/depositReceiverApproval.ts

@@ -0,0 +1,51 @@
+import type { Address } from 'viem';
+import type { GauntletClient } from '../client';
+import type { PreparedTx } from '../attribution';
+import { encodeTransactionWithAttribution } from '../attribution';
+import { AccountRequiredError, UnsupportedFeatureError, VaultNotFoundError } from '../errors';
+import { resolveAeraRuntimeContracts } from './aeraContracts';
+import * as provisionerV2 from './aeraContracts/v2';
+import { ContractVersion } from './types';
+import { resolveVault } from './vaults';
+
+export interface EvmDepositReceiverApprovalParams {
+  vaultId: string;
+  depositor: Address;
+  approved?: boolean;
+  chainId?: number;
+}
+
+/**
+ * Builds the V2 receiver-side approval transaction required before a depositor
+ * can make sync deposits to a separate receiver.
+ *
+ * The wallet account on the client is the receiver and must sign this transaction.
+ */
+export async function getDepositReceiverApprovalTx(
+  client: GauntletClient,
+  params: EvmDepositReceiverApprovalParams
+): Promise<PreparedTx> {
+  const resolved = await resolveVault(client, params.vaultId, params.chainId);
+  if (!resolved) throw new VaultNotFoundError(params.vaultId);
+
+  const chainId = params.chainId ?? resolved.vault.chainId;
+  const receiver = client.wallet?.account?.address;
+  if (!receiver) throw new AccountRequiredError();
+
+  const { vault } = resolved;
+  const publicClient = client.getPublicClient(chainId);
+  const runtime = await resolveAeraRuntimeContracts(publicClient, vault);
+  if (runtime.provisioner.version !== ContractVersion.V2) {
+    throw new UnsupportedFeatureError('Aera: deposit receiver approval on V1');
+  }
+
+  return encodeTransactionWithAttribution(client, {
+    type: 'setDepositReceiverApproval',
+    ...provisionerV2.setDepositReceiverApprovalTxRequest(
+      runtime.provisioner.address,
+      params.depositor,
+      params.approved ?? true,
+      receiver
+    ),
+  });
+}

package/src/evm/index.ts

@@ -1,11 +1,33 @@
 export { getDepositTx } from './deposit';
+export { getDepositReceiverApprovalTx } from './depositReceiverApproval';
 export { getWithdrawTx } from './withdraw';
 export { getUserCurrentBalance } from './userCurrentBalance';
 export { getVaults, VaultId } from './vaults';
+export { ContractVersion } from './types';
+export { resolveAeraRuntimeContracts, resolveContractVersion } from './aeraContracts';
+export {
+  Rounding,
+  convertTokenToUnits,
+  convertTokenToUnitsIfActive,
+  convertUnitsToToken,
+  convertUnitsToTokenIfActive,
+  getAnchorTimestamp,
+  getVaultState,
+  isVaultPaused,
+} from './aeraContracts/priceAndFeeCalculator';
 
 export type { EvmDepositParams } from './deposit';
+export type { EvmDepositReceiverApprovalParams } from './depositReceiverApproval';
 export type { EvmWithdrawParams } from './withdraw';
 export type { EvmTxStep } from './adapters/types';
-export type { VaultInfo, VaultDeployment, TokenInfo, VaultManifest } from './types';
+export type {
+  VaultInfo,
+  VaultDeployment,
+  EvmVaultDeployment,
+  TokenInfo,
+  VaultManifest,
+} from './types';
 export type { VaultFilter } from './vaults';
 export type { UserCurrentBalanceParams, UserCurrentBalance } from './userCurrentBalance';
+export type { AeraRuntimeContracts, AeraTokenModeSupport } from './aeraContracts';
+export type { NormalizedVaultPriceState } from './aeraContracts/priceAndFeeCalculator';

package/src/evm/operationMode.ts

@@ -0,0 +1,60 @@
+import { UnsupportedDepositModeError } from '../errors';
+
+export type OperationMode = 'sync' | 'async';
+
+export interface OperationModeSupport {
+  sync: boolean;
+  async: boolean;
+}
+
+function formatAvailableModes(support: OperationModeSupport): string {
+  if (support.async && support.sync) return 'both';
+  if (support.async) return 'async';
+  if (support.sync) return 'sync';
+  return 'none';
+}
+
+export function parseOperationMode(
+  vaultId: string,
+  requested: string | undefined
+): OperationMode | undefined {
+  if (requested === undefined || requested === 'sync' || requested === 'async') {
+    return requested;
+  }
+
+  throw new UnsupportedDepositModeError(vaultId, requested, 'sync, async');
+}
+
+export function resolveOperationMode(
+  vaultId: string,
+  requested: OperationMode | undefined,
+  support: OperationModeSupport
+): OperationMode {
+  const available = formatAvailableModes(support);
+
+  if (requested === 'sync') {
+    if (!support.sync) throw new UnsupportedDepositModeError(vaultId, 'sync', available);
+    return 'sync';
+  }
+
+  if (requested === 'async') {
+    if (!support.async) throw new UnsupportedDepositModeError(vaultId, 'async', available);
+    return 'async';
+  }
+
+  if (support.async) return 'async';
+  if (support.sync) return 'sync';
+
+  throw new UnsupportedDepositModeError(vaultId, 'async', available);
+}
+
+export function resolveSyncOnlyOperationMode(
+  vaultId: string,
+  requested: OperationMode | undefined
+): OperationMode {
+  if (requested === 'async') {
+    throw new UnsupportedDepositModeError(vaultId, 'async', 'sync');
+  }
+
+  return 'sync';
+}

package/src/evm/types.ts

@@ -6,14 +6,18 @@ export interface TokenInfo {
   decimals: number;
 }
 
+export const ContractVersion = {
+  V1: 'v1',
+  V2: 'v2',
+} as const;
+
+export type ContractVersion = (typeof ContractVersion)[keyof typeof ContractVersion];
+
 export interface EvmVaultDeployment {
   chain: 'evm';
   chainId: number;
   vaultAddress: Address;
-  /** Present for Aera multi-depositor vaults; absent for single-depositor and Morpho */
-  provisionerAddress?: Address;
   vaultType: 'single-depositor' | 'multi-depositor';
-  depositMode: 'sync' | 'async' | 'both';
   supplyToken: TokenInfo[];
   /** Number of days before an async request deadline expires. Defaults to 3. */
   expirationDays?: number;

package/src/evm/userCurrentBalance.ts

@@ -2,10 +2,14 @@ import { parseAbi, type Address } from 'viem';
 import type { GauntletClient } from '../client';
 import type { EvmVaultDeployment } from './types';
 import { ChainMismatchError, UnsupportedProtocolError, VaultNotFoundError } from '../errors';
-import { getMultiDepositorVault, getPriceAndFeeCalculator } from './aeraContracts';
+import { getMultiDepositorVault, resolveAeraRuntimeContracts } from './aeraContracts';
+import { convertUnitsToToken } from './aeraContracts/priceAndFeeCalculator';
+import { provisionerV2Abi } from './abis/provisionerV2';
+import { ContractVersion } from './types';
+import { BLOCKS_3_DAYS, CHAIN_NAMES, DEFAULT_BLOCKS_3_DAYS, LOG_PAGE_SIZE } from '../constants';
 
 // Inline as-const ABI items give viem full type inference for args and return types.
-const DEPOSIT_REQUESTED_ABI = [
+const DEPOSIT_REQUESTED_V1_ABI = [
   {
     type: 'event',
     name: 'DepositRequested',
@@ -23,7 +27,7 @@ const DEPOSIT_REQUESTED_ABI = [
   },
 ] as const;
 
-const REDEEM_REQUESTED_ABI = [
+const REDEEM_REQUESTED_V1_ABI = [
   {
     type: 'event',
     name: 'RedeemRequested',
@@ -41,8 +45,7 @@ const REDEEM_REQUESTED_ABI = [
   },
 ] as const;
 
-// ABI for provisioner state queries
-const provisionerStateAbi = parseAbi([
+const provisionerV1StateAbi = parseAbi([
   'function asyncDepositHashes(bytes32 asyncDepositHash) view returns (bool exists)',
   'function asyncRedeemHashes(bytes32 asyncRedeemHash) view returns (bool exists)',
 ]);
@@ -66,24 +69,22 @@ export interface UserCurrentBalance {
   pendingWithdraw: bigint;
 }
 
-const CHAIN_NAMES: Record<number, string> = {
-  1: 'ethereum',
-  8453: 'base',
-  42161: 'arbitrum',
-  10: 'optimism',
-};
+// V2 legacy wrapper calls can emit both receiver-aware and legacy events for one request.
+// Keep one row per request hash before state checks and summing pending amounts.
+function dedupeByRequestHash<TLog extends { args: { [key: string]: unknown } }>(
+  logs: TLog[],
+  hashKey: 'depositRequestHash' | 'redeemRequestHash'
+): TLog[] {
+  const seen = new Set<unknown>();
 
-// Approximate 3-day block lookback per chain based on avg block time
-const BLOCKS_3_DAYS: Record<number, bigint> = {
-  1: 21_600n,
-  8453: 129_600n,
-  42161: 1_036_800n,
-  10: 129_600n,
-};
-const DEFAULT_BLOCKS_3_DAYS = 129_600n;
-
-// Many RPC providers cap eth_getLogs to 10,000 blocks per request.
-const LOG_PAGE_SIZE = 9_999n;
+  return logs.filter((log) => {
+    const hash = log.args[hashKey];
+    // Drop malformed events and duplicates so one pending request cannot be counted twice.
+    if (hash == null || seen.has(hash)) return false;
+    seen.add(hash);
+    return true;
+  });
+}
 
 async function queryDeploymentBalance(
   client: GauntletClient,
@@ -92,20 +93,23 @@ async function queryDeploymentBalance(
 ): Promise<UserCurrentBalance> {
   const publicClient = client.getPublicClient(deployment.chainId);
   const token = deployment.supplyToken[0];
-  const provisionerAddress = deployment.provisionerAddress!;
 
   const vaultContract = getMultiDepositorVault(publicClient, deployment.vaultAddress);
-  const [units, feeCalculatorAddress] = await Promise.all([
+  const [runtime, units] = await Promise.all([
+    resolveAeraRuntimeContracts(publicClient, deployment),
     vaultContract.read.balanceOf([address]),
-    vaultContract.read.feeCalculator(),
   ]);
+  const provisionerAddress = runtime.provisioner.address;
+  const isV2 = runtime.provisioner.version === ContractVersion.V2;
 
-  const feeCalc = getPriceAndFeeCalculator(publicClient, feeCalculatorAddress);
-  const balance = await feeCalc.read.convertUnitsToToken([
+  const balance = await convertUnitsToToken(
+    publicClient,
+    runtime.feeCalculator.address,
+    runtime.feeCalculator.version,
     deployment.vaultAddress,
     token.address,
-    units,
-  ]);
+    units
+  );
 
   // Look back ~3 days for pending async requests
   const currentBlock = await publicClient.getBlockNumber();
@@ -122,46 +126,64 @@ async function queryDeploymentBalance(
   const [depositPages, redeemPages] = await Promise.all([
     Promise.all(
       chunks.map(([from, to]) =>
-        publicClient.getContractEvents({
-          address: provisionerAddress,
-          abi: DEPOSIT_REQUESTED_ABI,
-          eventName: 'DepositRequested',
-          args: { user: address },
-          fromBlock: from,
-          toBlock: to,
-        })
+        isV2
+          ? publicClient.getContractEvents({
+              address: provisionerAddress,
+              abi: provisionerV2Abi,
+              eventName: 'DepositRequested',
+              args: { receiver: address },
+              fromBlock: from,
+              toBlock: to,
+            })
+          : publicClient.getContractEvents({
+              address: provisionerAddress,
+              abi: DEPOSIT_REQUESTED_V1_ABI,
+              eventName: 'DepositRequested',
+              args: { user: address },
+              fromBlock: from,
+              toBlock: to,
+            })
       )
     ),
     Promise.all(
       chunks.map(([from, to]) =>
-        publicClient.getContractEvents({
-          address: provisionerAddress,
-          abi: REDEEM_REQUESTED_ABI,
-          eventName: 'RedeemRequested',
-          args: { user: address },
-          fromBlock: from,
-          toBlock: to,
-        })
+        isV2
+          ? publicClient.getContractEvents({
+              address: provisionerAddress,
+              abi: provisionerV2Abi,
+              eventName: 'RedeemRequested',
+              args: { user: address },
+              fromBlock: from,
+              toBlock: to,
+            })
+          : publicClient.getContractEvents({
+              address: provisionerAddress,
+              abi: REDEEM_REQUESTED_V1_ABI,
+              eventName: 'RedeemRequested',
+              args: { user: address },
+              fromBlock: from,
+              toBlock: to,
+            })
       )
     ),
   ]);
 
-  const depositLogs = depositPages.flat().filter((log) => log.args.depositRequestHash != null);
-  const redeemLogs = redeemPages.flat().filter((log) => log.args.redeemRequestHash != null);
+  const depositLogs = dedupeByRequestHash(depositPages.flat(), 'depositRequestHash');
+  const redeemLogs = dedupeByRequestHash(redeemPages.flat(), 'redeemRequestHash');
 
   // Check which requests are still pending on-chain via a single multicall
   const pendingChecks = await publicClient.multicall({
     contracts: [
       ...depositLogs.map((log) => ({
         address: provisionerAddress,
-        abi: provisionerStateAbi,
-        functionName: 'asyncDepositHashes' as const,
+        abi: isV2 ? provisionerV2Abi : provisionerV1StateAbi,
+        functionName: isV2 ? ('asyncRequestHashes' as const) : ('asyncDepositHashes' as const),
         args: [log.args.depositRequestHash!] as const,
       })),
       ...redeemLogs.map((log) => ({
         address: provisionerAddress,
-        abi: provisionerStateAbi,
-        functionName: 'asyncRedeemHashes' as const,
+        abi: isV2 ? provisionerV2Abi : provisionerV1StateAbi,
+        functionName: isV2 ? ('asyncRequestHashes' as const) : ('asyncRedeemHashes' as const),
         args: [log.args.redeemRequestHash!] as const,
       })),
     ],
@@ -187,11 +209,14 @@ async function queryDeploymentBalance(
 
   const pendingWithdraw =
     pendingWithdrawUnits > 0n
-      ? await feeCalc.read.convertUnitsToToken([
+      ? await convertUnitsToToken(
+          publicClient,
+          runtime.feeCalculator.address,
+          runtime.feeCalculator.version,
           deployment.vaultAddress,
           token.address,
-          pendingWithdrawUnits,
-        ])
+          pendingWithdrawUnits
+        )
       : 0n;
 
   return {
@@ -243,7 +268,7 @@ export async function getUserCurrentBalance(
   if (!vaultInfo) throw new VaultNotFoundError(params.vaultId);
 
   const evmDeployments = vaultInfo.deployments.filter(
-    (d): d is EvmVaultDeployment => d.chain === 'evm' && d.provisionerAddress !== undefined
+    (d): d is EvmVaultDeployment => d.chain === 'evm' && d.vaultType === 'multi-depositor'
   );
 
   if (vaultInfo.protocol !== 'aera' || evmDeployments.length === 0) {

package/src/evm/withdraw.ts

@@ -7,10 +7,21 @@ import {
   AccountRequiredError,
   VaultNotFoundError,
   UnsupportedAssetError,
-  UnsupportedDepositModeError,
   InvalidSlippageBPSError,
 } from '../errors';
+import {
+  resolveAeraRuntimeContracts,
+  resolveAeraTokenModeSupport,
+  type AeraRuntimeContracts,
+} from './aeraContracts';
 import { resolveVault } from './vaults';
+import { DEFAULT_BPS, MAX_BPS } from '../constants';
+import {
+  parseOperationMode,
+  resolveOperationMode,
+  resolveSyncOnlyOperationMode,
+  type OperationMode,
+} from './operationMode';
 
 export type EvmWithdrawParams = {
   vaultId: string;
@@ -18,12 +29,16 @@ export type EvmWithdrawParams = {
   chainId?: number;
   // Required for multiasset vaults, not utilized yet
   assetSymbol?: string;
-  /** Request async (queued) withdraw. Only valid for vaults with depositMode 'async' or 'both'. */
+  /** Request async (queued) or sync withdraw. Availability is read from live vault configuration. */
   depositMode?: string;
   // So a developer is able to specify a separate receiver than the tx sender
   receiver?: Address;
   /** Slippage tolerance in basis points (e.g. 100 = 1%). Defaults to 100. */
   slippageBps?: number;
+  /** Solver tip passed to async Aera provisioner requests. Defaults to 0. */
+  solverTip?: bigint;
+  /** Maximum price age passed to async Aera provisioner requests. Defaults to 10 days. */
+  maxPriceAge?: bigint;
 } & (
   | { shares: bigint; amount?: never; entireAmount?: never }
   | { amount: bigint; shares?: never; entireAmount?: never }
@@ -70,7 +85,9 @@ export async function getWithdrawTx(
 ): Promise<PreparedTx[]> {
   if (
     params.slippageBps !== undefined &&
-    (!Number.isInteger(params.slippageBps) || params.slippageBps < 0 || params.slippageBps > 10000)
+    (!Number.isInteger(params.slippageBps) ||
+      params.slippageBps < 0 ||
+      params.slippageBps > Number(MAX_BPS))
   ) {
     throw new InvalidSlippageBPSError(params.slippageBps);
   }
@@ -85,17 +102,6 @@ export async function getWithdrawTx(
 
   const { vault, protocol } = resolved;
 
-  if (params.depositMode === 'sync' && vault.depositMode === 'async') {
-    throw new UnsupportedDepositModeError(params.vaultId, 'sync', vault.depositMode);
-  }
-  if (params.depositMode === 'async' && vault.depositMode === 'sync') {
-    throw new UnsupportedDepositModeError(params.vaultId, 'async', vault.depositMode);
-  }
-  let modifiedDepositMode = params.depositMode;
-  if (params.depositMode === undefined) {
-    modifiedDepositMode = vault.depositMode === 'both' ? 'async' : vault.depositMode;
-  }
-
   const token =
     vault.supplyToken.length > 1
       ? vault.supplyToken.find((tInfo) => tInfo.symbol === params.assetSymbol)
@@ -107,6 +113,24 @@ export async function getWithdrawTx(
 
   const adapter = getAdapter(protocol);
   const publicClient = client.getPublicClient(chainId);
+  const requestedWithdrawMode = parseOperationMode(params.vaultId, params.depositMode);
+  let modifiedDepositMode: OperationMode;
+  let aeraRuntime: AeraRuntimeContracts | undefined;
+
+  if (protocol === 'aera') {
+    aeraRuntime = await resolveAeraRuntimeContracts(publicClient, vault);
+    const tokenModeSupport = await resolveAeraTokenModeSupport(
+      publicClient,
+      aeraRuntime,
+      token.address
+    );
+    modifiedDepositMode = resolveOperationMode(params.vaultId, requestedWithdrawMode, {
+      async: tokenModeSupport.asyncRedeem,
+      sync: tokenModeSupport.syncRedeem,
+    });
+  } else {
+    modifiedDepositMode = resolveSyncOnlyOperationMode(params.vaultId, requestedWithdrawMode);
+  }
 
   const withdrawParams = {
     vault,
@@ -115,7 +139,10 @@ export async function getWithdrawTx(
     async: modifiedDepositMode === 'async',
     asset: token,
     publicClient,
-    slippageBps: params.slippageBps,
+    slippageBps: params.slippageBps ?? DEFAULT_BPS,
+    solverTip: params.solverTip,
+    maxPriceAge: params.maxPriceAge,
+    aeraRuntime,
     ...('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/index.ts

@@ -1,5 +1,8 @@
 export { GauntletClient, AttributionMode } from './client';
 export type { GauntletClientConfig } from './client';
+export { ContractVersion } from './evm/types';
+
+export * from './api';
 
 export type {
   VaultInfo,
@@ -11,15 +14,30 @@ export type {
 export type { VaultFilter } from './evm/vaults';
 
 export { getDepositTx } from './evm/deposit';
+export { getDepositReceiverApprovalTx } from './evm/depositReceiverApproval';
 export { getWithdrawTx } from './evm/withdraw';
 export { getUserCurrentBalance } from './evm/userCurrentBalance';
 export { getVaults, VaultId } from './evm/vaults';
+export { resolveAeraRuntimeContracts, resolveContractVersion } from './evm/aeraContracts';
+export {
+  Rounding,
+  convertTokenToUnits,
+  convertTokenToUnitsIfActive,
+  convertUnitsToToken,
+  convertUnitsToTokenIfActive,
+  getAnchorTimestamp,
+  getVaultState,
+  isVaultPaused,
+} from './evm/aeraContracts/priceAndFeeCalculator';
 
 export type { EvmDepositParams } from './evm/deposit';
+export type { EvmDepositReceiverApprovalParams } from './evm/depositReceiverApproval';
 export type { EvmWithdrawParams } from './evm/withdraw';
 export type { EvmTxStep } from './evm/adapters/types';
 export type { UserCurrentBalanceParams, UserCurrentBalance } from './evm/userCurrentBalance';
 export type { PreparedTx } from './attribution';
+export type { AeraRuntimeContracts, AeraTokenModeSupport } from './evm/aeraContracts';
+export type { NormalizedVaultPriceState } from './evm/aeraContracts/priceAndFeeCalculator';
 
 export {
   GauntletSDKError,
@@ -30,7 +48,10 @@ export {
   RpcNotConfiguredError,
   AccountRequiredError,
   UnsupportedProtocolError,
+  UnsupportedFeatureError,
   InvalidWithdrawParamsError,
   UnimplementedFeatureError,
   UnitConversionError,
+  StalePriceError,
+  InvalidSolverTipError,
 } from './errors';