@tradeport/sui-trading-sdk 0.5.5 → 0.5.6

package/src/helpers/kiosk/getKioskPlaceBidCoin.ts

@@ -1,59 +0,0 @@
-import { type SuiGrpcClient } from '@mysten/sui/grpc';
-import { type Transaction } from '@mysten/sui/transactions';
-import { splitCoins } from '../splitCoins';
-import { getKioskCollectionRoyaltyFeeAmount } from './getKioskCollectionRoyaltyFeeAmount';
-
-export async function getKioskPlaceBidCoin({
-	tx,
-	suiClient,
-	bidder,
-	nftType,
-	bidAmount,
-	marketFeePrice,
-	royaltyRulePackageId,
-	royaltyRuleModule,
-	transferPolicyId,
-}: {
-	tx: Transaction;
-	suiClient: SuiGrpcClient;
-	bidder: string;
-	nftType: string;
-	bidAmount: number;
-	marketFeePrice: number;
-	royaltyRulePackageId?: string;
-	royaltyRuleModule?: string;
-	transferPolicyId: string;
-}) {
-	let coin;
-
-	if (royaltyRulePackageId && royaltyRuleModule) {
-		const royaltyFeeAmount = await getKioskCollectionRoyaltyFeeAmount({
-			tx,
-			suiClient,
-			walletAddress: bidder,
-			royaltyRulePackageId,
-			royaltyRuleModule,
-			transferPolicyId,
-			price: bidAmount,
-			nftType,
-		});
-
-		const [coin1, coin2] = splitCoins({
-			tx,
-			amounts: [tx.pure.u64(bidAmount + marketFeePrice), royaltyFeeAmount],
-		});
-		coin = coin1;
-
-		if (!coin1 || !coin2) throw new Error('Coin could not be split');
-
-		tx.mergeCoins(tx.object(coin1), [tx.object(coin2)]);
-	} else {
-		const [coin1] = splitCoins({
-			tx,
-			amounts: [tx.pure.u64(bidAmount + marketFeePrice)],
-		});
-		coin = coin1;
-	}
-
-	return coin;
-}

package/src/helpers/kiosk/getNativeKioskTransferPolicies.ts

@@ -1,29 +0,0 @@
-export const getNativeKioskTransferPolicies = (transferPolicies: any) => {
-	let nativeKioskTransferPolicies = transferPolicies?.filter(
-		(policy: any) =>
-			!policy?.is_origin_byte &&
-			!policy?.is_disabled &&
-			policy?.rules?.filter(
-				(rule: any) =>
-					rule?.type?.includes('royalty_rule') ||
-					rule?.type?.includes('kiosk_lock_rule') ||
-					rule?.type?.includes('personal_kiosk_rule') ||
-					rule?.type?.includes('floor_price_rule'),
-			)?.length > 0,
-	);
-
-	if (nativeKioskTransferPolicies?.length === 0 && transferPolicies?.length > 0) {
-		nativeKioskTransferPolicies = transferPolicies?.filter(
-			(policy: any) => !policy?.is_origin_byte && !policy?.is_disabled,
-		);
-	}
-
-	return nativeKioskTransferPolicies;
-};
-
-export const knownTransferPolicyRules = [
-	'royalty_rule',
-	'kiosk_lock_rule',
-	'personal_kiosk_rule',
-	'floor_price_rule',
-];

package/src/helpers/kiosk/getNativeKioskTransferPoliciesByNftType.ts

@@ -1,21 +0,0 @@
-import { gqlChainRequest } from '../../graphql/gqlChainRequest';
-import { fetchTransferPoliciesByType } from '../../graphql/queries/fetchTransferPoliciesByType';
-import { normalizedNftType } from '../../utils/normalizeNftType';
-import { getNativeKioskTransferPolicies } from './getNativeKioskTransferPolicies';
-
-export const getNativeKioskTransferPoliciesByNftType = async (nftType: string) => {
-	const res = await gqlChainRequest({
-		chain: 'sui',
-		query: fetchTransferPoliciesByType,
-		variables: { type: normalizedNftType(nftType) },
-	});
-
-	return getNativeKioskTransferPolicies(res?.transfer_policies_by_type);
-};
-
-export const knownTransferPolicyRules = [
-	'royalty_rule',
-	'kiosk_lock_rule',
-	'personal_kiosk_rule',
-	'floor_price_rule',
-];

