@haneullabs/haneulns 0.1.0 → 1.0.3

package/src/haneulns-transaction.ts

@@ -14,6 +14,13 @@ import { isNestedSubName, isSubName, zeroCoin } from './helpers.js';
 import type { HaneulnsClient } from './haneulns-client.js';
 import type { DiscountInfo, ReceiptParams, RegistrationParams, RenewalParams } from './types.js';
 
+import * as payment from './contracts/haneulns/payment.js';
+import * as controller from './contracts/haneulns/controller.js';
+import * as paymentsModule from './contracts/haneulns_payments/payments.js';
+import * as couponHouse from './contracts/haneulns_coupons/coupon_house.js';
+import * as discounts from './contracts/haneulns_discounts/discounts.js';
+import * as freeClaims from './contracts/haneulns_discounts/free_claims.js';
+
 export class HaneulnsTransaction {
 	haneulnsClient: HaneulnsClient;
 	transaction: Transaction;
@@ -100,22 +107,22 @@ export class HaneulnsTransaction {
 
 	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)],
-		});
+		return this.transaction.add(
+			payment.initRegistration({
+				package: config.packageId,
+				arguments: { haneulns: config.haneulns, 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),
-			],
-		});
+		return this.transaction.add(
+			payment.initRenewal({
+				package: config.packageId,
+				arguments: { haneulns: config.haneulns, nft: this.transaction.object(nft), years },
+			}),
+		);
 	}
 
 	calculatePrice(
@@ -124,65 +131,71 @@ export class HaneulnsTransaction {
 		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],
-		});
+		return this.transaction.add(
+			paymentsModule.calculatePrice({
+				package: config.payments.packageId,
+				arguments: {
+					haneulns: config.haneulns,
+					baseAmount,
+					priceInfoObject: priceInfoObjectId,
+				},
+				typeArguments: [paymentType],
+			}),
+		);
 	}
 
 	handleBasePayment(
 		paymentIntent: TransactionObjectArgument,
-		payment: TransactionObjectArgument,
+		paymentArg: 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],
-		});
+		return this.transaction.add(
+			paymentsModule.handleBasePayment({
+				package: config.payments.packageId,
+				arguments: {
+					haneulns: config.haneulns,
+					bbbVault: config.bbb.vault,
+					intent: paymentIntent,
+					payment: paymentArg,
+				},
+				typeArguments: [paymentType],
+			}),
+		);
 	}
 
 	handlePayment(
 		paymentIntent: TransactionObjectArgument,
-		payment: TransactionObjectArgument,
+		paymentArg: 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],
-		});
+		return this.transaction.add(
+			paymentsModule.handlePayment({
+				package: config.payments.packageId,
+				arguments: {
+					haneulns: config.haneulns,
+					bbbVault: config.bbb.vault,
+					intent: paymentIntent,
+					payment: paymentArg,
+					priceInfoObject: priceInfoObjectId,
+					userPriceGuard: 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()],
-		});
+		return this.transaction.add(
+			payment.register({
+				package: config.packageId,
+				arguments: { receipt, haneulns: config.haneulns },
+			}),
+		);
 	}
 
 	finalizeRenew(
@@ -190,15 +203,12 @@ export class HaneulnsTransaction {
 		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(),
-			],
-		});
+		return this.transaction.add(
+			payment.renew({
+				package: config.packageId,
+				arguments: { receipt, haneulns: config.haneulns, nft: this.transaction.object(nft) },
+			}),
+		);
 	}
 
 	calculatePriceAfterDiscount(
@@ -206,11 +216,13 @@ export class HaneulnsTransaction {
 		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],
-		});
+		return this.transaction.add(
+			paymentsModule.calculatePriceAfterDiscount({
+				package: config.payments.packageId,
+				arguments: { haneulns: config.haneulns, intent: paymentIntent },
+				typeArguments: [paymentType],
+			}),
+		);
 	}
 
 	generateReceipt(params: ReceiptParams): TransactionObjectArgument {
@@ -250,15 +262,12 @@ export class HaneulnsTransaction {
 	 */
 	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(),
-			],
-		});
+		return this.transaction.add(
+			couponHouse.applyCoupon({
+				package: config.coupons.packageId,
+				arguments: { haneulns: config.haneulns, intent, couponCode },
+			}),
+		);
 	}
 
 	/**
@@ -268,27 +277,31 @@ export class HaneulnsTransaction {
 		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],
-			});
+			this.transaction.add(
+				freeClaims.freeClaim({
+					package: config.discountsPackage.packageId,
+					arguments: {
+						self: config.discountsPackage.discountHouseId,
+						haneulns: config.haneulns,
+						intent,
+						object: 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],
-			});
+			this.transaction.add(
+				discounts.applyPercentageDiscount({
+					package: config.discountsPackage.packageId,
+					arguments: {
+						self: config.discountsPackage.discountHouseId,
+						intent,
+						haneulns: config.haneulns,
+						_: this.transaction.object(discountInfo.discountNft),
+					},
+					typeArguments: [discountInfo.type],
+				}),
+			);
 		}
 	}
 
@@ -431,13 +444,15 @@ export class HaneulnsTransaction {
 		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')),
-			],
-		});
+		this.transaction.add(
+			controller.setReverseLookup({
+				package: this.haneulnsClient.config.packageId,
+				arguments: {
+					haneulns: this.haneulnsClient.config.haneulns,
+					domainName: normalizeHaneulNSName(name, 'dot'),
+				},
+			}),
+		);
 	}
 
 	/**
@@ -541,15 +556,26 @@ export class HaneulnsTransaction {
 	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),
-			],
-		});
+		if (isSubname) {
+			this.transaction.add(
+				controller.burnExpiredSubname({
+					package: this.haneulnsClient.config.packageId,
+					arguments: {
+						haneulns: this.haneulnsClient.config.haneulns,
+						nft: this.transaction.object(nft),
+					},
+				}),
+			);
+		} else {
+			this.transaction.add(
+				controller.burnExpired({
+					package: this.haneulnsClient.config.packageId,
+					arguments: {
+						haneulns: this.haneulnsClient.config.haneulns,
+						nft: this.transaction.object(nft),
+					},
+				}),
+			);
+		}
 	}
 }

package/src/index.ts

@@ -1,8 +1,8 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
-export { HaneulnsClient } from './haneulns-client.js';
+export { haneulns, HaneulnsClient, type HaneulnsExtensionOptions } from './haneulns-client.js';
 export { HaneulnsTransaction } from './haneulns-transaction.js';
-export type { Network, HaneulnsClientConfig, Config } from './types.js';
+export type { HaneulnsClientConfig, PackageInfo } from './types.js';
 export { ALLOWED_METADATA, mainPackage } from './constants.js';
 export {
 	isSubName,

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, TransactionObjectArgument } 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;
@@ -25,17 +27,19 @@ export class HaneulPriceServiceConnection extends PriceServiceConnection {
 		return latestVaas.map((vaa) => fromBase64(vaa));
 	}
 }
+
+type ParsedPythState = ReturnType<typeof PythState.parse>;
+
 export class HaneulPythClient {
-	#pythPackageId?: Promise<ObjectId>;
+	#pythState?: Promise<ParsedPythState>;
 	#wormholePackageId?: Promise<ObjectId>;
 	#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;
@@ -65,7 +69,7 @@ export class HaneulPythClient {
 	 * @param tx Transaction block to add commands to.
 	 * @param updates Array of price feed updates received from the price service.
 	 * @param feedIds Array of feed IDs to update (in hex format).
-	 * @param feeCoin Optional custom SUI coin to use for Pyth oracle fees. If not provided, uses gas coin.
+	 * @param feeCoin Optional custom HANEUL coin to use for Pyth oracle fees. If not provided, uses gas coin.
 	 */
 	async updatePriceFeeds(
 		tx: Transaction,
@@ -154,25 +158,20 @@ export class HaneulPythClient {
 	 */
 	async #fetchPriceFeedObjectId(feedId: HexString): Promise<ObjectId> {
 		const { id: tableId, fieldType } = await this.getPriceTableInfo();
-		const result = await this.provider.getDynamicFieldObject({
+
+		const result = await this.provider.core.getDynamicField({
 			parentId: tableId,
 			name: {
 				type: `${fieldType}::price_identifier::PriceIdentifier`,
-				value: {
-					bytes: Array.from(fromHex(feedId)),
-				},
+				bcs: bcs.byteVector().serialize(fromHex(feedId)).toBytes(),
 			},
 		});
 
-		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');
-		}
 
-		// @ts-ignore
-		return result.data.content.fields.value;
+		return bcs.Address.parse(result.dynamicField.value.bcs);
 	}
 
 	/**
@@ -198,26 +197,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');
 		}
@@ -236,77 +236,61 @@ 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 },
+		});
 
-	/**
-	 * Fetches the package ID for the Pyth contract, with caching.
-	 */
-	getPythPackageId(): Promise<ObjectId> {
-		if (!this.#pythPackageId) {
-			this.#pythPackageId = this.#fetchPythPackageId();
+		if (!result.object?.content) {
+			throw new Error('Unable to fetch Wormhole state object');
 		}
-		return this.#pythPackageId;
+
+		const state = WormholeState.parse(result.object.content);
+		return state.upgrade_cap.package;
 	}
 
 	/**
-	 * Fetches the package ID for the Pyth contract (no caching).
+	 * Fetches and caches the parsed Pyth state object.
+	 * This is shared between getPythPackageId and getBaseUpdateFee to avoid redundant fetches.
 	 */
-	async #fetchPythPackageId(): Promise<ObjectId> {
-		return await this.#getPackageId(this.pythStateId);
+	#getPythState(): Promise<ParsedPythState> {
+		if (!this.#pythState) {
+			this.#pythState = this.#fetchPythState();
+		}
+		return this.#pythState;
 	}
 
 	/**
-	 * Fetches the package ID for a given object.
-	 *
-	 * @param objectId Object ID to fetch the package ID for.
+	 * Fetches the Pyth state object (no caching).
 	 */
-	async #getPackageId(objectId: ObjectId): Promise<ObjectId> {
-		const result = await this.provider.getObject({
-			id: objectId,
-			options: { showContent: true },
+	async #fetchPythState(): Promise<ParsedPythState> {
+		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('Unable to fetch Pyth state object');
 		}
 
-		throw new Error(`Cannot fetch package ID for object ${objectId}`);
+		return PythState.parse(result.object.content);
 	}
+
 	/**
-	 * Gets the base update fee from the Pyth state object.
+	 * Fetches the package ID for the Pyth contract, with caching.
+	 * Uses the shared Pyth state cache.
 	 */
-	async #fetchBaseUpdateFee(): Promise<number> {
-		const result = await this.provider.getObject({
-			id: this.pythStateId,
-			options: { showContent: true },
-		});
-
-		if (!result.data || result.data.content?.dataType !== 'moveObject') {
-			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;
+	async getPythPackageId(): Promise<ObjectId> {
+		const state = await this.#getPythState();
+		return state.upgrade_cap.package;
 	}
 
 	/**
 	 * Returns the cached base update fee, fetching it if necessary.
+	 * Uses the shared Pyth state cache.
 	 */
-	getBaseUpdateFee(): Promise<number> {
-		if (!this.#baseUpdateFee) {
-			this.#baseUpdateFee = this.#fetchBaseUpdateFee();
-		}
-		return this.#baseUpdateFee;
+	async getBaseUpdateFee(): Promise<number> {
+		const state = await this.#getPythState();
+		return Number(state.base_update_fee);
 	}
 }

package/src/types.ts

@@ -1,6 +1,6 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
-import type { HaneulClient } from '@haneullabs/haneul/client';
+import type { ClientWithCoreApi, HaneulClientTypes } from '@haneullabs/haneul/client';
 import type { TransactionObjectArgument, TransactionObjectInput } from '@haneullabs/haneul/transactions';
 
 // Interfaces
@@ -63,8 +63,6 @@ export interface NameRecord {
 // Types
 // -----------------
 
-export type Network = 'mainnet' | 'testnet' | 'custom';
-
 export type VersionedPackageId = {
 	latest: string;
 	v1: string;
@@ -101,11 +99,11 @@ export type ReceiptParams = {
 };
 
 export type HaneulnsClientConfig = {
-	client: HaneulClient;
-	network?: Network;
-	config?: Config;
+	client: ClientWithCoreApi;
+	network?: HaneulClientTypes.Network;
+	packageInfo?: PackageInfo;
 };
 
-export type SuinsPriceList = Map<[number, number], number>;
+export type HaneulnsPriceList = Map<[number, number], number>;
 
 export type CoinTypeDiscount = Map<string, number>;

package/dist/cjs/constants.d.ts

@@ -1,11 +0,0 @@
-import type { Config } from './types.js';
-export declare const MAX_U64: bigint;
-/**
- * Allowed keys for metadata.
- */
-export declare const ALLOWED_METADATA: {
-    contentHash: string;
-    avatar: string;
-    walrusSiteId: string;
-};
-export declare const mainPackage: Config;