@haneullabs/haneulns 0.1.0

package/src/haneulns-transaction.ts

@@ -0,0 +1,555 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@haneullabs/haneul/bcs';
+import type {
+	Transaction,
+	TransactionObjectArgument,
+	TransactionObjectInput,
+} from '@haneullabs/haneul/transactions';
+import { isValidHaneulNSName, normalizeHaneulNSName, HANEUL_CLOCK_OBJECT_ID } from '@haneullabs/haneul/utils';
+
+import { ALLOWED_METADATA, MAX_U64 } from './constants.js';
+import { isNestedSubName, isSubName, zeroCoin } from './helpers.js';
+import type { HaneulnsClient } from './haneulns-client.js';
+import type { DiscountInfo, ReceiptParams, RegistrationParams, RenewalParams } from './types.js';
+
+export class HaneulnsTransaction {
+	haneulnsClient: HaneulnsClient;
+	transaction: Transaction;
+
+	constructor(client: HaneulnsClient, transaction: Transaction) {
+		this.haneulnsClient = client;
+		this.transaction = transaction;
+	}
+
+	/**
+	 * Registers a domain for a number of years.
+	 */
+	register(params: RegistrationParams): TransactionObjectArgument {
+		if (params.couponCode && params.discountInfo) {
+			throw new Error('Cannot apply both coupon and discount NFT');
+		}
+
+		const paymentIntent = this.initRegistration(params.domain);
+		if (params.couponCode) {
+			this.applyCoupon(paymentIntent, params.couponCode);
+		}
+		if (params.discountInfo) {
+			this.applyDiscount(paymentIntent, params.discountInfo);
+		}
+		const priceAfterDiscount = this.calculatePriceAfterDiscount(
+			paymentIntent,
+			params.coinConfig.type,
+		);
+		const receipt = this.generateReceipt({
+			paymentIntent,
+			priceAfterDiscount,
+			coinConfig: params.coinConfig,
+			coin: params.coin,
+			maxAmount: params.maxAmount,
+			priceInfoObjectId: params.priceInfoObjectId,
+		});
+		const nft = this.finalizeRegister(receipt);
+
+		if (params.years > 1) {
+			this.renew({
+				nft,
+				years: params.years - 1,
+				coinConfig: params.coinConfig,
+				coin: params.coin,
+				couponCode: params.couponCode,
+				discountInfo: params.discountInfo,
+				maxAmount: params.maxAmount,
+				priceInfoObjectId: params.priceInfoObjectId,
+			});
+		}
+
+		return nft as TransactionObjectArgument;
+	}
+
+	/**
+	 * Renews an NFT for a number of years.
+	 */
+	renew(params: RenewalParams): void {
+		if (params.couponCode && params.discountInfo) {
+			throw new Error('Cannot apply both coupon and discount NFT');
+		}
+
+		const paymentIntent = this.initRenewal(params.nft, params.years);
+		if (params.couponCode) {
+			this.applyCoupon(paymentIntent, params.couponCode);
+		}
+		if (params.discountInfo) {
+			this.applyDiscount(paymentIntent, params.discountInfo);
+		}
+		const priceAfterDiscount = this.calculatePriceAfterDiscount(
+			paymentIntent,
+			params.coinConfig.type,
+		);
+		const receipt = this.generateReceipt({
+			paymentIntent,
+			priceAfterDiscount,
+			coinConfig: params.coinConfig,
+			coin: params.coin,
+			maxAmount: params.maxAmount,
+			priceInfoObjectId: params.priceInfoObjectId,
+		});
+		this.finalizeRenew(receipt, params.nft);
+	}
+
+	initRegistration(domain: string): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.packageId}::payment::init_registration`,
+			arguments: [this.transaction.object(config.haneulns), this.transaction.pure.string(domain)],
+		});
+	}
+
+	initRenewal(nft: TransactionObjectInput, years: number): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.packageId}::payment::init_renewal`,
+			arguments: [
+				this.transaction.object(config.haneulns),
+				this.transaction.object(nft),
+				this.transaction.pure.u8(years),
+			],
+		});
+	}
+
+	calculatePrice(
+		baseAmount: TransactionObjectArgument,
+		paymentType: string,
+		priceInfoObjectId: string,
+	): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.payments.packageId}::payments::calculate_price`,
+			arguments: [
+				this.transaction.object(config.haneulns),
+				baseAmount,
+				this.transaction.object.clock(),
+				this.transaction.object(priceInfoObjectId),
+			],
+			typeArguments: [paymentType],
+		});
+	}
+
+	handleBasePayment(
+		paymentIntent: TransactionObjectArgument,
+		payment: TransactionObjectArgument,
+		paymentType: string,
+	): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.payments.packageId}::payments::handle_base_payment`,
+			arguments: [
+				this.transaction.object(config.haneulns),
+				this.transaction.object(config.bbb.vault),
+				paymentIntent,
+				payment,
+			],
+			typeArguments: [paymentType],
+		});
+	}
+
+	handlePayment(
+		paymentIntent: TransactionObjectArgument,
+		payment: TransactionObjectArgument,
+		paymentType: string,
+		priceInfoObjectId: string,
+		maxAmount: bigint = MAX_U64,
+	): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.payments.packageId}::payments::handle_payment`,
+			arguments: [
+				this.transaction.object(config.haneulns),
+				this.transaction.object(config.bbb.vault),
+				paymentIntent,
+				payment,
+				this.transaction.object.clock(),
+				this.transaction.object(priceInfoObjectId),
+				this.transaction.pure.u64(maxAmount),
+			],
+			typeArguments: [paymentType],
+		});
+	}
+
+	finalizeRegister(receipt: TransactionObjectArgument): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.packageId}::payment::register`,
+			arguments: [receipt, this.transaction.object(config.haneulns), this.transaction.object.clock()],
+		});
+	}
+
+	finalizeRenew(
+		receipt: TransactionObjectArgument,
+		nft: TransactionObjectInput,
+	): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.packageId}::payment::renew`,
+			arguments: [
+				receipt,
+				this.transaction.object(config.haneulns),
+				this.transaction.object(nft),
+				this.transaction.object.clock(),
+			],
+		});
+	}
+
+	calculatePriceAfterDiscount(
+		paymentIntent: TransactionObjectArgument,
+		paymentType: string,
+	): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.payments.packageId}::payments::calculate_price_after_discount`,
+			arguments: [this.transaction.object(config.haneulns), paymentIntent],
+			typeArguments: [paymentType],
+		});
+	}
+
+	generateReceipt(params: ReceiptParams): TransactionObjectArgument {
+		const baseAssetPurchase = params.coinConfig.feed === '';
+		if (baseAssetPurchase) {
+			const payment = params.coin
+				? this.transaction.splitCoins(this.transaction.object(params.coin), [
+						params.priceAfterDiscount,
+					])
+				: zeroCoin(this.transaction, params.coinConfig.type);
+			const receipt = this.handleBasePayment(params.paymentIntent, payment, params.coinConfig.type);
+			return receipt;
+		} else {
+			const priceInfoObjectId = params.priceInfoObjectId;
+			if (!priceInfoObjectId)
+				throw new Error('Price info object ID is required for non-base asset purchases');
+			const price = this.calculatePrice(
+				params.priceAfterDiscount,
+				params.coinConfig.type,
+				priceInfoObjectId,
+			);
+			if (!params.coin) throw new Error('coin input is required');
+			const payment = this.transaction.splitCoins(this.transaction.object(params.coin!), [price]);
+			const receipt = this.handlePayment(
+				params.paymentIntent,
+				payment,
+				params.coinConfig.type,
+				priceInfoObjectId,
+				params.maxAmount,
+			);
+			return receipt;
+		}
+	}
+
+	/**
+	 * Applies a coupon to the payment intent.
+	 */
+	applyCoupon(intent: TransactionObjectArgument, couponCode: string): TransactionObjectArgument {
+		const config = this.haneulnsClient.config;
+		return this.transaction.moveCall({
+			target: `${config.coupons.packageId}::coupon_house::apply_coupon`,
+			arguments: [
+				this.transaction.object(config.haneulns),
+				intent,
+				this.transaction.pure.string(couponCode),
+				this.transaction.object.clock(),
+			],
+		});
+	}
+
+	/**
+	 * Applies a discount to the payment intent.
+	 */
+	applyDiscount(intent: TransactionObjectArgument, discountInfo: DiscountInfo): void {
+		const config = this.haneulnsClient.config;
+
+		if (discountInfo.isFreeClaim) {
+			this.transaction.moveCall({
+				target: `${config.discountsPackage.packageId}::free_claims::free_claim`,
+				arguments: [
+					this.transaction.object(config.discountsPackage.discountHouseId),
+					this.transaction.object(config.haneulns),
+					intent,
+					this.transaction.object(discountInfo.discountNft),
+				],
+				typeArguments: [discountInfo.type],
+			});
+		} else {
+			this.transaction.moveCall({
+				target: `${config.discountsPackage.packageId}::discounts::apply_percentage_discount`,
+				arguments: [
+					this.transaction.object(config.discountsPackage.discountHouseId),
+					intent,
+					this.transaction.object(config.haneulns),
+					this.transaction.object(discountInfo.discountNft),
+				],
+				typeArguments: [discountInfo.type],
+			});
+		}
+	}
+
+	/**
+	 * Creates a subdomain.
+	 */
+	createSubName({
+		parentNft,
+		name,
+		expirationTimestampMs,
+		allowChildCreation,
+		allowTimeExtension,
+	}: {
+		parentNft: TransactionObjectInput;
+		name: string;
+		expirationTimestampMs: number;
+		allowChildCreation: boolean;
+		allowTimeExtension: boolean;
+	}) {
+		if (!isValidHaneulNSName(name)) throw new Error('Invalid HaneulNS name');
+		const isParentSubdomain = isNestedSubName(name);
+		if (!this.haneulnsClient.config.haneulns) throw new Error('HaneulNS Object ID not found');
+		if (!this.haneulnsClient.config.subNamesPackageId)
+			throw new Error('Subnames package ID not found');
+		if (isParentSubdomain && !this.haneulnsClient.config.tempSubdomainsProxyPackageId)
+			throw new Error('Subnames proxy package ID not found');
+
+		const subNft = this.transaction.moveCall({
+			target: isParentSubdomain
+				? `${this.haneulnsClient.config.tempSubdomainsProxyPackageId}::subdomain_proxy::new`
+				: `${this.haneulnsClient.config.subNamesPackageId}::subdomains::new`,
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.object(parentNft),
+				this.transaction.object(HANEUL_CLOCK_OBJECT_ID),
+				this.transaction.pure.string(normalizeHaneulNSName(name, 'dot')),
+				this.transaction.pure.u64(expirationTimestampMs),
+				this.transaction.pure.bool(!!allowChildCreation),
+				this.transaction.pure.bool(!!allowTimeExtension),
+			],
+		});
+
+		return subNft;
+	}
+
+	/**
+	 * Builds the PTB to create a leaf subdomain.
+	 * Parent can be a `HaneulnsRegistration` or a `SubDomainRegistration` object.
+	 * Can be passed in as an ID or a TransactionArgument.
+	 */
+	createLeafSubName({
+		parentNft,
+		name,
+		targetAddress,
+	}: {
+		parentNft: TransactionObjectInput;
+		name: string;
+		targetAddress: string;
+	}) {
+		if (!isValidHaneulNSName(name)) throw new Error('Invalid HaneulNS name');
+		const isParentSubdomain = isNestedSubName(name);
+		if (!this.haneulnsClient.config.haneulns) throw new Error('HaneulNS Object ID not found');
+		if (!this.haneulnsClient.config.subNamesPackageId)
+			throw new Error('Subnames package ID not found');
+		if (isParentSubdomain && !this.haneulnsClient.config.tempSubdomainsProxyPackageId)
+			throw new Error('Subnames proxy package ID not found');
+
+		this.transaction.moveCall({
+			target: isParentSubdomain
+				? `${this.haneulnsClient.config.tempSubdomainsProxyPackageId}::subdomain_proxy::new_leaf`
+				: `${this.haneulnsClient.config.subNamesPackageId}::subdomains::new_leaf`,
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.object(parentNft),
+				this.transaction.object(HANEUL_CLOCK_OBJECT_ID),
+				this.transaction.pure.string(normalizeHaneulNSName(name, 'dot')),
+				this.transaction.pure.address(targetAddress),
+			],
+		});
+	}
+
+	/**
+	 * Removes a leaf subname.
+	 */
+	removeLeafSubName({ parentNft, name }: { parentNft: TransactionObjectInput; name: string }) {
+		if (!isValidHaneulNSName(name)) throw new Error('Invalid HaneulNS name');
+		const isParentSubdomain = isNestedSubName(name);
+		if (!isSubName(name)) throw new Error('This can only be invoked for subnames');
+		if (!this.haneulnsClient.config.haneulns) throw new Error('HaneulNS Object ID not found');
+		if (!this.haneulnsClient.config.subNamesPackageId)
+			throw new Error('Subnames package ID not found');
+		if (isParentSubdomain && !this.haneulnsClient.config.tempSubdomainsProxyPackageId)
+			throw new Error('Subnames proxy package ID not found');
+
+		this.transaction.moveCall({
+			target: isParentSubdomain
+				? `${this.haneulnsClient.config.tempSubdomainsProxyPackageId}::subdomain_proxy::remove_leaf`
+				: `${this.haneulnsClient.config.subNamesPackageId}::subdomains::remove_leaf`,
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.object(parentNft),
+				this.transaction.object(HANEUL_CLOCK_OBJECT_ID),
+				this.transaction.pure.string(normalizeHaneulNSName(name, 'dot')),
+			],
+		});
+	}
+
+	/**
+	 * Sets the target address of an NFT.
+	 */
+	setTargetAddress({
+		nft, // Can be string or argument
+		address,
+		isSubname,
+	}: {
+		nft: TransactionObjectInput;
+		address?: string;
+		isSubname?: boolean;
+	}) {
+		if (isSubname && !this.haneulnsClient.config.tempSubdomainsProxyPackageId)
+			throw new Error('Subnames proxy package ID not found');
+
+		this.transaction.moveCall({
+			target: isSubname
+				? `${this.haneulnsClient.config.tempSubdomainsProxyPackageId}::subdomain_proxy::set_target_address`
+				: `${this.haneulnsClient.config.packageId}::controller::set_target_address`,
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.object(nft),
+				this.transaction.pure(bcs.option(bcs.Address).serialize(address).toBytes()),
+				this.transaction.object(HANEUL_CLOCK_OBJECT_ID),
+			],
+		});
+	}
+
+	/**
+	 * Sets a default name for the user.
+	 */
+	setDefault(name: string) {
+		if (!isValidHaneulNSName(name)) throw new Error('Invalid HaneulNS name');
+		if (!this.haneulnsClient.config.haneulns) throw new Error('HaneulNS Object ID not found');
+
+		this.transaction.moveCall({
+			target: `${this.haneulnsClient.config.packageId}::controller::set_reverse_lookup`,
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.pure.string(normalizeHaneulNSName(name, 'dot')),
+			],
+		});
+	}
+
+	/**
+	 * Edits the setup of a subname.
+	 */
+	editSetup({
+		parentNft,
+		name,
+		allowChildCreation,
+		allowTimeExtension,
+	}: {
+		parentNft: TransactionObjectInput;
+		name: string;
+		allowChildCreation: boolean;
+		allowTimeExtension: boolean;
+	}) {
+		if (!isValidHaneulNSName(name)) throw new Error('Invalid HaneulNS name');
+		const isParentSubdomain = isNestedSubName(name);
+		if (!this.haneulnsClient.config.haneulns) throw new Error('HaneulNS Object ID not found');
+		if (!isParentSubdomain && !this.haneulnsClient.config.subNamesPackageId)
+			throw new Error('Subnames package ID not found');
+		if (isParentSubdomain && !this.haneulnsClient.config.tempSubdomainsProxyPackageId)
+			throw new Error('Subnames proxy package ID not found');
+
+		this.transaction.moveCall({
+			target: isParentSubdomain
+				? `${this.haneulnsClient.config.tempSubdomainsProxyPackageId}::subdomain_proxy::edit_setup`
+				: `${this.haneulnsClient.config.subNamesPackageId}::subdomains::edit_setup`,
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.object(parentNft),
+				this.transaction.object(HANEUL_CLOCK_OBJECT_ID),
+				this.transaction.pure.string(normalizeHaneulNSName(name, 'dot')),
+				this.transaction.pure.bool(!!allowChildCreation),
+				this.transaction.pure.bool(!!allowTimeExtension),
+			],
+		});
+	}
+
+	/**
+	 * Extends the expiration of a subname.
+	 */
+	extendExpiration({
+		nft,
+		expirationTimestampMs,
+	}: {
+		nft: TransactionObjectInput;
+		expirationTimestampMs: number;
+	}) {
+		if (!this.haneulnsClient.config.haneulns) throw new Error('HaneulNS Object ID not found');
+		if (!this.haneulnsClient.config.subNamesPackageId)
+			throw new Error('Subnames package ID not found');
+
+		this.transaction.moveCall({
+			target: `${this.haneulnsClient.config.subNamesPackageId}::subdomains::extend_expiration`,
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.object(nft),
+				this.transaction.pure.u64(expirationTimestampMs),
+			],
+		});
+	}
+
+	/**
+	 * Sets the user data of an NFT.
+	 */
+	setUserData({
+		nft,
+		value,
+		key,
+		isSubname,
+	}: {
+		nft: TransactionObjectInput;
+		value: string;
+		key: string;
+		isSubname?: boolean;
+	}) {
+		if (!this.haneulnsClient.config.haneulns) throw new Error('HaneulNS Object ID not found');
+		if (isSubname && !this.haneulnsClient.config.tempSubdomainsProxyPackageId)
+			throw new Error('Subnames proxy package ID not found');
+
+		if (!Object.values(ALLOWED_METADATA).some((x) => x === key)) throw new Error('Invalid key');
+
+		this.transaction.moveCall({
+			target: isSubname
+				? `${this.haneulnsClient.config.tempSubdomainsProxyPackageId}::subdomain_proxy::set_user_data`
+				: `${this.haneulnsClient.config.packageId}::controller::set_user_data`,
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.object(nft),
+				this.transaction.pure.string(key),
+				this.transaction.pure.string(value),
+				this.transaction.object(HANEUL_CLOCK_OBJECT_ID),
+			],
+		});
+	}
+
+	/**
+	 * Burns an expired NFT to collect storage rebates.
+	 */
+	burnExpired({ nft, isSubname }: { nft: TransactionObjectInput; isSubname?: boolean }) {
+		if (!this.haneulnsClient.config.haneulns) throw new Error('HaneulNS Object ID not found');
+
+		this.transaction.moveCall({
+			target: `${this.haneulnsClient.config.packageId}::controller::${
+				isSubname ? 'burn_expired_subname' : 'burn_expired'
+			}`, // Update this
+			arguments: [
+				this.transaction.object(this.haneulnsClient.config.haneulns),
+				this.transaction.object(nft),
+				this.transaction.object(HANEUL_CLOCK_OBJECT_ID),
+			],
+		});
+	}
+}