package/src/helpers/kiosk/getRulePackageId.ts

@@ -1,59 +0,0 @@
-import { getNormalizedRuleType, type KioskClient } from '@mysten/kiosk';
-import { type SuiGrpcClient } from '@mysten/sui/grpc';
-import { addHexPrefix } from '../../utils/addHexPrefix';
-import { normalizedNftType } from '../../utils/normalizeNftType';
-import { getTransferPolicyRuleNamesFromSuiObject } from '../getTransferPolicyRuleNamesFromSuiObject';
-import { getNativeKioskTransferPolicies } from './getNativeKioskTransferPolicies';
-import { upgradeKioskRulesPackageId } from './upgradeKioskRulesPackageId';
-
-type RuleType = 'kiosk_royalty_rule' | 'royalty_rule' | 'personal_kiosk_rule' | 'kiosk_lock_rule';
-
-export const getRulePackageId = async ({
-	transferPolicies,
-	nftType,
-	ruleType,
-	kioskClient,
-	suiClient,
-}: {
-	transferPolicies: any[];
-	suiClient: SuiGrpcClient;
-	nftType: string;
-	ruleType: RuleType;
-	kioskClient: KioskClient;
-}) => {
-	let rule: string | undefined;
-
-	if (transferPolicies.length > 0) {
-		const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
-
-		const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
-			suiClient,
-			transferPolicyId,
-		});
-
-		rule = ruleNames.filter((ruleName) => ruleName?.split('::')?.[1] === ruleType)?.[0];
-	} else {
-		const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
-			type: normalizedNftType(nftType),
-		});
-
-		if (transferPoliciesFromMystenSdk.length > 0) {
-			rule = transferPoliciesFromMystenSdk
-				.flatMap((policy) => policy.rules)
-				.filter((rule) => rule?.split('::')?.[1] === ruleType)?.[0];
-		} else {
-			throw new Error(`No transfer policy found for ${nftType}`);
-		}
-	}
-
-	const ruleDefinition = kioskClient.rules.find(
-		(x) => getNormalizedRuleType(x.rule) === getNormalizedRuleType(rule),
-	);
-
-	let rulePackageId = ruleDefinition?.packageId;
-	if (!rulePackageId) {
-		rulePackageId = rule?.split('::')?.[0];
-	}
-
-	return upgradeKioskRulesPackageId(addHexPrefix(rulePackageId));
-};

package/src/helpers/kiosk/getTransferPoliciesToResolve.ts

