@mysten/kiosk 0.6.0 → 0.7.1

package/src/tx/transfer-policy.ts

@@ -1,15 +1,15 @@
 // 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 { bcs } from '@mysten/sui.js/bcs';
 import {
-	ObjectArgument,
-	RulesEnvironmentParam,
-	TRANSFER_POLICY_MODULE,
-	TRANSFER_POLICY_TYPE,
-} from '../types';
+	TransactionArgument,
+	TransactionBlock,
+	TransactionObjectArgument,
+} 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.
@@ -19,20 +19,48 @@ export function createTransferPolicy(
 	tx: TransactionBlock,
 	itemType: string,
 	publisher: ObjectArgument,
-): TransactionArgument {
-	let [transferPolicy, transferPolicyCap] = tx.moveCall({
+): TransactionObjectArgument {
+	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,
+): [TransactionObjectArgument, TransactionObjectArgument] {
+	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: TransactionObjectArgument,
+) {
 	tx.moveCall({
 		target: `0x2::transfer::public_share_object`,
 		typeArguments: [`${TRANSFER_POLICY_TYPE}<${itemType}>`],
 		arguments: [transferPolicy],
 	});
-
-	return transferPolicyCap;
 }
 
 /**
@@ -43,14 +71,11 @@ export function withdrawFromPolicy(
 	itemType: string,
 	policy: ObjectArgument,
 	policyCap: ObjectArgument,
-	amount: string | bigint | null,
-): TransactionArgument {
-	let amountArg =
-		amount !== null
-			? tx.pure({ Some: amount }, 'Option<u64>')
-			: tx.pure({ None: true }, 'Option<u64>');
+	amount?: string | bigint | null,
+): TransactionObjectArgument {
+	const amountArg = bcs.option(bcs.u64()).serialize(amount);
 
-	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 +110,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)],
 	});
 }

package/src/types/index.ts

@@ -1,15 +1,36 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { SharedObjectRef } from '@mysten/sui.js/bcs';
-import { SuiObjectRef } from '@mysten/sui.js/client';
-import { TransactionArgument } from '@mysten/sui.js/transactions';
+import { type SharedObjectRef } from '@mysten/sui.js/bcs';
+import { type SuiClient, type SuiObjectRef } from '@mysten/sui.js/client';
+import { TransactionObjectArgument } from '@mysten/sui.js/transactions';
+
+import { BaseRulePackageIds } from '../constants';
 
 export * from './kiosk';
 export * from './transfer-policy';
-export * from './env';
 
 /**
  * A valid argument for any of the Kiosk functions.
  */
-export type ObjectArgument = string | TransactionArgument | SharedObjectRef | SuiObjectRef;
+export type ObjectArgument = string | TransactionObjectArgument | SharedObjectRef | SuiObjectRef;
+
+/**
+ * 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: SuiClient;
+	network: Network;
+	packageIds?: BaseRulePackageIds;
+};

package/src/types/kiosk.ts

@@ -1,8 +1,13 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { PaginatedObjectsResponse } from '@mysten/sui.js/client';
+import {
+	PaginatedObjectsResponse,
+	SuiObjectData,
+	SuiObjectDataOptions,
+} from '@mysten/sui.js/client';
 import { TransactionArgument } from '@mysten/sui.js/transactions';
+
 import { ObjectArgument } from '.';
 
 /** The Kiosk module. */
@@ -98,6 +103,10 @@ export type KioskItem = {
 	isLocked: boolean;
 	/** Optional listing */
 	listing?: KioskListing;
+	/** The ID of the kiosk the item is placed in */
+	kioskId: string;
+	/** Optional Kiosk Data */
+	data?: SuiObjectData;
 };
 /**
  * Aggregated data from the Kiosk.
@@ -117,8 +126,14 @@ export type PagedKioskData = {
 };
 
 export type FetchKioskOptions = {
+	/** Include the base kiosk object, which includes the profits, the owner and the base fields. */
 	withKioskFields?: boolean;
+	/** Include the listing prices. */
 	withListingPrices?: boolean;
+	/** Include the objects for the Items in the kiosk. Defaults to `display` only. */
+	withObjects?: boolean;
+	/** Pass the data options for the objects, when fetching, in case you want to query other details. */
+	objectOptions?: SuiObjectDataOptions;
 };
 
 export type OwnedKiosks = {
@@ -127,8 +142,18 @@ export type OwnedKiosks = {
 } & Omit<PaginatedObjectsResponse, 'data'>;
 
 export type KioskOwnerCap = {
+	isPersonal?: boolean;
 	objectId: string;
 	kioskId: string;
 	digest: string;
 	version: string;
 };
+
+export type PurchaseOptions = {
+	extraArgs?: Record<string, any>;
+};
+
+export type ItemId = { itemType: string; itemId: string };
+export type ItemReference = { itemType: string; item: ObjectArgument };
+export type ItemValue = { itemType: string; item: TransactionArgument };
+export type Price = { price: string | bigint };

package/src/types/transfer-policy.ts

@@ -1,7 +1,10 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { ObjectOwner } from '@mysten/sui.js/client';
+import { type ObjectOwner } from '@mysten/sui.js/client';
+import { TransactionObjectArgument, type TransactionBlock } from '@mysten/sui.js/transactions';
+
+import { ObjectArgument } from '.';
 
 /** The Transfer Policy module. */
 export const TRANSFER_POLICY_MODULE = '0x2::transfer_policy';
@@ -12,12 +15,24 @@ export const TRANSFER_POLICY_CREATED_EVENT = `${TRANSFER_POLICY_MODULE}::Transfe
 /** The Transfer Policy Type */
 export const TRANSFER_POLICY_TYPE = `${TRANSFER_POLICY_MODULE}::TransferPolicy`;
 
+/** The Transfer Policy Cap Type */
+export const TRANSFER_POLICY_CAP_TYPE = `${TRANSFER_POLICY_MODULE}::TransferPolicyCap`;
+
 /** The Kiosk Lock Rule */
 export const KIOSK_LOCK_RULE = 'kiosk_lock_rule::Rule';
 
 /** The Royalty rule */
 export const ROYALTY_RULE = 'royalty_rule::Rule';
 
+/**
+ * The Transfer Policy Cap in a consumable way.
+ */
+export type TransferPolicyCap = {
+	policyId: string;
+	policyCapId: string;
+	type: string;
+};
+
 /** The `TransferPolicy` object */
 export type TransferPolicy = {
 	id: string;
@@ -31,3 +46,22 @@ export type TransferPolicy = {
 export type TransferPolicyCreated = {
 	id: string;
 };
+
+// The object a Rule resolving function accepts
+// It can accept a set of fixed fields, that are part of every purchase flow as well any extra arguments to resolve custom policies!
+// Each rule resolving function should check that the key it's seeking is in the object
+// e.g. `if(!'my_key' in ruleParams!) throw new Error("Can't resolve that rule!")`
+export type RuleResolvingParams = {
+	transactionBlock: TransactionBlock;
+	itemType: string;
+	itemId: string;
+	price: string;
+	policyId: ObjectArgument;
+	sellerKiosk: ObjectArgument;
+	kiosk: ObjectArgument;
+	kioskCap: ObjectArgument;
+	transferRequest: TransactionObjectArgument;
+	purchasedItem: TransactionObjectArgument;
+	packageId: string;
+	extraArgs: Record<string, any>; // extraParams contains more possible {key, values} to pass for custom rules.
+};

package/src/utils.ts

@@ -2,44 +2,52 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { SharedObjectRef } from '@mysten/sui.js/bcs';
-import { SuiObjectRef, SuiObjectResponse } from '@mysten/sui.js/client';
-import { TransactionBlock, TransactionArgument } from '@mysten/sui.js/transactions';
-import { type DynamicFieldInfo } from '@mysten/sui.js/client';
+import {
+	PaginationArguments,
+	SuiClient,
+	SuiObjectData,
+	SuiObjectDataFilter,
+	SuiObjectDataOptions,
+	SuiObjectRef,
+	SuiObjectResponse,
+	type DynamicFieldInfo,
+} from '@mysten/sui.js/client';
+import { TransactionBlock, TransactionObjectArgument } from '@mysten/sui.js/transactions';
+import { normalizeSuiAddress } from '@mysten/sui.js/utils';
+
 import { bcs } from './bcs';
-import { KIOSK_TYPE, Kiosk, KioskData, KioskListing, RulesEnvironmentParam } from './types';
-import { MAINNET_RULES_PACKAGE_ADDRESS, TESTNET_RULES_PACKAGE_ADDRESS } from './constants';
-import { SuiClient, PaginationArguments } from '@mysten/sui.js/client';
-
-/* A simple map to the rule package addresses */
-// TODO: Supply the mainnet and devnet addresses.
-export const rulesPackageAddresses = {
-	mainnet: MAINNET_RULES_PACKAGE_ADDRESS,
-	testnet: TESTNET_RULES_PACKAGE_ADDRESS,
-	devnet: '',
-	custom: null,
-};
+import {
+	Kiosk,
+	KIOSK_TYPE,
+	KioskData,
+	KioskListing,
+	TRANSFER_POLICY_CAP_TYPE,
+	TransferPolicyCap,
+} from './types';
+
+const DEFAULT_QUERY_LIMIT = 50;
 
 /**
  * Convert any valid input into a TransactionArgument.
  *
- * @param tx The transaction to use for creating the argument.
+ * @param txb The Transaction Block
  * @param arg The argument to convert.
  * @returns The converted TransactionArgument.
  */
 export function objArg(
-	tx: TransactionBlock,
-	arg: string | SharedObjectRef | SuiObjectRef | TransactionArgument,
-): TransactionArgument {
+	txb: TransactionBlock,
+	arg: string | SharedObjectRef | SuiObjectRef | TransactionObjectArgument,
+): TransactionObjectArgument {
 	if (typeof arg === 'string') {
-		return tx.object(arg);
+		return txb.object(arg);
 	}
 
 	if ('digest' in arg && 'version' in arg && 'objectId' in arg) {
-		return tx.objectRef(arg);
+		return txb.objectRef(arg);
 	}
 
 	if ('objectId' in arg && 'initialSharedVersion' in arg && 'mutable' in arg) {
-		return tx.sharedObjectRef(arg);
+		return txb.sharedObjectRef(arg);
 	}
 
 	if ('kind' in arg) {
@@ -68,6 +76,7 @@ export function extractKioskData(
 	data: DynamicFieldInfo[],
 	listings: KioskListing[],
 	lockedItemIds: string[],
+	kioskId: string,
 ): KioskData {
 	return data.reduce<KioskData>(
 		(acc: KioskData, val: DynamicFieldInfo) => {
@@ -80,6 +89,7 @@ export function extractKioskData(
 						objectId: val.objectId,
 						type: val.objectType,
 						isLocked: false,
+						kioskId,
 					});
 					break;
 				case 'kiosk::Listing':
@@ -139,6 +149,23 @@ export function attachListingsAndPrices(
 	});
 }
 
+/**
+ * A helper that attaches the listing prices to kiosk listings.
+ */
+export function attachObjects(kioskData: KioskData, objects: SuiObjectData[]) {
+	const mapping = objects.reduce<Record<string, SuiObjectData>>(
+		(acc: Record<string, SuiObjectData>, obj) => {
+			acc[obj.objectId] = obj;
+			return acc;
+		},
+		{},
+	);
+
+	kioskData.items.forEach((item) => {
+		item.data = mapping[item.objectId] || undefined;
+	});
+}
+
 /**
  * A Helper to attach locked state to items in Kiosk Data.
  */
@@ -158,19 +185,6 @@ export function attachLockedItems(kioskData: KioskData, lockedItemIds: string[])
 	});
 }
 
-/**
- * A helper to get a rule's environment address.
- */
-export function getRulePackageAddress(environment: RulesEnvironmentParam): string {
-	// if we have custom environment, we return it.
-	if (environment.env === 'custom') {
-		if (!environment.address)
-			throw new Error('Please supply the custom package address for rules.');
-		return environment.address;
-	}
-	return rulesPackageAddresses[environment.env];
-}
-
 /**
  * A helper to fetch all DF pages.
  * We need that to fetch the kiosk DFs consistently, until we have
@@ -199,6 +213,70 @@ export async function getAllDynamicFields(
 	return data;
 }
 
+/**
+ * A helper to fetch all objects that works with pagination.
+ * It will fetch all objects in the array, and limit it to 50/request.
+ * Requests are sent using `Promise.all`.
+ */
+export async function getAllObjects(
+	client: SuiClient,
+	ids: string[],
+	options: SuiObjectDataOptions,
+	limit: number = DEFAULT_QUERY_LIMIT,
+) {
+	const chunks = Array.from({ length: Math.ceil(ids.length / limit) }, (_, index) =>
+		ids.slice(index * limit, index * limit + limit),
+	);
+
+	const results = await Promise.all(
+		chunks.map((chunk) => {
+			return client.multiGetObjects({
+				ids: chunk,
+				options,
+			});
+		}),
+	);
+
+	return results.flat();
+}
+
+/**
+ * A helper to return all owned objects, with an optional filter.
+ * It parses all the pages and returns the data.
+ */
+export async function getAllOwnedObjects({
+	client,
+	owner,
+	filter,
+	limit = DEFAULT_QUERY_LIMIT,
+	options = { showType: true, showContent: true },
+}: {
+	client: SuiClient;
+	owner: string;
+	filter?: SuiObjectDataFilter;
+	options?: SuiObjectDataOptions;
+	limit?: number;
+}) {
+	let hasNextPage = true;
+	let cursor = undefined;
+	const data: SuiObjectResponse[] = [];
+
+	while (hasNextPage) {
+		const result = await client.getOwnedObjects({
+			owner,
+			filter,
+			limit,
+			cursor,
+			options,
+		});
+		data.push(...result.data);
+		hasNextPage = result.hasNextPage;
+		cursor = result.nextCursor;
+	}
+
+	return data;
+}
+
 /**
  * Converts a number to basis points.
  * Supports up to 2 decimal points.
@@ -210,3 +288,33 @@ export function percentageToBasisPoints(percentage: number) {
 		throw new Error('Percentage needs to be in the [0,100] range.');
 	return Math.ceil(percentage * 100);
 }
+
+/**
+ * A helper to parse a transfer policy Cap into a usable object.
+ */
+export function parseTransferPolicyCapObject(
+	item: SuiObjectResponse,
+): TransferPolicyCap | undefined {
+	const type = (item?.data?.content as { type: string })?.type;
+
+	//@ts-ignore-next-line
+	const policy = item?.data?.content?.fields?.policy_id as string;
+
+	if (!type.includes(TRANSFER_POLICY_CAP_TYPE)) return undefined;
+
+	// Transform 0x2::transfer_policy::TransferPolicyCap<itemType> -> itemType
+	const objectType = type.replace(TRANSFER_POLICY_CAP_TYPE + '<', '').slice(0, -1);
+
+	return {
+		policyId: policy,
+		policyCapId: item.data?.objectId!,
+		type: objectType,
+	};
+}
+
+// Normalizes the packageId part of a rule's type.
+export function getNormalizedRuleType(rule: string) {
+	const normalizedRuleAddress = rule.split('::');
+	normalizedRuleAddress[0] = normalizeSuiAddress(normalizedRuleAddress[0]);
+	return normalizedRuleAddress.join('::');
+}

package/dist/tx/rules.d.ts

@@ -1,19 +0,0 @@
-import { TransactionBlock } from '@mysten/sui.js/transactions';
-import { ObjectArgument, RulesEnvironmentParam } from '../types';
-/**
- *  Adds the Kiosk Royalty rule to the Transfer Policy.
- *  You can pass the percentage, as well as a minimum amount.
- *  The royalty that will be paid is the MAX(percentage, minAmount).
- * 	You can pass 0 in either value if you want only percentage royalty, or a fixed amount fee.
- * 	(but you should define at least one of them for the rule to make sense).
- *
- * 	@param percentageBps The royalty percentage in basis points. Use `percentageToBasisPoints` helper to convert from percentage [0,100].
- * 	@param minAmount The minimum royalty amount per request in MIST.
- */
-export declare function attachRoyaltyRule(tx: TransactionBlock, type: string, policy: ObjectArgument, policyCap: ObjectArgument, percentageBps: number | string, // this is in basis points.
-minAmount: number | string, environment: RulesEnvironmentParam): void;
-/**
- * Adds the Kiosk Lock Rule to the Transfer Policy.
- * This Rule forces buyer to lock the item in the kiosk, preserving strong royalties.
- */
-export declare function attachKioskLockRule(tx: TransactionBlock, type: string, policy: ObjectArgument, policyCap: ObjectArgument, environment: RulesEnvironmentParam): void;

package/dist/types/env.d.ts

@@ -1,12 +0,0 @@
-export type Environment = 'mainnet' | 'testnet' | 'devnet' | 'custom';
-/** A Parameter to support environments for rules.  */
-export type RulesEnvironmentParam = {
-    env: Environment;
-    address?: string;
-};
-/** A default Testnet Environment object  */
-export declare const testnetEnvironment: RulesEnvironmentParam;
-/** A default Mainnet Environment object  */
-export declare const mainnetEnvironment: RulesEnvironmentParam;
-/** A helper to easily export a custom environment */
-export declare const customEnvironment: (address: string) => RulesEnvironmentParam;

package/src/tx/rules.ts

@@ -1,58 +0,0 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-import { TransactionBlock } from '@mysten/sui.js/transactions';
-import { ObjectArgument, RulesEnvironmentParam } from '../types';
-import { getRulePackageAddress, objArg } from '../utils';
-
-/**
- *  Adds the Kiosk Royalty rule to the Transfer Policy.
- *  You can pass the percentage, as well as a minimum amount.
- *  The royalty that will be paid is the MAX(percentage, minAmount).
- * 	You can pass 0 in either value if you want only percentage royalty, or a fixed amount fee.
- * 	(but you should define at least one of them for the rule to make sense).
- *
- * 	@param percentageBps The royalty percentage in basis points. Use `percentageToBasisPoints` helper to convert from percentage [0,100].
- * 	@param minAmount The minimum royalty amount per request in MIST.
- */
-export function attachRoyaltyRule(
-	tx: TransactionBlock,
-	type: string,
-	policy: ObjectArgument,
-	policyCap: ObjectArgument,
-	percentageBps: number | string, // this is in basis points.
-	minAmount: number | string,
-	environment: RulesEnvironmentParam,
-) {
-	if (Number(percentageBps) < 0 || Number(percentageBps) > 10_000)
-		throw new Error('Invalid basis point percentage. Use a value between [0,10000].');
-
-	tx.moveCall({
-		target: `${getRulePackageAddress(environment)}::royalty_rule::add`,
-		typeArguments: [type],
-		arguments: [
-			objArg(tx, policy),
-			objArg(tx, policyCap),
-			tx.pure(percentageBps, 'u16'),
-			tx.pure(minAmount, 'u64'),
-		],
-	});
-}
-
-/**
- * Adds the Kiosk Lock Rule to the Transfer Policy.
- * This Rule forces buyer to lock the item in the kiosk, preserving strong royalties.
- */
-export function attachKioskLockRule(
-	tx: TransactionBlock,
-	type: string,
-	policy: ObjectArgument,
-	policyCap: ObjectArgument,
-	environment: RulesEnvironmentParam,
-) {
-	tx.moveCall({
-		target: `${getRulePackageAddress(environment)}::kiosk_lock_rule::add`,
-		typeArguments: [type],
-		arguments: [objArg(tx, policy), objArg(tx, policyCap)],
-	});
-}

package/src/types/env.ts

@@ -1,20 +0,0 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-/* A list of environments. */
-export type Environment = 'mainnet' | 'testnet' | 'devnet' | 'custom';
-
-/** A Parameter to support environments for rules.  */
-export type RulesEnvironmentParam = { env: Environment; address?: string };
-
-/** A default Testnet Environment object  */
-export const testnetEnvironment: RulesEnvironmentParam = { env: 'testnet' };
-
-/** A default Mainnet Environment object  */
-export const mainnetEnvironment: RulesEnvironmentParam = { env: 'mainnet' };
-
-/** A helper to easily export a custom environment */
-export const customEnvironment = (address: string): RulesEnvironmentParam => ({
-	env: 'custom',
-	address,
-});