@tradeport/sui-trading-sdk 0.5.4 → 0.5.6

package/src/methods/acceptNftBids/addAcceptNftBidTxs.ts

@@ -1,438 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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;
-}