@@ -1,154 +0,0 @@
-import { getNormalizedRuleType, type KioskClient } from '@mysten/kiosk';
-import { type SuiGrpcClient } from '@mysten/sui/grpc';
-import { normalizedNftType } from '../../utils/normalizeNftType';
-import { getTransferPolicyRuleNamesFromSuiObject } from '../getTransferPolicyRuleNamesFromSuiObject';
-import {
-	getNativeKioskTransferPolicies,
-	knownTransferPolicyRules,
-} from './getNativeKioskTransferPolicies';
-import { upgradeKioskRulesPackageId } from './upgradeKioskRulesPackageId';
-
-interface RuleData {
-	rule: string;
-	rulePackageId?: string;
-	moduleName?: string;
-}
-
-export type Policy = {
-	id: string;
-	type?: string;
-	isCustom: boolean;
-	rules: RuleData[];
-};
-
-type Props = {
-	transferPolicies: any[];
-	suiClient: SuiGrpcClient;
-	kioskClient: KioskClient;
-	nftType: string;
-	customTransferPolicies?: any;
-};
-
-const originByteRuleModules = ['royalty_strategy_bps', 'transfer_allowlist'];
-
-export const getTransferPoliciesToResolve = async ({
-	transferPolicies,
-	suiClient,
-	kioskClient,
-	nftType,
-	customTransferPolicies,
-}: Props): Promise<Policy[]> => {
-	let policies: Policy[] = [];
-
-	if (transferPolicies.length > 0) {
-		const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
-
-		if (transferPolicyId) {
-			const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
-				suiClient,
-				transferPolicyId,
-			});
-
-			policies = [
-				{
-					id: transferPolicyId,
-					rules: ruleNames?.map((rule) => ({
-						rule,
-					})),
-					isCustom: false,
-				},
-			];
-		}
-	} else {
-		const transferPoliciesFromMystenSdk = await kioskClient.getTransferPolicies({
-			type: normalizedNftType(nftType),
-		});
-
-		if (transferPoliciesFromMystenSdk.length > 0) {
-			const policy =
-				transferPoliciesFromMystenSdk.find((policy) =>
-					policy?.rules?.some((rule) =>
-						knownTransferPolicyRules.some((ruleType) => rule?.includes(ruleType)),
-					),
-				) ?? transferPoliciesFromMystenSdk[0];
-
-			policies = [
-				{
-					id: policy.id,
-					rules: policy.rules?.map((rule) => ({
-						rule,
-					})),
-					isCustom: false,
-				},
-			];
-		} else {
-			throw new Error(
-				`Missing transfer policy of ${nftType}. No way to resolve the transfer request.`,
-			);
-		}
-	}
-
-	if (customTransferPolicies) {
-		for (const customTransferPolicy of customTransferPolicies) {
-			const customPolicy = await kioskClient.getTransferPolicies({
-				type: normalizedNftType(customTransferPolicy?.type),
-			});
-			policies = [
-				...policies,
-				{
-					id: customPolicy[0].id,
-					rules: customPolicy[0].rules?.map((rule) => ({
-						rule,
-					})),
-					isCustom: true,
-					type: customTransferPolicy?.type,
-				},
-			];
-		}
-	}
-
-	return policies.map((policy) => {
-		const kioskLockRule = policy?.rules.find((rule: RuleData) =>
-			rule?.rule?.includes('kiosk_lock_rule'),
-		);
-
-		const personalKioskRule = policy?.rules.find((rule: RuleData) =>
-			rule.rule.includes('personal_kiosk_rule'),
-		);
-
-		const otherRules = policy?.rules.filter(
-			(rule: RuleData) =>
-				!rule?.rule?.includes('kiosk_lock_rule') && !rule?.rule?.includes('personal_kiosk_rule'),
-		);
-
-		return {
-			...policy,
-			rules: [kioskLockRule, personalKioskRule, ...otherRules].filter(Boolean)?.map((ruleData) => {
-				const ruleDefinition = kioskClient.rules.find(
-					(x: any) => getNormalizedRuleType(x.rule) === getNormalizedRuleType(ruleData.rule),
-				);
-
-				let rulePackageId = ruleDefinition?.packageId;
-				if (!rulePackageId) {
-					rulePackageId = ruleData?.rule?.split('::')?.[0];
-				}
-
-				rulePackageId = upgradeKioskRulesPackageId(rulePackageId);
-
-				const moduleName = ruleData?.rule?.split('::')?.[1];
-
-				if (originByteRuleModules.includes(moduleName)) {
-					throw new Error(
-						`Using Origin Byte rule ${ruleData.rule} inside the native kiosk transaction`,
-					);
-				}
-
-				return {
-					...ruleData,
-					rulePackageId,
-					moduleName,
-				};
-			}),
-		};
-	});
-};

package/src/helpers/kiosk/isBluemoveKioskBid.ts

@@ -1 +0,0 @@
-export const isBluemoveKioskBid = (bidNonce: string): boolean => bidNonce?.startsWith('10000');

package/src/helpers/kiosk/isTradePortKioskBid.ts

@@ -1,4 +0,0 @@
-import { TRADEPORT_KIOSK_BID_NONCE_TYPE } from '../../constants';
-
-export const isTradePortKioskBid = (bidType: string): boolean =>
-	bidType === TRADEPORT_KIOSK_BID_NONCE_TYPE;

package/src/helpers/kiosk/kioskListingBcs.ts

@@ -1,19 +0,0 @@
-import { bcs } from '@mysten/sui/bcs';
-
-const PurchaseCap = bcs.struct('PurchaseCap', {
-	id: bcs.Address,
-	kiosk_id: bcs.Address,
-	item_id: bcs.Address,
-	min_price: bcs.u64(),
-});
-
-export const KioskListing = bcs.struct('KioskListing', {
-	id: bcs.Address,
-	seller: bcs.Address,
-	kiosk_id: bcs.Address,
-	nft_id: bcs.Address,
-	cap: PurchaseCap,
-	price: bcs.u64(),
-	commission: bcs.u64(),
-	beneficiary: bcs.Address,
-});

package/src/helpers/kiosk/kioskTxWrapper.ts

