@haneullabs/kiosk 0.1.0 → 1.1.2

package/src/tx/rules/resolve.ts

@@ -1,26 +1,29 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { bcs } from '@haneullabs/haneul/bcs';
 import type { TransactionArgument } from '@haneullabs/haneul/transactions';
 import { Transaction } from '@haneullabs/haneul/transactions';
+import { bcs } from '@haneullabs/haneul/bcs';
 import { normalizeHaneulAddress } from '@haneullabs/haneul/utils';
 
 import type { RuleResolvingParams } from '../../types/index.js';
-import { lock } from '../kiosk.js';
-
+import * as kiosk from '../../contracts/0x2/kiosk.js';
+import * as royaltyRule from '../../contracts/kiosk/royalty_rule.js';
+import * as kioskLockRule from '../../contracts/kiosk/kiosk_lock_rule.js';
+import * as personalKioskRule from '../../contracts/kiosk/personal_kiosk_rule.js';
+import * as floorPriceRule from '../../contracts/kiosk/floor_price_rule.js';
 /**
  * A helper to resolve the royalty rule.
  */
 export async function resolveRoyaltyRule(params: RuleResolvingParams) {
 	const {
-		kioskClient,
 		transaction: tx,
 		itemType,
 		price,
 		packageId,
 		transferRequest,
 		policyId,
+		kioskClient,
 	} = params;
 
 	// We attempt to resolve the fee amount outside of the PTB so that the split amount is known before the transaction is sent.
@@ -29,45 +32,69 @@ export async function resolveRoyaltyRule(params: RuleResolvingParams) {
 	const feeTx = new Transaction();
 
 	// calculates the amount
-	feeTx.moveCall({
-		target: `${packageId}::royalty_rule::fee_amount`,
-		typeArguments: [itemType],
-		arguments: [feeTx.object(policyId), feeTx.pure.u64(price || '0')],
-	});
+	feeTx.add(
+		royaltyRule.feeAmount({
+			package: packageId,
+			arguments: {
+				policy: feeTx.object(policyId),
+				paid: BigInt(price || '0'),
+			},
+			typeArguments: [itemType],
+		}),
+	);
 
 	const policyObj = tx.object(policyId);
 
-	const { results } = await kioskClient.client.devInspectTransactionBlock({
-		sender: tx.getData().sender || normalizeHaneulAddress('0x0'),
-		transactionBlock: feeTx,
-	});
-
 	let amount: TransactionArgument | bigint | null = null;
-	if (results) {
-		const returnedAmount = results?.[0].returnValues?.[0]?.[0];
-		if (returnedAmount) {
-			amount = BigInt(bcs.U64.parse(new Uint8Array(returnedAmount as number[])));
+
+	try {
+		feeTx.setSender(tx.getData().sender || normalizeHaneulAddress('0x0'));
+		const txBytes = await feeTx.build({ client: kioskClient.client });
+
+		const result = await kioskClient.client.core.simulateTransaction({
+			transaction: txBytes,
+			include: { commandResults: true },
+		});
+
+		if (result.commandResults && result.commandResults.length > 0) {
+			const returnedAmount = result.commandResults[0]?.returnValues?.[0]?.bcs;
+			if (returnedAmount) {
+				amount = BigInt(bcs.U64.parse(returnedAmount));
+			}
 		}
+	} catch {
+		// If simulate fails, fall back to resolving within the PTB
 	}
 
 	// We were not able to calculate the amount outside of the transaction, so fall back to resolving it within the PTB
 	if (!amount) {
-		[amount] = tx.moveCall({
-			target: `${packageId}::royalty_rule::fee_amount`,
-			typeArguments: [itemType],
-			arguments: [policyObj, tx.pure.u64(price || '0')],
-		});
+		[amount] = tx.add(
+			royaltyRule.feeAmount({
+				package: packageId,
+				arguments: {
+					policy: policyObj,
+					paid: BigInt(price || '0'),
+				},
+				typeArguments: [itemType],
+			}),
+		);
 	}
 
 	// splits the coin.
 	const feeCoin = tx.splitCoins(tx.gas, [amount]);
 
 	// pays the policy
-	tx.moveCall({
-		target: `${packageId}::royalty_rule::pay`,
-		typeArguments: [itemType],
-		arguments: [policyObj, transferRequest, feeCoin],
-	});
+	tx.add(
+		royaltyRule.pay({
+			package: packageId,
+			arguments: {
+				policy: policyObj,
+				request: transferRequest,
+				payment: feeCoin,
+			},
+			typeArguments: [itemType],
+		}),
+	);
 }
 
 export function resolveKioskLockRule(params: RuleResolvingParams) {
@@ -75,23 +102,33 @@ export function resolveKioskLockRule(params: RuleResolvingParams) {
 		transaction: tx,
 		packageId,
 		itemType,
-		kiosk,
+		kiosk: kioskId,
 		kioskCap,
 		policyId,
 		purchasedItem,
 		transferRequest,
 	} = params;
 
-	if (!kiosk || !kioskCap) throw new Error('Missing Owned Kiosk or Owned Kiosk Cap');
+	if (!kioskId || !kioskCap) throw new Error('Missing Owned Kiosk or Owned Kiosk Cap');
 
-	lock(tx, itemType, kiosk, kioskCap, policyId, purchasedItem);
+	tx.add(
+		kiosk.lock({
+			arguments: [kioskId, kioskCap, policyId, purchasedItem],
+			typeArguments: [itemType],
+		}),
+	);
 
 	// proves that the item is locked in the kiosk to the TP.
-	tx.moveCall({
-		target: `${packageId}::kiosk_lock_rule::prove`,
-		typeArguments: [itemType],
-		arguments: [transferRequest, tx.object(kiosk)],
-	});
+	tx.add(
+		kioskLockRule.prove({
+			package: packageId,
+			arguments: {
+				request: transferRequest,
+				kiosk: tx.object(kioskId),
+			},
+			typeArguments: [itemType],
+		}),
+	);
 }
 
 /**
@@ -104,23 +141,35 @@ export function resolvePersonalKioskRule(params: RuleResolvingParams) {
 	if (!kiosk) throw new Error('Missing owned Kiosk.');
 
 	// proves that the destination kiosk is personal.
-	tx.moveCall({
-		target: `${packageId}::personal_kiosk_rule::prove`,
-		typeArguments: [itemType],
-		arguments: [tx.object(kiosk), transferRequest],
-	});
+	tx.add(
+		personalKioskRule.prove({
+			package: packageId,
+			arguments: {
+				kiosk: tx.object(kiosk),
+				request: transferRequest,
+			},
+			typeArguments: [itemType],
+		}),
+	);
 }
 
 /**
- * Resolves the floor price rule.
+ * A helper to resolve the floor price rule.
+ * The floor price rule verifies that the paid amount meets the minimum price.
+ * @param params
  */
 export function resolveFloorPriceRule(params: RuleResolvingParams) {
 	const { transaction: tx, packageId, itemType, policyId, transferRequest } = params;
 
-	// proves that the destination kiosk is personal
-	tx.moveCall({
-		target: `${packageId}::floor_price_rule::prove`,
-		typeArguments: [itemType],
-		arguments: [tx.object(policyId), transferRequest],
-	});
+	// proves that the paid amount meets the floor price requirement
+	tx.add(
+		floorPriceRule.prove({
+			package: packageId,
+			arguments: {
+				policy: tx.object(policyId),
+				request: transferRequest,
+			},
+			typeArguments: [itemType],
+		}),
+	);
 }

package/src/tx/transfer-policy.ts

@@ -1,15 +1,10 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { bcs } from '@haneullabs/haneul/bcs';
-import type {
-	Transaction,
-	TransactionArgument,
-	TransactionObjectArgument,
-} from '@haneullabs/haneul/transactions';
+import type { Transaction, TransactionObjectArgument } from '@haneullabs/haneul/transactions';
 
 import type { ObjectArgument } from '../types/index.js';
-import { TRANSFER_POLICY_MODULE, TRANSFER_POLICY_TYPE } from '../types/index.js';
+import * as transferPolicy from '../contracts/0x2/transfer_policy.js';
 
 /**
  * Call the `transfer_policy::new` function to create a new transfer policy.
@@ -20,47 +15,20 @@ export function createTransferPolicy(
 	itemType: string,
 	publisher: ObjectArgument,
 ): TransactionObjectArgument {
-	const [transferPolicy, transferPolicyCap] = createTransferPolicyWithoutSharing(
-		tx,
-		itemType,
-		publisher,
+	const [policy, policyCap] = tx.add(
+		transferPolicy._new({
+			arguments: [publisher],
+			typeArguments: [itemType],
+		}),
 	);
 
-	shareTransferPolicy(tx, itemType, transferPolicy);
-
-	return transferPolicyCap;
-}
-
-/**
- * Creates a transfer Policy and returns both the Policy and the Cap.
- * Used if we want to use the policy before making it a shared object.
- */
-export function createTransferPolicyWithoutSharing(
-	tx: Transaction,
-	itemType: string,
-	publisher: ObjectArgument,
-): [TransactionObjectArgument, TransactionObjectArgument] {
-	const [transferPolicy, transferPolicyCap] = tx.moveCall({
-		target: `${TRANSFER_POLICY_MODULE}::new`,
-		typeArguments: [itemType],
-		arguments: [tx.object(publisher)],
-	});
-
-	return [transferPolicy, transferPolicyCap];
-}
-/**
- * Converts Transfer Policy to a shared object.
- */
-export function shareTransferPolicy(
-	tx: Transaction,
-	itemType: string,
-	transferPolicy: TransactionObjectArgument,
-) {
 	tx.moveCall({
-		target: `0x2::transfer::public_share_object`,
-		typeArguments: [`${TRANSFER_POLICY_TYPE}<${itemType}>`],
-		arguments: [transferPolicy],
+		target: '0x2::transfer::public_share_object',
+		arguments: [policy],
+		typeArguments: [`0x2::transfer_policy::TransferPolicy<${itemType}>`],
 	});
+
+	return policyCap;
 }
 
 /**
@@ -73,48 +41,19 @@ export function withdrawFromPolicy(
 	policyCap: ObjectArgument,
 	amount?: string | bigint | null,
 ): TransactionObjectArgument {
-	const amountArg = bcs.option(bcs.u64()).serialize(amount);
-
-	const [profits] = tx.moveCall({
-		target: `${TRANSFER_POLICY_MODULE}::withdraw`,
-		typeArguments: [itemType],
-		arguments: [tx.object(policy), tx.object(policyCap), amountArg],
-	});
+	// Convert string to bigint if needed for the generated function
+	const amountArg: bigint | null = amount
+		? typeof amount === 'string'
+			? BigInt(amount)
+			: amount
+		: null;
+
+	const [profits] = tx.add(
+		transferPolicy.withdraw({
+			arguments: [policy, policyCap, amountArg],
+			typeArguments: [itemType],
+		}),
+	);
 
 	return profits;
 }
-
-/**
- * Call the `transfer_policy::confirm_request` function to unblock the
- * transaction.
- */
-export function confirmRequest(
-	tx: Transaction,
-	itemType: string,
-	policy: ObjectArgument,
-	request: TransactionArgument,
-): void {
-	tx.moveCall({
-		target: `${TRANSFER_POLICY_MODULE}::confirm_request`,
-		typeArguments: [itemType],
-		arguments: [tx.object(policy), request],
-	});
-}
-
-/**
- * Calls the `transfer_policy::remove_rule` function to remove a Rule from the transfer policy's ruleset.
- */
-export function removeTransferPolicyRule(
-	tx: Transaction,
-	itemType: string,
-	ruleType: string,
-	configType: string,
-	policy: ObjectArgument,
-	policyCap: ObjectArgument,
-): void {
-	tx.moveCall({
-		target: `${TRANSFER_POLICY_MODULE}::remove_rule`,
-		typeArguments: [itemType, ruleType, configType],
-		arguments: [tx.object(policy), tx.object(policyCap)],
-	});
-}

package/src/types/index.ts

@@ -1,10 +1,12 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HaneulClient } from '@haneullabs/haneul/client';
+import type { HaneulClientTypes } from '@haneullabs/haneul/client';
 import type { TransactionObjectArgument } from '@haneullabs/haneul/transactions';
 
 import type { BaseRulePackageIds } from '../constants.js';
+import { HaneulJsonRpcClient } from '@haneullabs/haneul/jsonRpc';
+import { HaneulGraphQLClient } from '@haneullabs/haneul/graphql';
 
 export * from './kiosk.js';
 export * from './transfer-policy.js';
@@ -14,22 +16,13 @@ export * from './transfer-policy.js';
  */
 export type ObjectArgument = string | TransactionObjectArgument;
 
-/**
- * A Network selector.
- * Kiosk SDK supports mainnet & testnet.
- * Pass `custom` for any other network (devnet, localnet).
- */
-export enum Network {
-	MAINNET = 'mainnet',
-	TESTNET = 'testnet',
-	CUSTOM = 'custom',
-}
-
 /**
  * The Client Options for Both KioskClient & TransferPolicyManager.
  */
 export type KioskClientOptions = {
-	client: HaneulClient;
-	network: Network;
+	client: KioskCompatibleClient;
+	network: HaneulClientTypes.Network;
 	packageIds?: BaseRulePackageIds;
 };
+
+export type KioskCompatibleClient = HaneulJsonRpcClient | HaneulGraphQLClient;

package/src/types/kiosk.ts

@@ -1,17 +1,15 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type {
-	PaginatedObjectsResponse,
-	HaneulObjectData,
-	HaneulObjectDataOptions,
-} from '@haneullabs/haneul/client';
 import type { TransactionArgument } from '@haneullabs/haneul/transactions';
 
 import type { ObjectArgument } from './index.js';
 
+import { HANEUL_FRAMEWORK_ADDRESS } from '@haneullabs/haneul/utils';
+import { HaneulClientTypes } from '@haneullabs/haneul/client';
+
 /** The Kiosk module. */
-export const KIOSK_MODULE = '0x2::kiosk';
+export const KIOSK_MODULE = `${HANEUL_FRAMEWORK_ADDRESS}::kiosk`;
 
 /** The Kiosk type. */
 export const KIOSK_TYPE = `${KIOSK_MODULE}::Kiosk`;
@@ -90,6 +88,18 @@ export type KioskListing = {
 	price?: string;
 };
 
+export type KioskDisplay = {
+	data: Record<string, string> | null;
+	error: string | null;
+};
+
+export type ObjectWithDisplay = HaneulClientTypes.Object<{
+	content: true;
+	previousTransaction: true;
+}> & {
+	display?: KioskDisplay;
+};
+
 /**
  * A dynamic field `Item { ID }` attached to the Kiosk.
  * Holds an Item `T`. The type of the item is known upfront.
@@ -105,8 +115,8 @@ export type KioskItem = {
 	listing?: KioskListing;
 	/** The ID of the kiosk the item is placed in */
 	kioskId: string;
-	/** Optional Kiosk Data */
-	data?: HaneulObjectData;
+	/** Optional object data with display metadata */
+	data?: ObjectWithDisplay;
 };
 
 /** The overview type returned from `getKiosk` */
@@ -149,16 +159,16 @@ export type FetchKioskOptions = {
 	withKioskFields?: boolean;
 	/** Include the listing prices. */
 	withListingPrices?: boolean;
-	/** Include the objects for the Items in the kiosk. Defaults to `display` only. */
+	/** Include the objects for the Items in the kiosk. */
 	withObjects?: boolean;
-	/** Pass the data options for the objects, when fetching, in case you want to query other details. */
-	objectOptions?: HaneulObjectDataOptions;
 };
 
 export type OwnedKiosks = {
 	kioskOwnerCaps: KioskOwnerCap[];
 	kioskIds: string[];
-} & Omit<PaginatedObjectsResponse, 'data'>;
+	nextCursor: string | null;
+	hasNextPage: boolean;
+};
 
 export type KioskOwnerCap = {
 	isPersonal?: boolean;

package/src/types/transfer-policy.ts

@@ -1,14 +1,16 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { ObjectOwner } from '@haneullabs/haneul/client';
+import type { ObjectOwner } from '@haneullabs/haneul/jsonRpc';
 import type { Transaction, TransactionObjectArgument } from '@haneullabs/haneul/transactions';
 
 import type { KioskClient } from '../client/kiosk-client.js';
 import type { ObjectArgument } from './index.js';
 
+import { HANEUL_FRAMEWORK_ADDRESS } from '@haneullabs/haneul/utils';
+
 /** The Transfer Policy module. */
-export const TRANSFER_POLICY_MODULE = '0x2::transfer_policy';
+export const TRANSFER_POLICY_MODULE = `${HANEUL_FRAMEWORK_ADDRESS}::transfer_policy`;
 
 /** Name of the event emitted when a TransferPolicy for T is created. */
 export const TRANSFER_POLICY_CREATED_EVENT = `${TRANSFER_POLICY_MODULE}::TransferPolicyCreated`;
@@ -54,8 +56,6 @@ export type TransferPolicyCreated = {
 // e.g. `if(!'my_key' in ruleParams!) throw new Error("Can't resolve that rule!")`
 export type RuleResolvingParams = {
 	transaction: Transaction;
-	/** @deprecated use transaction instead */
-	transactionBlock: Transaction;
 	itemType: string;
 	itemId: string;
 	price: string;