@haneullabs/deepbook-v3 0.1.0 → 1.0.11

package/src/contracts/utils/index.ts

@@ -1,23 +1,33 @@
-// 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 {
+	bcs,
+	BcsType,
+	TypeTag,
+	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';
+import { TransactionArgument, isArgument } from '@haneullabs/haneul/transactions';
+import { ClientWithCoreApi, HaneulClientTypes } from '@haneullabs/haneul/client';
 
 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 interface GetOptions<
+	Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {},
+> extends HaneulClientTypes.GetObjectOptions<Include> {
+	client: ClientWithCoreApi;
+}
+
+export interface GetManyOptions<
+	Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {},
+> extends HaneulClientTypes.GetObjectsOptions<Include> {
+	client: ClientWithCoreApi;
+}
+
 export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null {
 	const parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
 
@@ -42,7 +52,7 @@ export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null
 		return type ? bcs.vector(type) : null;
 	} else if ('struct' in parsedTag) {
 		const structTag = parsedTag.struct;
-		const pkg = normalizeHaneulAddress(parsedTag.struct.address);
+		const pkg = normalizeHaneulAddress(structTag.address);
 
 		if (pkg === MOVE_STDLIB_ADDRESS) {
 			if (
@@ -53,12 +63,16 @@ export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null
 			}
 
 			if (structTag.module === 'option' && structTag.name === 'Option') {
-				const type = getPureBcsSchema(structTag.typeParams[0]!);
-				return type ? bcs.vector(type) : null;
+				const type = getPureBcsSchema(structTag.typeParams[0]);
+				return type ? bcs.option(type) : null;
 			}
 		}
 
-		if (pkg === HANEUL_FRAMEWORK_ADDRESS && structTag.module === 'Object' && structTag.name === 'ID') {
+		if (
+			pkg === HANEUL_FRAMEWORK_ADDRESS &&
+			structTag.module === 'object' &&
+			(structTag.name === 'ID' || structTag.name === 'UID')
+		) {
 			return bcs.Address;
 		}
 	}
@@ -66,44 +80,38 @@ export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null
 	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[],
+	argTypes: readonly (string | null)[],
 	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));
+		throw new Error(
+			`Invalid number of arguments, expected ${parameterNames.length}, got ${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());
+		if (argType === '0x2::clock::Clock') {
+			normalizedArgs.push((tx) => tx.object.clock());
 			continue;
 		}
 
-		if (argType === `${HANEUL_FRAMEWORK_ADDRESS}::random::Random`) {
+		if (argType === '0x2::random::Random') {
 			normalizedArgs.push((tx) => tx.object.random());
 			continue;
 		}
 
-		if (argType === `${HANEUL_FRAMEWORK_ADDRESS}::clock::Clock`) {
-			normalizedArgs.push((tx) => tx.object.clock());
+		if (argType === '0x2::deny_list::DenyList') {
+			normalizedArgs.push((tx) => tx.object.denyList());
 			continue;
 		}
 
-		if (argType === `${HANEUL_SYSTEM_ADDRESS}::haneul_system::HaneulSystemState`) {
+		if (argType === '0x3::haneul_system::HaneulSystemState') {
 			normalizedArgs.push((tx) => tx.object.system());
 			continue;
 		}
@@ -111,18 +119,20 @@ export function normalizeMoveArguments(
 		let arg;
 		if (Array.isArray(args)) {
 			if (index >= args.length) {
-				throw new ValidationError(ErrorMessages.INVALID_ARGUMENT_COUNT(index + 1, args.length));
+				throw new Error(
+					`Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`,
+				);
 			}
 			arg = args[index];
 		} else {
 			if (!parameterNames) {
-				throw new ValidationError(`Expected arguments to be passed as an array`);
+				throw new Error(`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));
+			if (arg === undefined) {
+				throw new Error(`Parameter ${name} is required`);
 			}
 		}
 
@@ -133,8 +143,8 @@ export function normalizeMoveArguments(
 			continue;
 		}
 
-		const type = argTypes[i]!;
-		const bcsType = getPureBcsSchema(type);
+		const type = argTypes[i];
+		const bcsType = type === null ? null : getPureBcsSchema(type);
 
 		if (bcsType) {
 			const bytes = bcsType.serialize(arg as never);
@@ -145,7 +155,7 @@ export function normalizeMoveArguments(
 			continue;
 		}
 
-		throw new ValidationError(ErrorMessages.INVALID_ARGUMENT(stringify(arg) as string, type));
+		throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
 	}
 
 	return normalizedArgs;
