@haneullabs/deepbook-v3 0.1.0

package/src/contracts/deepbook/registry.ts

@@ -0,0 +1,242 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** Registry holds all created pools. */
+
+import { MoveStruct, normalizeMoveArguments } from '../utils/index.js';
+import type { RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import type { Transaction } from '@haneullabs/haneul/transactions';
+import * as object from './deps/sui/object.js';
+import * as versioned from './deps/sui/versioned.js';
+import * as vec_set from './deps/sui/vec_set.js';
+import * as bag from './deps/sui/bag.js';
+import * as type_name from './deps/std/type_name.js';
+const $moduleName = '@deepbook/core::registry';
+export const REGISTRY = new MoveStruct({
+	name: `${$moduleName}::REGISTRY`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const DeepbookAdminCap = new MoveStruct({
+	name: `${$moduleName}::DeepbookAdminCap`,
+	fields: {
+		id: object.UID,
+	},
+});
+export const Registry = new MoveStruct({
+	name: `${$moduleName}::Registry`,
+	fields: {
+		id: object.UID,
+		inner: versioned.Versioned,
+	},
+});
+export const RegistryInner = new MoveStruct({
+	name: `${$moduleName}::RegistryInner`,
+	fields: {
+		allowed_versions: vec_set.VecSet(bcs.u64()),
+		pools: bag.Bag,
+		treasury_address: bcs.Address,
+	},
+});
+export const PoolKey = new MoveStruct({
+	name: `${$moduleName}::PoolKey`,
+	fields: {
+		base: type_name.TypeName,
+		quote: type_name.TypeName,
+	},
+});
+export const StableCoinKey = new MoveStruct({
+	name: `${$moduleName}::StableCoinKey`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export interface SetTreasuryAddressArguments {
+	self: RawTransactionArgument<string>;
+	treasuryAddress: RawTransactionArgument<string>;
+	Cap: RawTransactionArgument<string>;
+}
+export interface SetTreasuryAddressOptions {
+	package?: string;
+	arguments:
+		| SetTreasuryAddressArguments
+		| [
+				self: RawTransactionArgument<string>,
+				treasuryAddress: RawTransactionArgument<string>,
+				Cap: RawTransactionArgument<string>,
+		  ];
+}
+/**
+ * Sets the treasury address where the pool creation fees are sent By default, the
+ * treasury address is the publisher of the deepbook package
+ */
+export function setTreasuryAddress(options: SetTreasuryAddressOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [
+		`${packageAddress}::registry::Registry`,
+		'address',
+		`${packageAddress}::registry::DeepbookAdminCap`,
+	] satisfies string[];
+	const parameterNames = ['self', 'treasuryAddress', 'Cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'set_treasury_address',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface EnableVersionArguments {
+	self: RawTransactionArgument<string>;
+	version: RawTransactionArgument<number | bigint>;
+	Cap: RawTransactionArgument<string>;
+}
+export interface EnableVersionOptions {
+	package?: string;
+	arguments:
+		| EnableVersionArguments
+		| [
+				self: RawTransactionArgument<string>,
+				version: RawTransactionArgument<number | bigint>,
+				Cap: RawTransactionArgument<string>,
+		  ];
+}
+/**
+ * Enables a package version Only Admin can enable a package version This function
+ * does not have version restrictions
+ */
+export function enableVersion(options: EnableVersionOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [
+		`${packageAddress}::registry::Registry`,
+		'u64',
+		`${packageAddress}::registry::DeepbookAdminCap`,
+	] satisfies string[];
+	const parameterNames = ['self', 'version', 'Cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'enable_version',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface DisableVersionArguments {
+	self: RawTransactionArgument<string>;
+	version: RawTransactionArgument<number | bigint>;
+	Cap: RawTransactionArgument<string>;
+}
+export interface DisableVersionOptions {
+	package?: string;
+	arguments:
+		| DisableVersionArguments
+		| [
+				self: RawTransactionArgument<string>,
+				version: RawTransactionArgument<number | bigint>,
+				Cap: RawTransactionArgument<string>,
+		  ];
+}
+/**
+ * Disables a package version Only Admin can disable a package version This
+ * function does not have version restrictions
+ */
+export function disableVersion(options: DisableVersionOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [
+		`${packageAddress}::registry::Registry`,
+		'u64',
+		`${packageAddress}::registry::DeepbookAdminCap`,
+	] satisfies string[];
+	const parameterNames = ['self', 'version', 'Cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'disable_version',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface AddStablecoinArguments {
+	self: RawTransactionArgument<string>;
+	Cap: RawTransactionArgument<string>;
+}
+export interface AddStablecoinOptions {
+	package?: string;
+	arguments:
+		| AddStablecoinArguments
+		| [self: RawTransactionArgument<string>, Cap: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Adds a stablecoin to the whitelist Only Admin can add stablecoin */
+export function addStablecoin(options: AddStablecoinOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [
+		`${packageAddress}::registry::Registry`,
+		`${packageAddress}::registry::DeepbookAdminCap`,
+	] satisfies string[];
+	const parameterNames = ['self', 'Cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'add_stablecoin',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface RemoveStablecoinArguments {
+	self: RawTransactionArgument<string>;
+	Cap: RawTransactionArgument<string>;
+}
+export interface RemoveStablecoinOptions {
+	package?: string;
+	arguments:
+		| RemoveStablecoinArguments
+		| [self: RawTransactionArgument<string>, Cap: RawTransactionArgument<string>];
+	typeArguments: [string];
+}
+/** Removes a stablecoin from the whitelist Only Admin can remove stablecoin */
+export function removeStablecoin(options: RemoveStablecoinOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [
+		`${packageAddress}::registry::Registry`,
+		`${packageAddress}::registry::DeepbookAdminCap`,
+	] satisfies string[];
+	const parameterNames = ['self', 'Cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'remove_stablecoin',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface IsStablecoinArguments {
+	self: RawTransactionArgument<string>;
+	stableType: RawTransactionArgument<string>;
+}
+export interface IsStablecoinOptions {
+	package?: string;
+	arguments:
+		| IsStablecoinArguments
+		| [self: RawTransactionArgument<string>, stableType: RawTransactionArgument<string>];
+}
+/** Returns whether the given coin is whitelisted */
+export function isStablecoin(options: IsStablecoinOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [
+		`${packageAddress}::registry::Registry`,
+		'0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName',
+	] satisfies string[];
+	const parameterNames = ['self', 'stableType'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'is_stablecoin',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}

package/src/contracts/deepbook/state.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * State module represents the current state of the pool. It maintains all the
+ * accounts, history, and governance information. It also processes all the
+ * transactions and updates the state accordingly.
+ */
+
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import * as table from './deps/sui/table.js';
+import * as history from './history.js';
+import * as governance from './governance.js';
+import * as balances from './balances.js';
+const $moduleName = '@deepbook/core::state';
+export const State = new MoveStruct({
+	name: `${$moduleName}::State`,
+	fields: {
+		accounts: table.Table,
+		history: history.History,
+		governance: governance.Governance,
+	},
+});
+export const StakeEvent = new MoveStruct({
+	name: `${$moduleName}::StakeEvent`,
+	fields: {
+		pool_id: bcs.Address,
+		balance_manager_id: bcs.Address,
+		epoch: bcs.u64(),
+		amount: bcs.u64(),
+		stake: bcs.bool(),
+	},
+});
+export const ProposalEvent = new MoveStruct({
+	name: `${$moduleName}::ProposalEvent`,
+	fields: {
+		pool_id: bcs.Address,
+		balance_manager_id: bcs.Address,
+		epoch: bcs.u64(),
+		taker_fee: bcs.u64(),
+		maker_fee: bcs.u64(),
+		stake_required: bcs.u64(),
+	},
+});
+export const VoteEvent = new MoveStruct({
+	name: `${$moduleName}::VoteEvent`,
+	fields: {
+		pool_id: bcs.Address,
+		balance_manager_id: bcs.Address,
+		epoch: bcs.u64(),
+		from_proposal_id: bcs.option(bcs.Address),
+		to_proposal_id: bcs.Address,
+		stake: bcs.u64(),
+	},
+});
+export const RebateEventV2 = new MoveStruct({
+	name: `${$moduleName}::RebateEventV2`,
+	fields: {
+		pool_id: bcs.Address,
+		balance_manager_id: bcs.Address,
+		epoch: bcs.u64(),
+		claim_amount: balances.Balances,
+	},
+});
+export const RebateEvent = new MoveStruct({
+	name: `${$moduleName}::RebateEvent`,
+	fields: {
+		pool_id: bcs.Address,
+		balance_manager_id: bcs.Address,
+		epoch: bcs.u64(),
+		claim_amount: bcs.u64(),
+	},
+});

package/src/contracts/deepbook/trade_params.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** TradeParams module contains the trade parameters for a trading pair. */
+
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = '@deepbook/core::trade_params';
+export const TradeParams = new MoveStruct({
+	name: `${$moduleName}::TradeParams`,
+	fields: {
+		taker_fee: bcs.u64(),
+		maker_fee: bcs.u64(),
+		stake_required: bcs.u64(),
+	},
+});

package/src/contracts/deepbook/vault.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * The vault holds all of the assets for this pool. At the end of all transaction
+ * processing, the vault is used to settle the balances for the user.
+ */
+
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import * as balance from './deps/sui/balance.js';
+import * as type_name from './deps/std/type_name.js';
+const $moduleName = '@deepbook/core::vault';
+export const Vault = new MoveStruct({
+	name: `${$moduleName}::Vault`,
+	fields: {
+		base_balance: balance.Balance,
+		quote_balance: balance.Balance,
+		deep_balance: balance.Balance,
+	},
+});
+export const FlashLoan = new MoveStruct({
+	name: `${$moduleName}::FlashLoan`,
+	fields: {
+		pool_id: bcs.Address,
+		borrow_quantity: bcs.u64(),
+		type_name: type_name.TypeName,
+	},
+});
+export const FlashLoanBorrowed = new MoveStruct({
+	name: `${$moduleName}::FlashLoanBorrowed`,
+	fields: {
+		pool_id: bcs.Address,
+		borrow_quantity: bcs.u64(),
+		type_name: type_name.TypeName,
+	},
+});

package/src/contracts/utils/index.ts

@@ -0,0 +1,184 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import type { BcsType, TypeTag } from '@haneullabs/haneul/bcs';
+import { bcs, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple } from '@haneullabs/haneul/bcs';
+import { normalizeHaneulAddress } from '@haneullabs/haneul/utils';
+import type { TransactionArgument } from '@haneullabs/haneul/transactions';
+import { isArgument } from '@haneullabs/haneul/transactions';
+import { ValidationError, ErrorMessages } from '../../utils/errors.js';
+
+const MOVE_STDLIB_ADDRESS = normalizeHaneulAddress('0x1');
+const HANEUL_FRAMEWORK_ADDRESS = normalizeHaneulAddress('0x2');
+const HANEUL_SYSTEM_ADDRESS = normalizeHaneulAddress('0x3');
+
+export type RawTransactionArgument<T> = T | TransactionArgument;
+
+/**
+ * @description Get the BCS schema for a given type tag
+ * @param {string | TypeTag} typeTag - The Move type tag to get the schema for
+ * @returns {BcsType<any> | null} The BCS schema if found, null otherwise
+ */
+export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null {
+	const parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+
+	if ('u8' in parsedTag) {
+		return bcs.U8;
+	} else if ('u16' in parsedTag) {
+		return bcs.U16;
+	} else if ('u32' in parsedTag) {
+		return bcs.U32;
+	} else if ('u64' in parsedTag) {
+		return bcs.U64;
+	} else if ('u128' in parsedTag) {
+		return bcs.U128;
+	} else if ('u256' in parsedTag) {
+		return bcs.U256;
+	} else if ('address' in parsedTag) {
+		return bcs.Address;
+	} else if ('bool' in parsedTag) {
+		return bcs.Bool;
+	} else if ('vector' in parsedTag) {
+		const type = getPureBcsSchema(parsedTag.vector);
+		return type ? bcs.vector(type) : null;
+	} else if ('struct' in parsedTag) {
+		const structTag = parsedTag.struct;
+		const pkg = normalizeHaneulAddress(parsedTag.struct.address);
+
+		if (pkg === MOVE_STDLIB_ADDRESS) {
+			if (
+				(structTag.module === 'ascii' || structTag.module === 'string') &&
+				structTag.name === 'String'
+			) {
+				return bcs.String;
+			}
+
+			if (structTag.module === 'option' && structTag.name === 'Option') {
+				const type = getPureBcsSchema(structTag.typeParams[0]!);
+				return type ? bcs.vector(type) : null;
+			}
+		}
+
+		if (pkg === HANEUL_FRAMEWORK_ADDRESS && structTag.module === 'Object' && structTag.name === 'ID') {
+			return bcs.Address;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * @description Normalize Move function arguments to TransactionArguments
+ * @param {unknown[] | object} args - The arguments to normalize
+ * @param {string[]} argTypes - The expected Move type strings for each argument
+ * @param {string[]} [parameterNames] - Optional parameter names when args is an object
+ * @returns {TransactionArgument[]} Array of normalized transaction arguments
+ * @throws {Error} If arguments are invalid or don't match expected types
+ */
+export function normalizeMoveArguments(
+	args: unknown[] | object,
+	argTypes: string[],
+	parameterNames?: string[],
+): TransactionArgument[] {
+	const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+	if (parameterNames && argLen !== parameterNames.length) {
+		throw new ValidationError(ErrorMessages.INVALID_ARGUMENT_COUNT(parameterNames.length, argLen));
+	}
+
+	const normalizedArgs: TransactionArgument[] = [];
+
+	let index = 0;
+	for (const [i, argType] of argTypes.entries()) {
+		if (argType === `${HANEUL_FRAMEWORK_ADDRESS}::deny_list::DenyList`) {
+			normalizedArgs.push((tx) => tx.object.denyList());
+			continue;
+		}
+
+		if (argType === `${HANEUL_FRAMEWORK_ADDRESS}::random::Random`) {
+			normalizedArgs.push((tx) => tx.object.random());
+			continue;
+		}
+
+		if (argType === `${HANEUL_FRAMEWORK_ADDRESS}::clock::Clock`) {
+			normalizedArgs.push((tx) => tx.object.clock());
+			continue;
+		}
+
+		if (argType === `${HANEUL_SYSTEM_ADDRESS}::haneul_system::HaneulSystemState`) {
+			normalizedArgs.push((tx) => tx.object.system());
+			continue;
+		}
+
+		let arg;
+		if (Array.isArray(args)) {
+			if (index >= args.length) {
+				throw new ValidationError(ErrorMessages.INVALID_ARGUMENT_COUNT(index + 1, args.length));
+			}
+			arg = args[index];
+		} else {
+			if (!parameterNames) {
+				throw new ValidationError(`Expected arguments to be passed as an array`);
+			}
+			const name = parameterNames[index];
+			arg = args[name as keyof typeof args];
+
+			if (arg == null) {
+				throw new ValidationError(ErrorMessages.PARAMETER_REQUIRED(name));
+			}
+		}
+
+		index += 1;
+
+		if (typeof arg === 'function' || isArgument(arg)) {
+			normalizedArgs.push(arg as TransactionArgument);
+			continue;
+		}
+
+		const type = argTypes[i]!;
+		const bcsType = getPureBcsSchema(type);
+
+		if (bcsType) {
+			const bytes = bcsType.serialize(arg as never);
+			normalizedArgs.push((tx) => tx.pure(bytes));
+			continue;
+		} else if (typeof arg === 'string') {
+			normalizedArgs.push((tx) => tx.object(arg));
+			continue;
+		}
+
+		throw new ValidationError(ErrorMessages.INVALID_ARGUMENT(stringify(arg) as string, type));
+	}
+
+	return normalizedArgs;
+}
+
+export class MoveStruct<
+	T extends Record<string, BcsType<any>>,
+	const Name extends string = string,
+> extends BcsStruct<T, Name> {}
+
+export class MoveEnum<
+	T extends Record<string, BcsType<any> | null>,
+	const Name extends string,
+> extends BcsEnum<T, Name> {}
+
+export class MoveTuple<
+	T extends readonly BcsType<any>[],
+	const Name extends string,
+> extends BcsTuple<T, Name> {}
+
+/**
+ * @description Convert a value to string representation for error messages
+ * @param {unknown} val - The value to stringify
+ * @returns {unknown} String representation of the value
+ * @private
+ */
+function stringify(val: unknown): unknown {
+	if (typeof val === 'object') {
+		return JSON.stringify(val, (val: unknown) => val);
+	}
+	if (typeof val === 'bigint') {
+		return val.toString();
+	}
+
+	return val;
+}

package/src/index.ts

@@ -0,0 +1,95 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Main client and configuration
+export { DeepBookClient } from './client.js';
+export { DeepBookConfig } from './utils/config.js';
+
+// Core contract classes
+export { BalanceManagerContract } from './transactions/balanceManager.js';
+export { DeepBookContract } from './transactions/deepbook.js';
+export { DeepBookAdminContract } from './transactions/deepbookAdmin.js';
+export { FlashLoanContract } from './transactions/flashLoans.js';
+export { GovernanceContract } from './transactions/governance.js';
+
+// Margin trading contracts
+export { MarginAdminContract } from './transactions/marginAdmin.js';
+export { MarginMaintainerContract } from './transactions/marginMaintainer.js';
+export { MarginManagerContract } from './transactions/marginManager.js';
+export { MarginPoolContract } from './transactions/marginPool.js';
+export { PoolProxyContract } from './transactions/poolProxy.js';
+export { MarginTPSLContract } from './transactions/marginTPSL.js';
+
+// Pyth price feed integration
+export { HaneulPythClient, HaneulPriceServiceConnection } from './pyth/pyth.js';
+
+// BCS types for parsing on-chain data
+export { Account, Balances, Order, OrderDeepPrice, VecSet } from './types/bcs.js';
+
+// TypeScript interfaces and types
+export type {
+	BalanceManager,
+	Coin,
+	Pool,
+	MarginManager,
+	MarginPool,
+	Environment,
+	Config,
+} from './types/index.js';
+
+// Trading parameter interfaces
+export type {
+	PlaceLimitOrderParams,
+	PlaceMarketOrderParams,
+	PlaceMarginLimitOrderParams,
+	PlaceMarginMarketOrderParams,
+	SwapParams,
+	ProposalParams,
+	MarginProposalParams,
+	CreatePoolAdminParams,
+	CreatePermissionlessPoolParams,
+	SetEwmaParams,
+	PoolConfigParams,
+	MarginPoolConfigParams,
+	InterestConfigParams,
+} from './types/index.js';
+
+// TPSL (Take Profit / Stop Loss) parameter interfaces
+export type {
+	PendingLimitOrderParams,
+	PendingMarketOrderParams,
+	AddConditionalOrderParams,
+} from './types/index.js';
+
+// Enums for trading
+export { OrderType, SelfMatchingOptions } from './types/index.js';
+
+// Constants and configuration maps
+export type { CoinMap, PoolMap, MarginPoolMap } from './utils/constants.js';
+export {
+	DEEP_SCALAR,
+	FLOAT_SCALAR,
+	GAS_BUDGET,
+	MAX_TIMESTAMP,
+	POOL_CREATION_FEE_DEEP,
+	PRICE_INFO_OBJECT_MAX_AGE_MS,
+} from './utils/config.js';
+
+// Error handling utilities
+export {
+	DeepBookError,
+	ResourceNotFoundError,
+	ConfigurationError,
+	ValidationError,
+	ErrorMessages,
+} from './utils/errors.js';
+
+// Validation utilities
+export {
+	validateRequired,
+	validateAddress,
+	validatePositiveNumber,
+	validateNonNegativeNumber,
+	validateRange,
+	validateNonEmptyArray,
+} from './utils/validation.js';

package/src/pyth/PriceServiceConnection.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import axios from 'axios';
+import type { AxiosInstance } from 'axios';
+import axiosRetry from 'axios-retry';
+
+export type HexString = string;
+export type PriceFeedRequestConfig = {
+	verbose?: boolean;
+	binary?: boolean;
+};
+export type PriceServiceConnectionConfig = {
+	timeout?: number;
+	httpRetries?: number;
+};
+export class PriceServiceConnection {
+	private httpClient: AxiosInstance;
+	/**
+	 * Constructs a new Connection.
+	 *
+	 * @param endpoint endpoint URL to the price service.
+	 * @param config Optional configuration for custom setups.
+	 */
+	constructor(endpoint: string, config?: PriceServiceConnectionConfig) {
+		this.httpClient = axios.create({
+			baseURL: endpoint,
+			timeout: config?.timeout || 5000,
+		});
+		axiosRetry(this.httpClient, {
+			retries: config?.httpRetries || 3,
+			retryDelay: axiosRetry.exponentialDelay,
+		});
+	}
+	/**
+	 * Fetch latest VAAs of given price IDs.
+	 *
+	 * @param priceIds Array of hex-encoded price IDs.
+	 * @returns Array of base64 encoded VAAs.
+	 */
+	async getLatestVaas(priceIds: HexString[]): Promise<string[]> {
+		const response = await this.httpClient.get('/api/latest_vaas', {
+			params: {
+				ids: priceIds,
+			},
+		});
+		return response.data;
+	}
+}