@@ -1,152 +0,0 @@
-import { type KioskClient, KioskTransaction } from '@mysten/kiosk';
-import { type Transaction } from '@mysten/sui/transactions';
-import { gqlChainRequest } from '../../graphql/gqlChainRequest';
-import { fetchKiosksByOwner } from '../../graphql/queries/fetchKiosksByOwner';
-import { fetchOwnerCapByKiosk } from '../../graphql/queries/fetchOwnerCapByKiosk';
-import { fetchPersonalCapByKiosk } from '../../graphql/queries/fetchPersonalCapByKiosk';
-import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
-import { assertNftInSharedKiosk } from './assertNftInSharedKiosk';
-import { type SharedKioskState } from './sharedKioskState.type';
-
-type Args = {
-	tx: Transaction;
-	kioskClient: KioskClient;
-	kioskOwner: string;
-	kiosk?: any;
-	runCommands: (kioskTx: KioskTransaction) => Promise<void>;
-	shouldConvertToPersonalKiosk?: boolean;
-	shouldAssertNftInSharedKiosk?: boolean;
-	shouldAllowNftUnsharedKiosk?: boolean;
-	kioskStrategy?: 'include' | 'exclude';
-	failIfNoKiosk?: boolean;
-	sharedKioskState?: SharedKioskState;
-	shouldUseSharedKioskTx?: boolean;
-};
-
-export const kioskTxWrapper = async ({
-	tx,
-	kioskClient,
-	kioskOwner,
-	kiosk,
-	runCommands,
-	shouldConvertToPersonalKiosk,
-	shouldAssertNftInSharedKiosk,
-	shouldAllowNftUnsharedKiosk,
-	kioskStrategy,
-	failIfNoKiosk,
-	sharedKioskState,
-	shouldUseSharedKioskTx = true,
-}: Args) => {
-	if (shouldUseSharedKioskTx && sharedKioskState?.kioskTx) {
-		await runCommands(sharedKioskState.kioskTx);
-		return;
-	}
-
-	if (!kioskOwner) {
-		throw new Error('No kiosk owner provided');
-	}
-
-	let kioskTx: KioskTransaction;
-
-	let kiosks =
-		sharedKioskState?.ownerKiosks ??
-		(((
-			await gqlChainRequest({
-				chain: 'sui',
-				query: fetchKiosksByOwner,
-				variables: { ownerAddress: addLeadingZerosAfter0x(kioskOwner) },
-			})
-		).kiosks ?? []) as Array<{
-			id: string;
-			is_personal: boolean;
-			is_origin_byte: boolean;
-			is_shared: boolean;
-		}>);
-
-	if (sharedKioskState) {
-		sharedKioskState.ownerKiosks = kiosks;
-	}
-
-	if (shouldAssertNftInSharedKiosk) {
-		await assertNftInSharedKiosk({ kioskId: kiosk, walletAddress: kioskOwner, sharedKioskState });
-	}
-
-	kiosks = kiosks?.filter((k) => !k.is_origin_byte && (shouldAllowNftUnsharedKiosk || k.is_shared));
-
-	if (kiosk) {
-		let filteredKiosks = [];
-		switch (kioskStrategy ?? 'include') {
-			case 'include':
-				filteredKiosks = kiosks.filter((k) => k?.id === kiosk);
-				break;
-			case 'exclude':
-				filteredKiosks = kiosks.filter((k) => k?.id !== kiosk);
-				break;
-			default:
-				throw new Error(`Unsupported kiosk strategy ${kioskStrategy}`);
-		}
-
-		if (filteredKiosks.length > 0) {
-			kiosks = filteredKiosks;
-		} else if (failIfNoKiosk ?? false) {
-			throw new Error(`Kiosk ${kiosk} not found for account ${kioskOwner}`);
-		}
-	}
-
-	const personalKiosk = kiosks.find((k) => k.is_personal);
-
-	if (personalKiosk) {
-		// using existing personal kiosk
-		const personalKioskCapId = (
-			await gqlChainRequest({
-				chain: 'sui',
-				query: fetchPersonalCapByKiosk,
-				variables: { kioskId: personalKiosk.id },
-			})
-		).personalCap.id;
-		kioskTx = new KioskTransaction({
-			transaction: tx,
-			kioskClient,
-			cap: {
-				isPersonal: true,
-				objectId: personalKioskCapId,
-				kioskId: personalKiosk.id,
-				digest: '',
-				version: '',
-			},
-		});
-	} else if (kiosks.length > 0 && !shouldConvertToPersonalKiosk) {
-		const kioskCapId = (
-			await gqlChainRequest({
-				chain: 'sui',
-				query: fetchOwnerCapByKiosk,
-				variables: { kioskId: kiosks[0].id },
-			})
-		).ownerCap?.id;
-		kioskTx = new KioskTransaction({
-			transaction: tx,
-			kioskClient,
-			cap: {
-				isPersonal: false,
-				objectId: kioskCapId,
-				kioskId: kiosks[0].id,
-				digest: '',
-				version: '',
-			},
-		});
-	} else {
-		// creating new personal kiosk
-		kioskTx = new KioskTransaction({ transaction: tx, kioskClient });
-		kioskTx.createPersonal(true);
-	}
-
-	if (shouldUseSharedKioskTx && sharedKioskState) {
-		sharedKioskState.kioskTx = kioskTx;
-	}
-
-	await runCommands(kioskTx);
-
-	if (!sharedKioskState?.kioskTx) {
-		kioskTx.finalize();
-	}
-};