@@ -154,7 +164,53 @@ export function normalizeMoveArguments(
 export class MoveStruct<
 	T extends Record<string, BcsType<any>>,
 	const Name extends string = string,
-> extends BcsStruct<T, Name> {}
+> extends BcsStruct<T, Name> {
+	async get<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
+		objectId,
+		...options
+	}: GetOptions<Include>): Promise<
+		HaneulClientTypes.Object<Include & { content: true; json: true }> & {
+			json: BcsStruct<T>['$inferType'];
+		}
+	> {
+		const [res] = await this.getMany<Include>({
+			...options,
+			objectIds: [objectId],
+		});
+
+		return res;
+	}
+
+	async getMany<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
+		client,
+		...options
+	}: GetManyOptions<Include>): Promise<
+		Array<
+			HaneulClientTypes.Object<Include & { content: true; json: true }> & {
+				json: BcsStruct<T>['$inferType'];
+			}
+		>
+	> {
+		const response = (await client.core.getObjects({
+			...options,
+			include: {
+				...options.include,
+				content: true,
+			},
+		})) as HaneulClientTypes.GetObjectsResponse<Include & { content: true }>;
+
+		return response.objects.map((obj) => {
+			if (obj instanceof Error) {
+				throw obj;
+			}
+
+			return {
+				...obj,
+				json: this.parse(obj.content),
+			};
+		});
+	}
+}
 
 export class MoveEnum<
 	T extends Record<string, BcsType<any> | null>,
@@ -162,17 +218,11 @@ export class MoveEnum<
 > extends BcsEnum<T, Name> {}
 
 export class MoveTuple<
