@tradeport/sui-trading-sdk 0.5.3 → 0.5.5

package/src/methods/acceptNftBids/addAcceptNftBidTxs.ts

@@ -0,0 +1,438 @@
+import { type TransactionArgument } from '@mysten/sui/transactions';
+import { normalizeSuiObjectId, SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils';
+import {
+	BLUEMOVE_CREATOR_CONFIG_OBJECT,
+	BLUEMOVE_MARKET_CONFIG_OBJECT,
+	BLUEMOVE_OFFER_DATA_OBJECT,
+	BLUEMOVE_ROYALTY_COLLECTION_OBJECT,
+	TRADEPORT_BIDDING_STORE,
+	TRADEPORT_KIOSK_BIDDING_STORE,
+	TRADEPORT_MULTI_BID_PACKAGE,
+	TRADEPORT_MULTI_BID_STORE,
+} from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchMultibidChainIdById } from '../../graphql/queries/fetchMultibidById';
+import { getRoyaltyRuleModule } from '../../helpers/getRoyaltyRuleModule';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { getTransferPolicyRuleNamesFromSuiObject } from '../../helpers/getTransferPolicyRuleNamesFromSuiObject';
+import { hasPersonalKioskRule } from '../../helpers/hasPersonalKioskRule';
+import { hasNativeKioskTransferPolicyRules } from '../../helpers/hasTransferPolicyRules';
+import { isSingleBid } from '../../helpers/isSIngleBid';
+import { assertNftInSharedKiosk } from '../../helpers/kiosk/assertNftInSharedKiosk';
+import {
+	getNativeKioskTransferPolicies,
+	knownTransferPolicyRules,
+} from '../../helpers/kiosk/getNativeKioskTransferPolicies';
+import { getRulePackageId } from '../../helpers/kiosk/getRulePackageId';
+import { isTradePortKioskBid } from '../../helpers/kiosk/isTradePortKioskBid';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { lockNftInsideKioskIfNotLocked } from '../../helpers/kiosk/lockNftInsideKioskIfNotLocked';
+import {
+	resolveCustomTransferPolicyRules,
+	customTransferPolicyRuleNames,
+} from '../../helpers/kiosk/resolveCustomTransferPolicyRules';
+import { resolveTransferPolicies } from '../../helpers/kiosk/resolveTransferPolicies';
+import { confirmOBTranfer } from '../../helpers/originByte/confirmOBTranfer';
+import { getOBBidderKiosk } from '../../helpers/originByte/getOBBidderKiosk';
+import { isOriginByteBid } from '../../helpers/originByte/isOriginByteBid';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { getObjectType } from '../../helpers/rpc/getObjectType';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { type AcceptNftBidTx } from './acceptNftBids';
+
+export function addTradeportAcceptNftBidTx({
+	tx,
+	sharedObjects,
+	bidNonce,
+	nftTokenId,
+	nftType,
+}: AcceptNftBidTx) {
+	const { collection, royaltyStrategy } = sharedObjects;
+
+	if (collection && royaltyStrategy) {
+		tx.moveCall({
+			target:
+				'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::ob_accept_bid',
+			arguments: [
+				tx.object(TRADEPORT_BIDDING_STORE),
+				tx.pure.address(bidNonce),
+				tx.object(nftTokenId),
+				tx.object(collection),
+				tx.object(royaltyStrategy),
+			],
+			typeArguments: [nftType],
+		});
+	} else {
+		tx.moveCall({
+			target:
+				'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::accept_bid',
+			arguments: [
+				tx.object(TRADEPORT_BIDDING_STORE),
+				tx.pure.address(bidNonce),
+				tx.object(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+	}
+}
+
+export async function addTradeportKioskAcceptNftBidTx({
+	tx,
+	suiClient,
+	kioskClient,
+	transferPolicies,
+	seller,
+	kioskTx,
+	bidNonce,
+	nftTokenId,
+	nftType,
+	royaltyRulePackageId,
+	royaltyRuleModule,
+	bidAmount,
+	shouldSplitRoyaltyFromUserGasCoins,
+	beforeResolveKioskTransferRequest,
+}: AcceptNftBidTx) {
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	await lockNftInsideKioskIfNotLocked({
+		tx,
+		kioskClient,
+		kioskTx,
+		nftTokenId,
+		nftType,
+		transferPolicyId,
+	});
+
+	if (beforeResolveKioskTransferRequest) {
+		const [feeCoin, transferRequest] = tx.moveCall({
+			target:
+				'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::accept_bid_with_price_lock',
+			arguments: [
+				tx.object(TRADEPORT_KIOSK_BIDDING_STORE),
+				tx.pure.address(bidNonce),
+				tx.object(kioskTx.kiosk),
+				tx.object(kioskTx.kioskCap),
+				tx.pure.address(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+
+		await beforeResolveKioskTransferRequest?.(feeCoin, transferRequest);
+
+		await resolveTransferPolicies({
+			tx,
+			transferPolicies,
+			suiClient,
+			walletAddress: seller,
+			kioskTx,
+			kioskClient,
+			nftType,
+			price: bidAmount?.toString(),
+			transferRequest,
+			coinToSplit: feeCoin,
+			shouldSkipKioskLocking: true,
+		});
+
+		tx.transferObjects([tx.object(feeCoin)], tx.pure.address(addLeadingZerosAfter0x(seller)));
+	} else {
+		const [feeCoin, transferRequest] = tx.moveCall({
+			target:
+				'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::accept_bid_with_purchase_cap',
+			arguments: [
+				tx.object(TRADEPORT_KIOSK_BIDDING_STORE),
+				tx.pure.address(bidNonce),
+				tx.object(kioskTx.kiosk),
+				tx.object(kioskTx.kioskCap),
+				tx.pure.address(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+
+		if (!shouldSplitRoyaltyFromUserGasCoins) {
+			tx.moveCall({
+				target: `${royaltyRulePackageId}::${royaltyRuleModule}::pay`,
+				typeArguments: [nftType],
+				arguments: [tx.object(transferPolicyId), transferRequest, feeCoin],
+			});
+		}
+
+		await resolveTransferPolicies({
+			tx,
+			transferPolicies,
+			suiClient,
+			walletAddress: seller,
+			kioskTx,
+			kioskClient,
+			nftType,
+			price: shouldSplitRoyaltyFromUserGasCoins ? bidAmount?.toString() : '0',
+			transferRequest,
+			shouldSkipKioskLocking: true,
+			shouldSkipResolvingRoyaltyRule: !shouldSplitRoyaltyFromUserGasCoins,
+		});
+
+		if (shouldSplitRoyaltyFromUserGasCoins) {
+			tx.transferObjects([tx.object(feeCoin)], tx.pure.address(addLeadingZerosAfter0x(seller)));
+		}
+	}
+}
+
+export async function addOriginByteAcceptNftBidTx({
+	tx,
+	suiClient,
+	sharedObjects,
+	sellerKiosk,
+	bidNonce,
+	nftTokenId,
+	nftType,
+	itemOwner,
+}: AcceptNftBidTx) {
+	await assertNftInSharedKiosk({
+		kioskId: sellerKiosk,
+		walletAddress: itemOwner,
+	});
+
+	const receiverKiosk = await getOBBidderKiosk({ suiClient, bidNonce });
+
+	let transferRequest: TransactionArgument;
+	if (sellerKiosk) {
+		transferRequest = tx.moveCall({
+			target:
+				'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::sell_nft_from_kiosk',
+			arguments: [
+				tx.object(bidNonce),
+				tx.object(sellerKiosk),
+				tx.object(receiverKiosk),
+				tx.pure.address(nftTokenId),
+			],
+			typeArguments: [nftType, '0x2::sui::SUI'],
+		});
+	} else {
+		transferRequest = tx.moveCall({
+			target:
+				'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::sell_nft',
+			arguments: [tx.object(bidNonce), tx.object(receiverKiosk), tx.object(nftTokenId)],
+			typeArguments: [nftType, '0x2::sui::SUI'],
+		});
+	}
+
+	confirmOBTranfer({ tx, sharedObjects, transferRequest, nftType });
+}
+
+export function addBluemoveAcceptNftBidTx({
+	tx,
+	nftTokenId,
+	nftType,
+	bidNonce,
+	isListedOnBluemove,
+}: AcceptNftBidTx) {
+	if (isListedOnBluemove) {
+		tx.moveCall({
+			target:
+				'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist',
+			arguments: [tx.object(BLUEMOVE_MARKET_CONFIG_OBJECT), tx.pure.address(nftTokenId)],
+			typeArguments: [nftType, nftType],
+		});
+	}
+
+	tx.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_item::accept_offer_nft',
+		arguments: [
+			tx.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+			tx.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+			tx.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+			tx.object(BLUEMOVE_OFFER_DATA_OBJECT),
+			tx.pure.u64(bidNonce),
+			isListedOnBluemove
+				? ({
+						kind: 'Result',
+						index: 0,
+					} as any)
+				: tx.object(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addSingleBidAcceptNftBidTx(txData: AcceptNftBidTx) {
+	const { nftType, tx, bidNonce, multiBidId, nftTokenId, suiClient, sharedKioskState } = txData;
+	const transferPolicies = getNativeKioskTransferPolicies(txData?.transferPolicies);
+	const transferPolicy = transferPolicies?.find(
+		(policy: { rules: any[] }) => policy?.rules?.length > 0,
+	);
+	const { chain_id: multiBidChainId, cancelled_at } = multiBidId
+		? ((
+				await gqlChainRequest({
+					chain: 'sui',
+					query: fetchMultibidChainIdById,
+					variables: { multiBidId },
+				})
+			)?.multi_bids?.[0] ?? {})
+		: {};
+
+	if (multiBidChainId && cancelled_at) {
+		throw new Error(`MultiBid ${multiBidId} already cancelled`);
+	}
+
+	if (transferPolicy) {
+		const allRules = await getTransferPolicyRuleNamesFromSuiObject({
+			suiClient,
+			transferPolicyId: transferPolicy.id,
+		});
+
+		const unsupportedRule = allRules.find((r) => {
+			const moduleName = r.split('::').at(1);
+			return (
+				!knownTransferPolicyRules.includes(moduleName) &&
+				!customTransferPolicyRuleNames.includes(moduleName)
+			);
+		});
+		if (unsupportedRule) {
+			throw new Error(
+				`Found unsupported transfer policy rule ${unsupportedRule} for ${transferPolicy.id} of ${nftType}`,
+			);
+		}
+
+		return kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: txData?.kioskClient,
+			kioskOwner: txData?.seller,
+			kiosk: txData?.sellerKiosk,
+			sharedKioskState,
+			async runCommands(kioskTx) {
+				if (!txData?.sellerKiosk) {
+					kioskTx.place({
+						item: txData?.nftTokenId,
+						itemType: txData?.nftType,
+					});
+				}
+
+				const [transferRequest] = tx.moveCall({
+					target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::accept_bid_with_transfer_policy`,
+					typeArguments: [nftType],
+					arguments: [
+						tx.object(SUI_CLOCK_OBJECT_ID),
+						tx.object(TRADEPORT_MULTI_BID_STORE),
+						tx.pure.id(normalizeSuiObjectId(bidNonce)),
+						tx.pure.option('id', multiBidChainId),
+						tx.object(kioskTx.getKiosk() as any),
+						tx.object(kioskTx.getKioskCap() as any),
+						tx.pure.id(nftTokenId),
+						tx.object(transferPolicy.id),
+					],
+				});
+				// The contract resolves itself to the standard transfer policy rules
+				// Resolve custom transfer policy rules (e.g. table_allowlist_rule)
+				const customRules = allRules
+					.filter((r) => customTransferPolicyRuleNames.includes(r.split('::').at(1)))
+					.map((rule) => ({
+						rule,
+						rulePackageId: rule.split('::')[0],
+						moduleName: rule.split('::')[1],
+					}));
+				if (customRules.length > 0) {
+					resolveCustomTransferPolicyRules({
+						tx,
+						rules: customRules,
+						transferRequest,
+						nftType,
+						policyId: transferPolicy.id,
+					});
+				}
+
+				tx.moveCall({
+					target: '0x2::transfer_policy::confirm_request',
+					arguments: [tx.object(transferPolicy.id), transferRequest],
+					typeArguments: [nftType],
+				});
+			},
+		});
+	}
+
+	if (txData.sellerKiosk) {
+		throw new Error(`Can't use NFT in kiosk without transfer policy`);
+	}
+
+	tx.moveCall({
+		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::accept_bid_without_transfer_policy`,
+		typeArguments: [nftType],
+		arguments: [
+			tx.object(SUI_CLOCK_OBJECT_ID),
+			tx.object(TRADEPORT_MULTI_BID_STORE),
+			tx.pure.id(bidNonce),
+			tx.pure.option('id', multiBidChainId),
+			tx.object(nftTokenId),
+		],
+	});
+}
+
+export async function addTradePortAcceptNftBidTxHandler(txData: AcceptNftBidTx) {
+	const bidType = await getObjectType({
+		suiClient: txData?.suiClient,
+		objectId: normalizeSuiObjectId(txData?.bidNonce),
+	});
+
+	if (isSingleBid(bidType)) {
+		await addSingleBidAcceptNftBidTx(txData);
+		return;
+	}
+
+	if (isOriginByteBid(bidType)) {
+		if (isOriginByteCollection(txData?.transferPolicies)) {
+			const sharedObjects = await getSharedObjects(txData?.nftType);
+			await addOriginByteAcceptNftBidTx({ ...txData, sharedObjects });
+
+			return;
+		}
+
+		throw new Error(
+			`You cannot accept an Origin Byte bid with a NFT outside of an Origin Byte kiosk. Nft Token Id: ${txData?.nftTokenId}`,
+		);
+	}
+
+	if (isTradePortKioskBid(bidType)) {
+		if (txData?.sellerKiosk) {
+			const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
+			const royaltyRulePackageId = await getRulePackageId({
+				transferPolicies: txData?.transferPolicies,
+				suiClient: txData?.suiClient,
+				nftType: txData?.nftType,
+				ruleType: 'royalty_rule',
+				kioskClient: txData?.kioskClient,
+			});
+
+			return kioskTxWrapper({
+				tx: txData?.tx,
+				kioskClient: txData?.kioskClient,
+				kioskOwner: txData?.itemOwner,
+				kiosk: txData?.sellerKiosk,
+				shouldConvertToPersonalKiosk: Boolean(hasPersonalKioskRule(txData?.transferPolicies)),
+				shouldAssertNftInSharedKiosk: true,
+				failIfNoKiosk: Boolean(txData?.sellerKiosk),
+				sharedKioskState: txData?.sharedKioskState,
+				async runCommands(kioskTx) {
+					if (hasNativeKioskTransferPolicyRules(txData?.transferPolicies) && !txData?.sellerKiosk) {
+						kioskTx.place({
+							item: txData?.nftTokenId,
+							itemType: txData?.nftType,
+						});
+					}
+
+					await addTradeportKioskAcceptNftBidTx({
+						...txData,
+						kioskTx,
+						royaltyRulePackageId,
+						royaltyRuleModule,
+					});
+				},
+			});
+		}
+
+		throw new Error(
+			`You cannot accept an Native Kiosk Bid with a NFT outside of a native kiosk. Nft Token Id: ${txData?.nftTokenId}`,
+		);
+	}
+
+	const sharedObjects = await getSharedObjects(txData?.nftType);
+	addTradeportAcceptNftBidTx({ ...txData, sharedObjects });
+}

package/src/methods/applyFtStrategy/applyFtStrategy.ts

@@ -0,0 +1,55 @@
+import { Transaction } from '@mysten/sui/transactions';
+import {
+	TRADEPORT_NFT_STRATEGY_PACKAGE_ID,
+	TRADEPORT_NFT_STRATEGY_MANAGER_ID,
+	TRADEPORT_POOL_REGISTRY_ID,
+	TRADEPORT_POOL_VERSIONED_ID,
+} from '../../constants';
+import { getCollectionChainState } from '../../helpers/getCollectionChainState';
+
+export type ApplyFtStrategy = {
+	collectionId: string;
+	strategyFtType?: string;
+	tx?: Transaction;
+	collectionChainState?: Record<string, unknown>;
+};
+
+export async function applyFtStrategy({
+	collectionId,
+	strategyFtType,
+	tx: existingTx,
+	collectionChainState,
+}: ApplyFtStrategy): Promise<Transaction> {
+	const tx = existingTx ?? new Transaction();
+	const chainState = collectionChainState ?? (await getCollectionChainState(collectionId));
+	const nftStrategies = (chainState?.nft_strategies ?? {}) as Record<
+		string,
+		Record<string, unknown>
+	>;
+	const nftStrategyKeys = Object.keys(nftStrategies);
+	const nftType = chainState?.nft_type as string;
+
+	if (nftStrategyKeys.length === 0) {
+		throw new Error('No NFT strategies found for collection');
+	}
+
+	strategyFtType = strategyFtType ?? nftStrategyKeys[0];
+
+	if (!nftStrategyKeys.includes(strategyFtType)) {
+		throw new Error(`Specified FT type ${strategyFtType} is not supported for this collection`);
+	}
+
+	tx.moveCall({
+		target: `${TRADEPORT_NFT_STRATEGY_PACKAGE_ID}::tradeport_nft_strategy::apply_ft_strategy`,
+		typeArguments: [nftType, strategyFtType],
+		arguments: [
+			tx.object(TRADEPORT_NFT_STRATEGY_MANAGER_ID),
+			tx.object((nftStrategies[strategyFtType] as { kiosk_id: string }).kiosk_id),
+			tx.object(TRADEPORT_POOL_REGISTRY_ID),
+			tx.object(TRADEPORT_POOL_VERSIONED_ID),
+			tx.object.clock(),
+		],
+	});
+
+	return tx;
+}

package/src/methods/applyNftStrategy/applyNftStrategy.ts

@@ -0,0 +1,90 @@
+import { Transaction } from '@mysten/sui/transactions';
+import {
+	TRADEPORT_NFT_STRATEGY_PACKAGE_ID,
+	TRADEPORT_NFT_STRATEGY_MANAGER_ID,
+	TRADEPORT_ORDERBOOK_STORE,
+	TRADEPORT_LISTINGS_STORE,
+} from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchCollectionFloorListingsForMarket } from '../../graphql/queries/fetchCollectionFloorListingForMarket';
+import { getNativeKioskTransferPolicies } from '../../helpers/kiosk/getNativeKioskTransferPolicies';
+import { RequestContext } from '../../SuiTradingClient';
+import { getCollectionChainState } from '../../helpers/getCollectionChainState';
+
+export type ApplyNftStrategy = {
+	collectionId: string;
+	strategyFtType?: string;
+	tx?: Transaction;
+};
+
+export async function applyTradeportNftStrategy({
+	collectionId,
+	strategyFtType,
+	tx: existingTx,
+}: ApplyNftStrategy): Promise<Transaction> {
+	const tx = existingTx ?? new Transaction();
+	const chainState = await getCollectionChainState(collectionId);
+	const nftStrategies = (chainState?.nft_strategies ?? {}) as Record<
+		string,
+		Record<string, unknown>
+	>;
+	const nftStrategyKeys = Object.keys(nftStrategies);
+	if (nftStrategyKeys.length === 0) {
+		throw new Error('No NFT strategies found for collection');
+	}
+
+	strategyFtType = strategyFtType ?? nftStrategyKeys[0];
+
+	if (!nftStrategyKeys.includes(strategyFtType)) {
+		throw new Error(`Specified FT type ${strategyFtType} is not supported for this collection`);
+	}
+
+	const transferPolicy = getNativeKioskTransferPolicies(chainState?.transfer_policies ?? [])?.at(0);
+
+	if (!transferPolicy) {
+		throw new Error('No transfer policy found for collection');
+	}
+
+	const nftType = chainState?.nft_type as string;
+	let suiBalance = BigInt(
+		(nftStrategies[strategyFtType] as { sui_balance: string }).sui_balance ?? 0n,
+	);
+
+	const result = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchCollectionFloorListingsForMarket,
+		variables: {
+			collectionId,
+			marketAddress: TRADEPORT_NFT_STRATEGY_MANAGER_ID,
+			totalPrice: suiBalance.toString(),
+		},
+	});
+	if ((result?.listings?.length ?? 0) === 0) {
+		throw new Error(
+			`No floor listing found for collection with price bellow or equal to ${suiBalance} MIST`,
+		);
+	}
+
+	for (const floorListing of result.listings) {
+		suiBalance -= BigInt(floorListing.price);
+		if (suiBalance < 0n) {
+			break;
+		}
+
+		tx.moveCall({
+			target: `${TRADEPORT_NFT_STRATEGY_PACKAGE_ID}::tradeport_nft_strategy::apply_tradeport_nft_strategy_confirm_request`,
+			typeArguments: [nftType, strategyFtType],
+			arguments: [
+				tx.object(TRADEPORT_NFT_STRATEGY_MANAGER_ID),
+				tx.object((nftStrategies[strategyFtType] as { kiosk_id: string }).kiosk_id),
+				tx.object(TRADEPORT_LISTINGS_STORE),
+				tx.object(TRADEPORT_ORDERBOOK_STORE),
+				tx.object(floorListing.nft.delegated_owner),
+				tx.object(floorListing.nft.token_id),
+				tx.object(transferPolicy.id),
+			],
+		});
+	}
+
+	return tx;
+}