@mysten/kiosk 0.6.0 → 0.7.0

package/src/query/transfer-policy.ts

@@ -2,8 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { SuiClient } from '@mysten/sui.js/client';
+import { isValidSuiAddress } from '@mysten/sui.js/utils';
+
 import { bcs } from '../bcs';
-import { TRANSFER_POLICY_CREATED_EVENT, TRANSFER_POLICY_TYPE, TransferPolicy } from '../types';
+import {
+	TRANSFER_POLICY_CAP_TYPE,
+	TRANSFER_POLICY_CREATED_EVENT,
+	TRANSFER_POLICY_TYPE,
+	TransferPolicy,
+	TransferPolicyCap,
+} from '../types';
+import { getAllOwnedObjects, parseTransferPolicyCapObject } from '../utils';
 
 /**
  * Searches the `TransferPolicy`-s for the given type. The seach is performed via
@@ -40,7 +49,7 @@ export async function queryTransferPolicy(
 				throw new Error(`Invalid policy: ${policy?.objectId}, expected object, got package`);
 			}
 
-			let parsed = bcs.de(TRANSFER_POLICY_TYPE, policy.bcs.bcsBytes, 'base64');
+			const parsed = bcs.de(TRANSFER_POLICY_TYPE, policy.bcs.bcsBytes, 'base64');
 
 			return {
 				id: policy?.objectId,
@@ -51,3 +60,74 @@ export async function queryTransferPolicy(
 			} as TransferPolicy;
 		});
 }
+
+/**
+ * A function to fetch all the user's kiosk Caps
+ * And a list of the kiosk address ids.
+ * Returns a list of `kioskOwnerCapIds` and `kioskIds`.
+ * Extra options allow pagination.
+ * @returns TransferPolicyCap Object ID | undefined if not found.
+ */
+export async function queryTransferPolicyCapsByType(
+	client: SuiClient,
+	address: string,
+	type: string,
+): Promise<TransferPolicyCap[]> {
+	if (!isValidSuiAddress(address)) return [];
+
+	const filter = {
+		MatchAll: [
+			{
+				StructType: `${TRANSFER_POLICY_CAP_TYPE}<${type}>`,
+			},
+		],
+	};
+
+	// fetch owned kiosk caps, paginated.
+	const data = await getAllOwnedObjects({
+		client,
+		filter,
+		owner: address,
+	});
+
+	return data
+		.map((item) => parseTransferPolicyCapObject(item))
+		.filter((item) => !!item) as TransferPolicyCap[];
+}
+
+/**
+ * A function to fetch all the user's kiosk Caps
+ * And a list of the kiosk address ids.
+ * Returns a list of `kioskOwnerCapIds` and `kioskIds`.
+ * Extra options allow pagination.
+ * @returns TransferPolicyCap Object ID | undefined if not found.
+ */
+export async function queryOwnedTransferPolicies(
+	client: SuiClient,
+	address: string,
+): Promise<TransferPolicyCap[] | undefined> {
+	if (!isValidSuiAddress(address)) return;
+
+	const filter = {
+		MatchAll: [
+			{
+				MoveModule: {
+					module: 'transfer_policy',
+					package: '0x2',
+				},
+			},
+		],
+	};
+
+	// fetch all owned kiosk caps, paginated.
+	const data = await getAllOwnedObjects({ client, owner: address, filter });
+
+	const policies: TransferPolicyCap[] = [];
+
+	for (const item of data) {
+		const data = parseTransferPolicyCapObject(item);
+		if (data) policies.push(data);
+	}
+
+	return policies;
+}

package/src/tx/kiosk.ts

@@ -1,27 +1,16 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { TransactionBlock, TransactionArgument } from '@mysten/sui.js/transactions';
+import { TransactionArgument, TransactionBlock } from '@mysten/sui.js/transactions';
 