package/src/helpers.ts

@@ -0,0 +1,52 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Transaction } from '@haneullabs/haneul/transactions';
+import { normalizeHaneulNSName } from '@haneullabs/haneul/utils';
+
+export function isSubName(name: string): boolean {
+	return normalizeHaneulNSName(name, 'dot').split('.').length > 2;
+}
+
+/**
+ * Checks if a name is a nested subname.
+ * A nested subdomain is a subdomain that is a subdomain of another subdomain.
+ * @param name The name to check (e.g test.example.sub.haneul)
+ */
+export function isNestedSubName(name: string): boolean {
+	return normalizeHaneulNSName(name, 'dot').split('.').length > 3;
+}
+
+/**
+ * The years must be between 1 and 5.
+ */
+export function validateYears(years: number) {
+	if (!(years > 0 && years < 6)) throw new Error('Years must be between 1 and 5');
+}
+
+export function zeroCoin(tx: Transaction, type: string) {
+	return tx.moveCall({
+		target: '0x2::coin::zero',
+		typeArguments: [type],
+	});
+}
+
+export function getConfigType(haneulnsPackageV1: string, innerType: string): string {
+	return `${haneulnsPackageV1}::haneulns::ConfigKey<${innerType}>`;
+}
+
+export function getDomainType(haneulnsPackageV1: string): string {
+	return `${haneulnsPackageV1}::domain::Domain`;
+}
+
+export function getPricelistConfigType(haneulnsPackageId: string): string {
+	return `${haneulnsPackageId}::pricing_config::PricingConfig`;
+}
+
+export function getRenewalPricelistConfigType(haneulnsPackageId: string): string {
+	return `${haneulnsPackageId}::pricing_config::RenewalConfig`;
+}
+
+export function getCoinDiscountConfigType(paymentPackageId: string): string {
+	return `${paymentPackageId}::payments::PaymentsConfig`;
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+export { HaneulnsClient } from './haneulns-client.js';
+export { HaneulnsTransaction } from './haneulns-transaction.js';
+export type { Network, HaneulnsClientConfig, Config } from './types.js';
+export { ALLOWED_METADATA, mainPackage } from './constants.js';
+export {
+	isSubName,
+	isNestedSubName,
+	validateYears,
+	getConfigType,
+	getDomainType,
+	getPricelistConfigType,
+	getRenewalPricelistConfigType,
+	getCoinDiscountConfigType,
+} from './helpers.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;
+	}
+}

package/src/pyth/pyth-helpers.ts

@@ -0,0 +1,23 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Extracts the VAA bytes embedded in an accumulator message.
+ *
+ * @param accumulatorMessage The accumulator price update message as a Uint8Array.
+ * @returns VAA bytes as a Uint8Array.
+ */
+export function extractVaaBytesFromAccumulatorMessage(accumulatorMessage: Uint8Array): Uint8Array {
+	const dataView = new DataView(
+		accumulatorMessage.buffer,
+		accumulatorMessage.byteOffset,
+		accumulatorMessage.byteLength,
+	);
+
+	const trailingPayloadSize = dataView.getUint8(6);
+	const vaaSizeOffset = 7 + trailingPayloadSize + 1; // Header (7 bytes), trailing payload size, proof type
+	const vaaSize = dataView.getUint16(vaaSizeOffset, false); // Read 2 bytes for VAA size (big-endian)
+	const vaaOffset = vaaSizeOffset + 2; // VAA size is 2 bytes
+
+	return accumulatorMessage.subarray(vaaOffset, vaaOffset + vaaSize);
+}