-	T extends readonly BcsType<any>[],
+	const 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 {
+function stringify(val: unknown) {
 	if (typeof val === 'object') {
 		return JSON.stringify(val, (val: unknown) => val);
 	}

package/src/contracts/wormhole/bytes32.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = '0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94::bytes32';
+export const Bytes32 = new MoveStruct({
+	name: `${$moduleName}::Bytes32`,
+	fields: {
+		data: bcs.vector(bcs.u8()),
+	},
+});

package/src/contracts/wormhole/consumed_vaas.ts

@@ -0,0 +1,13 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import * as set from './set.js';
+const $moduleName =
+	'0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94::consumed_vaas';
+export const ConsumedVAAs = new MoveStruct({
+	name: `${$moduleName}::ConsumedVAAs`,
+	fields: {
+		hashes: set.Set,
+	},
+});

package/src/contracts/wormhole/deps/0x0000000000000000000000000000000000000000000000000000000000000002/balance.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = '0x2::balance';
+export const Balance = new MoveStruct({
+	name: `${$moduleName}::Balance`,
+	fields: {
+		value: bcs.u64(),
+	},
+});

package/src/contracts/wormhole/deps/0x0000000000000000000000000000000000000000000000000000000000000002/package.ts

@@ -0,0 +1,15 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = '0x2::package';
+export const UpgradeCap = new MoveStruct({
+	name: `${$moduleName}::UpgradeCap`,
+	fields: {
+		id: bcs.Address,
+		package: bcs.Address,
+		version: bcs.u64(),
+		policy: bcs.u8(),
+	},
+});

package/src/contracts/wormhole/deps/0x0000000000000000000000000000000000000000000000000000000000000002/table.ts

@@ -0,0 +1,13 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = '0x2::table';
+export const Table = new MoveStruct({
+	name: `${$moduleName}::Table`,
+	fields: {
+		id: bcs.Address,
+		size: bcs.u64(),
+	},
+});

package/src/contracts/wormhole/external_address.ts

@@ -0,0 +1,13 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import * as bytes32 from './bytes32.js';
+const $moduleName =
+	'0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94::external_address';
+export const ExternalAddress = new MoveStruct({
+	name: `${$moduleName}::ExternalAddress`,
+	fields: {
+		value: bytes32.Bytes32,
+	},
+});

package/src/contracts/wormhole/fee_collector.ts

@@ -0,0 +1,15 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import * as balance from './deps/0x0000000000000000000000000000000000000000000000000000000000000002/balance.js';
+const $moduleName =
+	'0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94::fee_collector';
+export const FeeCollector = new MoveStruct({
+	name: `${$moduleName}::FeeCollector`,
+	fields: {
+		fee_amount: bcs.u64(),
+		balance: balance.Balance,
+	},
+});

package/src/contracts/wormhole/set.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import * as table from './deps/0x0000000000000000000000000000000000000000000000000000000000000002/table.js';
+const $moduleName = '0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94::set';
+export const Set = new MoveStruct({
+	name: `${$moduleName}::Set`,
+	fields: {
+		items: table.Table,
+	},
+});

package/src/contracts/wormhole/state.ts

@@ -0,0 +1,25 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import * as external_address from './external_address.js';
+import * as table from './deps/0x0000000000000000000000000000000000000000000000000000000000000002/table.js';
+import * as consumed_vaas from './consumed_vaas.js';
+import * as fee_collector from './fee_collector.js';
+import * as _package from './deps/0x0000000000000000000000000000000000000000000000000000000000000002/package.js';
+const $moduleName = '0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94::state';
+export const State = new MoveStruct({
+	name: `${$moduleName}::State`,
+	fields: {
+		id: bcs.Address,
+		governance_chain: bcs.u16(),
+		governance_contract: external_address.ExternalAddress,
+		guardian_set_index: bcs.u32(),
+		guardian_sets: table.Table,
+		guardian_set_seconds_to_live: bcs.u32(),
+		consumed_vaas: consumed_vaas.ConsumedVAAs,
+		fee_collector: fee_collector.FeeCollector,
+		upgrade_cap: _package.UpgradeCap,
+	},
+});

package/src/index.ts

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Main client and configuration
-export { DeepBookClient } from './client.js';
+export { DeepBookClient, deepbook } from './client.js';
+export type { DeepBookCompatibleClient, DeepBookOptions, DeepBookClientOptions } from './client.js';
 export { DeepBookConfig } from './utils/config.js';
 
 // Core contract classes
@@ -33,7 +34,6 @@ export type {
 	Pool,
 	MarginManager,
 	MarginPool,
-	Environment,
 	Config,
 } from './types/index.js';
 
@@ -65,7 +65,21 @@ export type {
 export { OrderType, SelfMatchingOptions } from './types/index.js';
 
 // Constants and configuration maps
-export type { CoinMap, PoolMap, MarginPoolMap } from './utils/constants.js';
+export type { CoinMap, PoolMap, MarginPoolMap, DeepbookPackageIds } from './utils/constants.js';
+
+// Default configurations for mainnet and testnet
+export {
+	mainnetCoins,
+	testnetCoins,
+	mainnetPools,
+	testnetPools,
+	mainnetMarginPools,
+	testnetMarginPools,
+	mainnetPackageIds,
+	testnetPackageIds,
+	mainnetPythConfigs,
+	testnetPythConfigs,
+} from './utils/constants.js';
 export {
 	DEEP_SCALAR,
 	FLOAT_SCALAR,

package/src/pyth/pyth.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { bcs } from '@haneullabs/haneul/bcs';
-import type { HaneulClient } from '@haneullabs/haneul/client';
+import type { ClientWithCoreApi } from '@haneullabs/haneul/client';
 import type { Transaction } from '@haneullabs/haneul/transactions';
 import { coinWithBalance } from '@haneullabs/haneul/transactions';
 import { fromBase64, fromHex, parseStructTag } from '@haneullabs/haneul/utils';
@@ -10,6 +10,8 @@ import { fromBase64, fromHex, parseStructTag } from '@haneullabs/haneul/utils';
 import type { HexString } from './PriceServiceConnection.js';
 import { PriceServiceConnection } from './PriceServiceConnection.js';
 import { extractVaaBytesFromAccumulatorMessage } from './pyth-helpers.js';
+import { State as PythState } from '../contracts/pyth/state.js';
+import { State as WormholeState } from '../contracts/wormhole/state.js';
 
 const MAX_ARGUMENT_SIZE = 16 * 1024;
 export type ObjectId = string;
@@ -31,11 +33,11 @@ export class HaneulPythClient {
 	#priceFeedObjectIdCache: Map<HexString, Promise<ObjectId>> = new Map();
 	#priceTableInfo?: Promise<{ id: ObjectId; fieldType: ObjectId }>;
 	#baseUpdateFee?: Promise<number>;
-	provider: HaneulClient;
+	provider: ClientWithCoreApi;
 	pythStateId: ObjectId;
 	wormholeStateId: ObjectId;
 
-	constructor(provider: HaneulClient, pythStateId: ObjectId, wormholeStateId: ObjectId) {
+	constructor(provider: ClientWithCoreApi, pythStateId: ObjectId, wormholeStateId: ObjectId) {
 		this.provider = provider;
 		this.pythStateId = pythStateId;
 		this.wormholeStateId = wormholeStateId;
@@ -147,25 +149,28 @@ export class HaneulPythClient {
 	 */
 	async #fetchPriceFeedObjectId(feedId: HexString): Promise<ObjectId> {
 		const { id: tableId, fieldType } = await this.getPriceTableInfo();
-		const result = await this.provider.getDynamicFieldObject({
+
+		// Serialize the PriceIdentifier name using BCS (vector of bytes)
+		const nameBytes = bcs
+			.byteVector()
+			.serialize(Array.from(fromHex(feedId)))
+			.toBytes();
+
+		const result = await this.provider.core.getDynamicField({
 			parentId: tableId,
 			name: {
 				type: `${fieldType}::price_identifier::PriceIdentifier`,
-				value: {
-					bytes: Array.from(fromHex(feedId)),
-				},
+				bcs: nameBytes,
 			},
 		});
 
-		if (!result.data || !result.data.content) {
+		if (!result.dynamicField) {
 			throw new Error(`Price feed object ID for feed ID ${feedId} not found.`);
 		}
-		if (result.data.content.dataType !== 'moveObject') {
-			throw new Error('Price feed type mismatch');
-		}
 
-		const fields = result.data.content.fields as { value: string };
-		return fields.value;
+		// The value in the table is just the object ID (address)
+		const objectId = bcs.Address.parse(result.dynamicField.value.bcs);
+		return objectId;
 	}
 
 	/**
@@ -191,26 +196,27 @@ export class HaneulPythClient {
 	 * @returns Price table object ID and field type
 	 */
 	async #fetchPriceTableInfo(): Promise<{ id: ObjectId; fieldType: ObjectId }> {
-		const result = await this.provider.getDynamicFieldObject({
+		const result = await this.provider.core.getDynamicObjectField({
 			parentId: this.pythStateId,
 			name: {
 				type: 'vector<u8>',
-				value: 'price_info',
+				bcs: bcs.string().serialize('price_info').toBytes(),
 			},
 		});
 
-		if (!result.data || !result.data.type) {
+		if (!result.object) {
 			throw new Error('Price Table not found, contract may not be initialized');
 		}
 
-		const priceIdentifier = parseStructTag(result.data.type).typeParams[0];
+		const tableType = parseStructTag(result.object.type);
+		const priceIdentifier = tableType.typeParams[0];
 		if (
 			typeof priceIdentifier === 'object' &&
 			priceIdentifier !== null &&
 			priceIdentifier.name === 'PriceIdentifier' &&
 			'address' in priceIdentifier
 		) {
-			return { id: result.data.objectId, fieldType: priceIdentifier.address };
+			return { id: result.object.objectId, fieldType: priceIdentifier.address };
 		} else {
 			throw new Error('fieldType not found');
 		}
@@ -229,7 +235,17 @@ export class HaneulPythClient {
 	 * Fetches the package ID for the Wormhole contract (no caching).
 	 */
 	async #fetchWormholePackageId(): Promise<ObjectId> {
-		return await this.#getPackageId(this.wormholeStateId);
+		const result = await this.provider.core.getObject({
+			objectId: this.wormholeStateId,
+			include: { content: true },
+		});
+
+		if (!result.object?.content) {
+			throw new Error('Unable to fetch Wormhole state object');
+		}
+
+		const state = WormholeState.parse(result.object.content);
+		return state.upgrade_cap.package;
 	}
 
 	/**
@@ -246,51 +262,36 @@ export class HaneulPythClient {
 	 * Fetches the package ID for the Pyth contract (no caching).
 	 */
 	async #fetchPythPackageId(): Promise<ObjectId> {
-		return await this.#getPackageId(this.pythStateId);
-	}
-
-	/**
-	 * Fetches the package ID for a given object.
-	 *
-	 * @param objectId Object ID to fetch the package ID for.
-	 */
-	async #getPackageId(objectId: ObjectId): Promise<ObjectId> {
-		const result = await this.provider.getObject({
-			id: objectId,
-			options: { showContent: true },
+		const result = await this.provider.core.getObject({
+			objectId: this.pythStateId,
+			include: { content: true },
 		});
 
-		if (
-			result.data?.content?.dataType === 'moveObject' &&
-			'upgrade_cap' in result.data.content.fields
-		) {
-			const fields = result.data.content.fields as {
-				upgrade_cap: {
-					fields: {
-						package: ObjectId;
-					};
-				};
-			};
-			return fields.upgrade_cap.fields.package;
+		if (!result.object?.content) {
+			throw new Error(`Cannot fetch Pyth package ID for object ${this.pythStateId}`);
 		}
 
-		throw new Error(`Cannot fetch package ID for object ${objectId}`);
+		// Parse the BCS content to get the upgrade_cap.package field
+		const state = PythState.parse(result.object.content);
+		return state.upgrade_cap.package;
 	}
+
 	/**
 	 * Gets the base update fee from the Pyth state object.
 	 */
 	async #fetchBaseUpdateFee(): Promise<number> {
-		const result = await this.provider.getObject({
-			id: this.pythStateId,
-			options: { showContent: true },
+		const result = await this.provider.core.getObject({
+			objectId: this.pythStateId,
+			include: { content: true },
 		});
 
-		if (!result.data || result.data.content?.dataType !== 'moveObject') {
+		if (!result.object?.content) {
 			throw new Error('Unable to fetch Pyth state object');
 		}
 
-		const fields = result.data.content.fields as { base_update_fee: number };
-		return fields.base_update_fee;
+		// Parse the BCS content to get the base_update_fee field
+		const state = PythState.parse(result.object.content);
+		return Number(state.base_update_fee);
 	}
 
 	/**