package/src/helpers/kiosk/lockNftInsideKioskIfNotLocked.ts

@@ -1,100 +0,0 @@
-import { type KioskClient, type KioskTransaction } from '@mysten/kiosk';
-import { type Transaction } from '@mysten/sui/transactions';
-import { getKioskIdFromKioskTx } from './getKioskIdFromKioskTx';
-
-export const lockNftInsideKioskIfNotLocked = async ({
-	tx,
-	kioskClient,
-	kioskTx,
-	nftTokenId,
-	nftType,
-	transferPolicyId,
-}: {
-	tx: Transaction;
-	kioskClient: KioskClient;
-	kioskTx: KioskTransaction;
-	nftTokenId: string;
-	nftType: string;
-	transferPolicyId: string;
-}) => {
-	if (
-		lockNftInsideKioskIfKioskCreatedInThisTx({ tx, kioskTx, nftTokenId, nftType, transferPolicyId })
-	) {
-		return;
-	}
-
-	const kioskId = getKioskIdFromKioskTx({ kioskTx, tx });
-	const res = await kioskClient.getKiosk({ id: kioskId });
-	const nftInKiosk = res.items.find((i) => i.objectId === nftTokenId);
-	let takeFromKiosk = true;
-
-	if (!nftInKiosk) {
-		const { object } = await (kioskClient.client as any).getObject({
-			objectId: nftTokenId,
-			include: {},
-		});
-		if (object?.owner?.$kind === 'AddressOwner') {
-			// NFT is owned by account
-			takeFromKiosk = false;
-		} else {
-			throw new Error(`NFT ${nftTokenId} is not found in kiosk ${kioskId}`);
-		}
-	}
-
-	if (!nftInKiosk?.isLocked) {
-		let takenNftId;
-
-		if (takeFromKiosk) {
-			const takenNft = kioskTx.take({
-				itemId: nftTokenId,
-				itemType: nftType,
-			});
-
-			takenNftId = (takenNft as any).value ?? takenNft;
-		}
-
-		kioskTx.lock({
-			item: takenNftId ?? nftTokenId,
-			itemType: nftType,
-			policy: transferPolicyId,
-		});
-	}
-};
-
-function lockNftInsideKioskIfKioskCreatedInThisTx({
-	tx,
-	kioskTx,
-	nftTokenId,
-	nftType,
-	transferPolicyId,
-}: {
-	tx: Transaction;
-	kioskTx: any;
-	nftTokenId: string;
-	nftType: string;
-	transferPolicyId: string;
-}) {
-	if (Array.isArray(kioskTx.kiosk.NestedResult)) {
-		const transaction = (tx as any).getData().commands[kioskTx.kiosk.NestedResult[0]] as {
-			target: string;
-		};
-		if (
-			transaction.target ===
-				'0x0000000000000000000000000000000000000000000000000000000000000002::kiosk::new' ||
-			transaction.target ===
-				'0x0000000000000000000000000000000000000000000000000000000000000002::personal_kiosk::new'
-		) {
-			// just created in this transaction block kiosk
-			kioskTx.lock({
-				item: nftTokenId,
-				itemType: nftType,
-				policy: transferPolicyId,
-			});
-			return true;
-		}
-
-		throw new Error(`Unsupported kiosk move call ${transaction.target}`);
-	}
-
-	return false;
-}