-import { getTypeWithoutPackageAddress, objArg } from '../utils';
-import { confirmRequest, resolveKioskLockRule, resolveRoyaltyRule } from './transfer-policy';
-import {
-	KIOSK_LOCK_RULE,
-	KIOSK_MODULE,
-	KIOSK_TYPE,
-	ObjectArgument,
-	PurchaseAndResolvePoliciesResponse,
-	PurchaseOptionalParams,
-	ROYALTY_RULE,
-	RulesEnvironmentParam,
-	TransferPolicy,
-} from '../types';
+import { KIOSK_MODULE, KIOSK_TYPE, ObjectArgument } from '../types';
+import { objArg } from '../utils';
 
 /**
  * Create a new shared Kiosk and returns the [kiosk, kioskOwnerCap] tuple.
  */
 export function createKiosk(tx: TransactionBlock): [TransactionArgument, TransactionArgument] {
-	let [kiosk, kioskOwnerCap] = tx.moveCall({
+	const [kiosk, kioskOwnerCap] = tx.moveCall({
 		target: `${KIOSK_MODULE}::new`,
 	});
 
@@ -33,17 +22,20 @@ export function createKiosk(tx: TransactionBlock): [TransactionArgument, Transac
  * Returns the `kioskOwnerCap` object.
  */
 export function createKioskAndShare(tx: TransactionBlock): TransactionArgument {
-	let [kiosk, kioskOwnerCap] = tx.moveCall({
-		target: `${KIOSK_MODULE}::new`,
-	});
+	const [kiosk, kioskOwnerCap] = createKiosk(tx);
+	shareKiosk(tx, kiosk);
+	return kioskOwnerCap;
+}
 
+/**
+ * Converts Transfer Policy to a shared object.
+ */
+export function shareKiosk(tx: TransactionBlock, kiosk: TransactionArgument) {
 	tx.moveCall({
 		target: `0x2::transfer::public_share_object`,
 		typeArguments: [KIOSK_TYPE],
 		arguments: [kiosk],
 	});
-
-	return kioskOwnerCap;
 }
 
 /**
@@ -98,7 +90,7 @@ export function take(
 	kioskCap: ObjectArgument,
 	itemId: string,
 ): TransactionArgument {
-	let [item] = tx.moveCall({
+	const [item] = tx.moveCall({
 		target: `${KIOSK_MODULE}::take`,
 		typeArguments: [itemType],
 		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
@@ -179,7 +171,7 @@ export function purchase(
 	itemId: string,
 	payment: ObjectArgument,
 ): [TransactionArgument, TransactionArgument] {
-	let [item, transferRequest] = tx.moveCall({
+	const [item, transferRequest] = tx.moveCall({
 		target: `${KIOSK_MODULE}::purchase`,
 		typeArguments: [itemType],
 		arguments: [objArg(tx, kiosk), tx.pure(itemId, 'address'), objArg(tx, payment)],
@@ -196,19 +188,11 @@ export function withdrawFromKiosk(
 	tx: TransactionBlock,
 	kiosk: ObjectArgument,
 	kioskCap: ObjectArgument,
-	amount: string | bigint | null,
+	amount?: string | bigint | number,
 ): TransactionArgument {
-	let amountArg =
-		amount !== null
-			? tx.pure(
-					{
-						Some: amount,
-					},
-					'Option<u64>',
-			  )
-			: tx.pure({ None: true }, 'Option<u64>');
+	const amountArg = tx.pure(amount ? { Some: amount } : { None: true }, 'Option<u64>');
 
-	let [coin] = tx.moveCall({
+	const [coin] = tx.moveCall({
 		target: `${KIOSK_MODULE}::withdraw`,
 		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), amountArg],
 	});
@@ -216,46 +200,6 @@ export function withdrawFromKiosk(
 	return coin;
 }
 
-/**
- * Call the `kiosk::borrow<T>(Kiosk, KioskOwnerCap, ID): &T` function.
- * Immutably borrow an item from the Kiosk.
- */
-export function borrow(
-	tx: TransactionBlock,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	itemId: string,
-): TransactionArgument {
-	let [item] = tx.moveCall({
-		target: `${KIOSK_MODULE}::borrow`,
-		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
-	});
-
-	return item;
-}
-
-/**
- * Call the `kiosk::borrow_mut<T>(Kiosk, KioskOwnerCap, ID): &mut T` function.
- * Mutably borrow an item from the Kiosk.
- */
-export function borrowMut(
-	tx: TransactionBlock,
-	itemType: string,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	itemId: string,
-): TransactionArgument {
-	let [item] = tx.moveCall({
-		target: `${KIOSK_MODULE}::borrow_mut`,
-		typeArguments: [itemType],
-		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
-	});
-
-	return item;
-}
-
 /**
  * Call the `kiosk::borrow_value<T>(Kiosk, KioskOwnerCap, ID): T` function.
  * Immutably borrow an item from the Kiosk and return it in the end.
@@ -269,7 +213,7 @@ export function borrowValue(
 	kioskCap: ObjectArgument,
 	itemId: string,
 ): [TransactionArgument, TransactionArgument] {
-	let [item, promise] = tx.moveCall({
+	const [item, promise] = tx.moveCall({
 		target: `${KIOSK_MODULE}::borrow_val`,
 		typeArguments: [itemType],
 		arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, 'address')],
@@ -295,75 +239,3 @@ export function returnValue(
 		arguments: [objArg(tx, kiosk), item, promise],
 	});
 }
-
-/**
- * Completes the full purchase flow that includes:
- * 1. Purchasing the item.
- * 2. Resolving all the transfer policies (if any).
- * 3. Returns the item and whether the user can transfer it or not.
- *
- * If the item can be transferred, there's an extra transaction required by the user
- * to transfer it to an address or place it in their kiosk.
- */
-export function purchaseAndResolvePolicies(
-	tx: TransactionBlock,
-	itemType: string,
-	price: string,
-	kiosk: ObjectArgument,
-	itemId: string,
-	policy: TransferPolicy,
-	environment: RulesEnvironmentParam,
-	extraParams?: PurchaseOptionalParams,
-): PurchaseAndResolvePoliciesResponse {
-	// if we don't pass the listing or the listing doens't have a price, return.
-	if (price === undefined || typeof price !== 'string')
-		throw new Error(`Price of the listing is not supplied.`);
-
-	// Split the coin for the amount of the listing.
-	const coin = tx.splitCoins(tx.gas, [tx.pure(price, 'u64')]);
-
-	// initialize the purchase `kiosk::purchase`
-	const [purchasedItem, transferRequest] = purchase(tx, itemType, kiosk, itemId, coin);
-
-	// Start resolving rules.
-	// Right now we support `kiosk_lock_rule` and `royalty_rule`.
-	// They can also be supplied in parallel (supports combination).
-	let hasKioskLockRule = false;
-
-	for (let rule of policy.rules) {
-		const ruleWithoutAddr = getTypeWithoutPackageAddress(rule);
-
-		switch (ruleWithoutAddr) {
-			case ROYALTY_RULE:
-				resolveRoyaltyRule(tx, itemType, price, policy.id, transferRequest, environment);
-				break;
-			case KIOSK_LOCK_RULE:
-				if (!extraParams?.ownedKiosk || !extraParams?.ownedKioskCap)
-					throw new Error(
-						`This item type ${itemType} has a 'kiosk_lock_rule', but function call is missing user's kiosk and kioskCap params`,
-					);
-				hasKioskLockRule = true;
-				resolveKioskLockRule(
-					tx,
-					itemType,
-					purchasedItem,
-					extraParams.ownedKiosk,
-					extraParams.ownedKioskCap,
-					policy.id,
-					transferRequest,
-					environment,
-				);
-				break;
-			default:
-				break;
-		}
-	}
-
-	// confirm the Transfer Policy request.
-	confirmRequest(tx, itemType, policy.id, transferRequest);
-
-	return {
-		item: purchasedItem,
-		canTransfer: !hasKioskLockRule,
-	};
-}

package/src/tx/personal-kiosk.ts

@@ -0,0 +1,35 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionArgument, TransactionBlock } from '@mysten/sui.js/transactions';
+
+import { ObjectArgument } from '../types';
+import { objArg } from '../utils';
+
+export function convertToPersonalTx(
+	tx: TransactionBlock,
+	kiosk: ObjectArgument,
+	kioskOwnerCap: ObjectArgument,
+	packageId: string,
+): TransactionArgument {
+	const personalKioskCap = tx.moveCall({
+		target: `${packageId}::personal_kiosk::new`,
+		arguments: [objArg(tx, kiosk), objArg(tx, kioskOwnerCap)],
+	});
+
+	return personalKioskCap;
+}
+
+/**
+ * Transfers the personal kiosk Cap to the sender.
+ */
+export function transferPersonalCapTx(
+	tx: TransactionBlock,
+	personalKioskCap: TransactionArgument,
+	packageId: string,
+) {
+	tx.moveCall({
+		target: `${packageId}::personal_kiosk::transfer_to_sender`,
+		arguments: [personalKioskCap],
+	});
+}

package/src/tx/rules/attach.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { type TransactionBlock } from '@mysten/sui.js/transactions';
+
+import { type ObjectArgument } from '../../types';
+import { objArg } from '../../utils';
+
+export function attachKioskLockRuleTx(
+	tx: TransactionBlock,
+	type: string,
+	policy: ObjectArgument,
+	policyCap: ObjectArgument,
+	packageId: string,
+) {
+	tx.moveCall({
+		target: `${packageId}::kiosk_lock_rule::add`,
+		typeArguments: [type],
+		arguments: [objArg(tx, policy), objArg(tx, policyCap)],
+	});
+}
+
+export function attachRoyaltyRuleTx(
+	tx: TransactionBlock,
+	type: string,
+	policy: ObjectArgument,
+	policyCap: ObjectArgument,
+	percentageBps: number | string, // this is in basis points.
+	minAmount: number | string,
+	packageId: string,
+) {
+	if (Number(percentageBps) < 0 || Number(percentageBps) > 10_000)
+		throw new Error('Invalid basis point percentage. Use a value between [0,10000].');
+
+	tx.moveCall({
+		target: `${packageId}::royalty_rule::add`,
+		typeArguments: [type],
+		arguments: [
+			objArg(tx, policy),
+			objArg(tx, policyCap),
+			tx.pure(percentageBps, 'u16'),
+			tx.pure(minAmount, 'u64'),
+		],
+	});
+}
+
+export function attachPersonalKioskRuleTx(
+	tx: TransactionBlock,
+	type: string,
+	policy: ObjectArgument,
+	policyCap: ObjectArgument,
+	packageId: string,
+) {
+	tx.moveCall({
+		target: `${packageId}::personal_kiosk_rule::add`,
+		typeArguments: [type],
+		arguments: [objArg(tx, policy), objArg(tx, policyCap)],
+	});
+}
+
+export function attachFloorPriceRuleTx(
+	tx: TransactionBlock,
+	type: string,
+	policy: ObjectArgument,
+	policyCap: ObjectArgument,
+	minPrice: string | bigint,
+	packageId: string,
+) {
+	tx.moveCall({
+		target: `${packageId}::floor_price_rule::add`,
+		typeArguments: [type],
+		arguments: [objArg(tx, policy), objArg(tx, policyCap), tx.pure(minPrice, 'u64')],
+	});
+}

package/src/tx/rules/resolve.ts

@@ -0,0 +1,87 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { type RuleResolvingParams } from '../../types';
+import { objArg } from '../../utils';
+import { lock } from '../kiosk';
+
+/**
+ * A helper to resolve the royalty rule.
+ */
+export function resolveRoyaltyRule(params: RuleResolvingParams) {
+	const { transactionBlock: txb, itemType, price, packageId, transferRequest, policyId } = params;
+
+	const policyObj = objArg(txb, policyId);
+
+	// calculates the amount
+	const [amount] = txb.moveCall({
+		target: `${packageId}::royalty_rule::fee_amount`,
+		typeArguments: [itemType],
+		arguments: [policyObj, objArg(txb, price ?? '')],
+	});
+
+	// splits the coin.
+	const feeCoin = txb.splitCoins(txb.gas, [amount]);
+
+	// pays the policy
+	txb.moveCall({
+		target: `${packageId}::royalty_rule::pay`,
+		typeArguments: [itemType],
+		arguments: [policyObj, transferRequest, feeCoin],
+	});
+}
+
+export function resolveKioskLockRule(params: RuleResolvingParams) {
+	const {
+		transactionBlock: txb,
+		packageId,
+		itemType,
+		kiosk,
+		kioskCap,
+		policyId,
+		purchasedItem,
+		transferRequest,
+	} = params;
+
+	if (!kiosk || !kioskCap) throw new Error('Missing Owned Kiosk or Owned Kiosk Cap');
+
+	lock(txb, itemType, kiosk, kioskCap, policyId, purchasedItem);
+
+	// proves that the item is locked in the kiosk to the TP.
+	txb.moveCall({
+		target: `${packageId}::kiosk_lock_rule::prove`,
+		typeArguments: [itemType],
+		arguments: [transferRequest, objArg(txb, kiosk)],
+	});
+}
+
+/**
+ * A helper to resolve the personalKioskRule.
+ * @param params
+ */
+export function resolvePersonalKioskRule(params: RuleResolvingParams) {
+	const { transactionBlock: txb, packageId, itemType, kiosk, transferRequest } = params;
+
+	if (!kiosk) throw new Error('Missing owned Kiosk.');
+
+	// proves that the destination kiosk is personal.
+	txb.moveCall({
+		target: `${packageId}::personal_kiosk_rule::prove`,
+		typeArguments: [itemType],
+		arguments: [objArg(txb, kiosk), transferRequest],
+	});
+}
+
+/**
+ * Resolves the floor price rule.
+ */
+export function resolveFloorPriceRule(params: RuleResolvingParams) {
+	const { transactionBlock: txb, packageId, itemType, policyId, transferRequest } = params;
+
+	// proves that the destination kiosk is personal
+	txb.moveCall({
+		target: `${packageId}::floor_price_rule::prove`,
+		typeArguments: [itemType],
+		arguments: [objArg(txb, policyId), transferRequest],
+	});
+}

package/src/tx/transfer-policy.ts

@@ -1,15 +1,10 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { TransactionBlock, TransactionArgument } from '@mysten/sui.js/transactions';
-import { getRulePackageAddress, objArg } from '../utils';
-import { lock } from './kiosk';
-import {
-	ObjectArgument,
-	RulesEnvironmentParam,
-	TRANSFER_POLICY_MODULE,
-	TRANSFER_POLICY_TYPE,
-} from '../types';
+import { TransactionArgument, TransactionBlock } from '@mysten/sui.js/transactions';
+
+import { ObjectArgument, TRANSFER_POLICY_MODULE, TRANSFER_POLICY_TYPE } from '../types';
+import { objArg } from '../utils';
 
 /**
  * Call the `transfer_policy::new` function to create a new transfer policy.
@@ -20,19 +15,47 @@ export function createTransferPolicy(
 	itemType: string,
 	publisher: ObjectArgument,
 ): TransactionArgument {
-	let [transferPolicy, transferPolicyCap] = tx.moveCall({
+	const [transferPolicy, transferPolicyCap] = createTransferPolicyWithoutSharing(
+		tx,
+		itemType,
+		publisher,
+	);
+
+	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: TransactionBlock,
+	itemType: string,
+	publisher: ObjectArgument,
+): [TransactionArgument, TransactionArgument] {
+	const [transferPolicy, transferPolicyCap] = tx.moveCall({
 		target: `${TRANSFER_POLICY_MODULE}::new`,
 		typeArguments: [itemType],
 		arguments: [objArg(tx, publisher)],
 	});
 
+	return [transferPolicy, transferPolicyCap];
+}
+/**
+ * Converts Transfer Policy to a shared object.
+ */
+export function shareTransferPolicy(
+	tx: TransactionBlock,
+	itemType: string,
+	transferPolicy: TransactionArgument,
+) {
 	tx.moveCall({
 		target: `0x2::transfer::public_share_object`,
 		typeArguments: [`${TRANSFER_POLICY_TYPE}<${itemType}>`],
 		arguments: [transferPolicy],
 	});
-
-	return transferPolicyCap;
 }
 
 /**
@@ -43,14 +66,11 @@ export function withdrawFromPolicy(
 	itemType: string,
 	policy: ObjectArgument,
 	policyCap: ObjectArgument,
-	amount: string | bigint | null,
+	amount?: string | bigint | null,
 ): TransactionArgument {
-	let amountArg =
-		amount !== null
-			? tx.pure({ Some: amount }, 'Option<u64>')
-			: tx.pure({ None: true }, 'Option<u64>');
+	const amountArg = tx.pure(amount ? { Some: amount } : { None: true }, 'Option<u64>');
 
-	let [profits] = tx.moveCall({
+	const [profits] = tx.moveCall({
 		target: `${TRANSFER_POLICY_MODULE}::withdraw`,
 		typeArguments: [itemType],
 		arguments: [objArg(tx, policy), objArg(tx, policyCap), amountArg],
@@ -85,69 +105,11 @@ export function removeTransferPolicyRule(
 	ruleType: string,
 	configType: string,
 	policy: ObjectArgument,
-	policyCap: TransactionArgument,
+	policyCap: ObjectArgument,
 ): void {
 	tx.moveCall({
 		target: `${TRANSFER_POLICY_MODULE}::remove_rule`,
 		typeArguments: [itemType, ruleType, configType],
-		arguments: [objArg(tx, policy), policyCap],
-	});
-}
-
-/**
- * Calculates the amount to be paid for the royalty rule to be resolved,
- * splits the coin to pass the exact amount,
- * then calls the `royalty_rule::pay` function to resolve the royalty rule.
- */
-export function resolveRoyaltyRule(
-	tx: TransactionBlock,
-	itemType: string,
-	price: string,
-	policyId: ObjectArgument,
-	transferRequest: TransactionArgument,
-	environment: RulesEnvironmentParam,
-) {
-	const policyObj = objArg(tx, policyId);
-	// calculates the amount
-	const [amount] = tx.moveCall({
-		target: `${getRulePackageAddress(environment)}::royalty_rule::fee_amount`,
-		typeArguments: [itemType],
-		arguments: [policyObj, objArg(tx, price)],
-	});
-
-	// splits the coin.
-	const feeCoin = tx.splitCoins(tx.gas, [amount]);
-
-	// pays the policy
-	tx.moveCall({
-		target: `${getRulePackageAddress(environment)}::royalty_rule::pay`,
-		typeArguments: [itemType],
-		arguments: [policyObj, transferRequest, feeCoin],
-	});
-}
-
-/**
- * Locks the item in the supplied kiosk and
- * proves to the `kiosk_lock` rule that the item was indeed locked,
- * by calling the `kiosk_lock_rule::prove` function to resolve it.
- */
-export function resolveKioskLockRule(
-	tx: TransactionBlock,
-	itemType: string,
-	item: TransactionArgument,
-	kiosk: ObjectArgument,
-	kioskCap: ObjectArgument,
-	policyId: ObjectArgument,
-	transferRequest: TransactionArgument,
-	environment: RulesEnvironmentParam,
-) {
-	// lock item in the kiosk.
-	lock(tx, itemType, kiosk, kioskCap, policyId, item);
-
-	// proves that the item is locked in the kiosk to the TP.
-	tx.moveCall({
-		target: `${getRulePackageAddress(environment)}::kiosk_lock_rule::prove`,
-		typeArguments: [itemType],
-		arguments: [transferRequest, objArg(tx, kiosk)],
+		arguments: [objArg(tx, policy), objArg(tx, policyCap)],
 	});
 }