@tradeport/sui-trading-sdk 0.0.0

package/src/methods/acceptCollectionBid/addAcceptCollectionBIdTxs.ts

@@ -0,0 +1,359 @@
+import { type ObjectArgument } from '@mysten/kiosk';
+import {
+	BLUEMOVE_CREATOR_CONFIG_OBJECT,
+	BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT,
+	BLUEMOVE_KIOSK_OFFER_COLLECTION_BIDDER_BAG,
+	BLUEMOVE_KIOSK_OFFER_COLLECTION_DATA_OBJECT,
+	BLUEMOVE_MARKET_CONFIG_OBJECT,
+	BLUEMOVE_OFFER_COLLECTION_DATA_OBJECT,
+	BLUEMOVE_ROYALTY_COLLECTION_OBJECT,
+	TOCEN_MARKETPLACE_OBJECT,
+	TRADEPORT_BIDDING_STORE,
+} from '../../constants';
+import { hasTransferPolicyRules } from '../../helpers/hasTransferPolicyRules';
+import { getRulePackageId } from '../../helpers/kiosk/getRulePackageId';
+import { isBluemoveKioskBid } from '../../helpers/kiosk/isBluemoveKioskBid';
+import { isTradePortKioskBid } from '../../helpers/kiosk/isTradePortKioskBid';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { confirmOBTranfer } from '../../helpers/originByte/confirmOBTranfer';
+import { depositItemIntoOBKiosk } from '../../helpers/originByte/depositNftIntoOBKiosk';
+import { getOrCreateOBKiosk } from '../../helpers/originByte/getOrCreateOBKiosk';
+import { isOriginByteBid } from '../../helpers/originByte/isOriginByteBid';
+import { isOriginByteTx } from '../../helpers/originByte/isOriginByteTx';
+import { shareOriginByteKiosk } from '../../helpers/originByte/shareOriginByteKiosk';
+import { getObjectType } from '../../helpers/rpc/getObjectType';
+import { addTradeportKioskAcceptNftBidTx } from '../acceptNftBids/addAcceptNftBidTxs';
+import { addOriginByteUnlistTx } from '../unlistListings/addUnlistListingTxs';
+import { type AcceptCollectionBidTx } from './acceptCollectionBid';
+
+export function addTradeportAcceptCollectionBidTx({
+	txBlock,
+	sharedObjects,
+	nftTokenId,
+	nftType,
+	itemTakenOutOfNativeKiosk,
+	bidNonce,
+}: AcceptCollectionBidTx) {
+	const { collection, royaltyStrategy } = sharedObjects;
+
+	if (collection && royaltyStrategy) {
+		txBlock.moveCall({
+			target:
+				'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::ob_accept_bid',
+			arguments: [
+				txBlock.object(TRADEPORT_BIDDING_STORE),
+				txBlock.pure(bidNonce),
+				itemTakenOutOfNativeKiosk
+					? txBlock.object(itemTakenOutOfNativeKiosk)
+					: txBlock.pure(nftTokenId),
+				txBlock.object(collection),
+				txBlock.object(royaltyStrategy),
+			],
+			typeArguments: [nftType],
+		});
+	} else {
+		txBlock.moveCall({
+			target:
+				'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::accept_bid',
+			arguments: [
+				txBlock.object(TRADEPORT_BIDDING_STORE),
+				txBlock.pure(bidNonce),
+				itemTakenOutOfNativeKiosk
+					? txBlock.object(itemTakenOutOfNativeKiosk)
+					: txBlock.pure(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+	}
+}
+
+export const addTradeportKioskAcceptCollectionBidTx = async (txData: AcceptCollectionBidTx) => {
+	await addTradeportKioskAcceptNftBidTx(txData);
+};
+
+export async function addOriginByteAcceptCollectionBidTx(txData: AcceptCollectionBidTx) {
+	const {
+		txBlock,
+		sharedObjects,
+		sellerKiosk,
+		itemOwner,
+		nftTokenId,
+		nftType,
+		bidAmount,
+		bidNonce,
+		listingPrice,
+	} = txData;
+
+	if (listingPrice && listingPrice > 0) {
+		addOriginByteUnlistTx({
+			...txData,
+			price: txData?.listingPrice,
+		});
+	}
+
+	const { kiosk, isNewKiosk } = await getOrCreateOBKiosk({
+		txBlock,
+		address: itemOwner,
+		kioskToUseIfExists: sellerKiosk,
+	});
+
+	if (isNewKiosk) {
+		depositItemIntoOBKiosk({
+			txBlock,
+			kiosk: sellerKiosk,
+			nftTokenId,
+			nftType,
+		});
+	}
+
+	const { orderbook } = sharedObjects;
+
+	const [tradeInfo] = txBlock.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::market_sell',
+		arguments: [
+			txBlock.object(orderbook),
+			txBlock.object(kiosk),
+			txBlock.pure(bidAmount),
+			txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	const [id] = txBlock.moveCall({
+		target:
+			'0xa0bab69d913e5a0ce8b448235a08bcf4c42da45c50622743dc9cab2dc0dff30f::orderbook::trade_id',
+		arguments: [txBlock.object(tradeInfo)],
+		typeArguments: [],
+	});
+
+	const transferRequest = txBlock.moveCall({
+		target:
+			'0xa0bab69d913e5a0ce8b448235a08bcf4c42da45c50622743dc9cab2dc0dff30f::orderbook::finish_trade',
+		arguments: [
+			txBlock.object(orderbook),
+			txBlock.object(id),
+			txBlock.object(kiosk),
+			txBlock.object(bidNonce),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	confirmOBTranfer({ txBlock, sharedObjects, transferRequest, nftType });
+
+	if (isNewKiosk) {
+		await shareOriginByteKiosk({ txBlock, kiosk });
+	}
+}
+
+export function addBluemoveAcceptCollectionBidTx({
+	txBlock,
+	nftTokenId,
+	nftType,
+	bidNonce,
+	listingPrice,
+	itemTakenOutOfNativeKiosk,
+}: AcceptCollectionBidTx) {
+	let unlistedItem: ObjectArgument;
+	if (listingPrice && listingPrice > 0) {
+		unlistedItem = txBlock.moveCall({
+			target:
+				'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist',
+			arguments: [txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT), txBlock.pure(nftTokenId)],
+			typeArguments: [nftType, nftType],
+		});
+	}
+
+	txBlock.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_collection::accept_offer_collection',
+		arguments: [
+			txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+			txBlock.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+			txBlock.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+			txBlock.object(BLUEMOVE_OFFER_COLLECTION_DATA_OBJECT),
+			txBlock.pure(bidNonce),
+			itemTakenOutOfNativeKiosk
+				? txBlock.object(itemTakenOutOfNativeKiosk)
+				: unlistedItem
+					? txBlock.object(unlistedItem)
+					: txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addBluemoveKioskAcceptCollectionBidTx({
+	txBlock,
+	kioskTx,
+	nftTokenId,
+	nftType,
+	bidNonce,
+}: AcceptCollectionBidTx) {
+	txBlock.moveCall({
+		target:
+			'0x2949e130ca4dabfe6448173758468a3e45ea3f070e3264f112b51c023f3ecf9f::kiosk_offer_collection_v2::accept_offer_collection_v2',
+		arguments: [
+			txBlock.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
+			txBlock.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_DATA_OBJECT),
+			txBlock.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_BIDDER_BAG),
+			txBlock.pure(bidNonce),
+			txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+			txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export function addTocenAcceptCollectionBidTx({
+	txBlock,
+	nftTokenId,
+	nftType,
+	bidAmount,
+	bidder,
+}: AcceptCollectionBidTx) {
+	txBlock.moveCall({
+		target:
+			'0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::accept_offer_list',
+		arguments: [
+			txBlock.object(TOCEN_MARKETPLACE_OBJECT),
+			txBlock.pure(nftTokenId),
+			txBlock.pure(bidder),
+			txBlock.pure(bidAmount),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addTradePortAcceptCollectionBidTxHandler(txData: AcceptCollectionBidTx) {
+	const bidType = await getObjectType(txData?.bidNonce);
+
+	if (isOriginByteBid(bidType)) {
+		if (isOriginByteTx(txData?.sharedObjects)) {
+			await addOriginByteAcceptCollectionBidTx(txData);
+			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 nft has no transfer policy rules but is inside a kiosk, take it out of the kiosk
+	if (!(await hasTransferPolicyRules(txData?.nftType)) && txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			txBlock: txData?.txBlock,
+			kioskOwner: txData?.seller,
+			kiosk: txData?.sellerKiosk,
+			async tx(kioskTx) {
+				const item = kioskTx.take({
+					itemId: txData?.nftTokenId,
+					itemType: txData?.nftType,
+				});
+				addTradeportAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: item });
+			},
+		});
+	}
+
+	if (isTradePortKioskBid(bidType)) {
+		if (txData?.sellerKiosk) {
+			const royaltyRulePackageId = await getRulePackageId(txData.nftType, 'royalty_rule');
+			return kioskTxWrapper({
+				txBlock: txData?.txBlock,
+				kioskOwner: txData?.itemOwner,
+				kiosk: txData?.sellerKiosk,
+				async tx(kioskTx) {
+					await addTradeportKioskAcceptCollectionBidTx({
+						...txData,
+						kioskTx,
+						royaltyRulePackageId,
+					});
+				},
+			});
+		}
+
+		// If NFT not in a kiosk, but nft type has a transfer policy rule, create kiosk and place NFT in kiosk first
+		if ((await hasTransferPolicyRules(txData?.nftType)) && !txData?.sellerKiosk) {
+			const royaltyRulePackageId = await getRulePackageId(txData.nftType, 'royalty_rule');
+
+			return kioskTxWrapper({
+				txBlock: txData?.txBlock,
+				kioskOwner: txData?.seller,
+				kiosk: txData?.sellerKiosk,
+				async tx(kioskTx) {
+					kioskTx.place({
+						item: txData?.nftTokenId,
+						itemType: txData?.nftType,
+					});
+					await addTradeportKioskAcceptCollectionBidTx({
+						...txData,
+						kioskTx,
+						royaltyRulePackageId,
+					});
+				},
+			});
+		}
+	}
+
+	addTradeportAcceptCollectionBidTx(txData);
+}
+
+export async function addBluemoveAcceptCollectionBidTxHandler(txData: AcceptCollectionBidTx) {
+	const bidType = await getObjectType(txData?.bidNonce);
+
+	if (isOriginByteBid(bidType)) {
+		if (isOriginByteTx(txData?.sharedObjects)) {
+			await addOriginByteAcceptCollectionBidTx(txData);
+			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 (isBluemoveKioskBid(txData?.bidNonce)) {
+		if (txData?.sellerKiosk) {
+			return kioskTxWrapper({
+				txBlock: txData?.txBlock,
+				kioskOwner: txData?.itemOwner,
+				kiosk: txData?.sellerKiosk,
+				async tx(kioskTx) {
+					await addBluemoveKioskAcceptCollectionBidTx({
+						...txData,
+						kioskTx,
+					});
+				},
+			});
+		}
+
+		throw new Error(
+			`You cannot accept an Native Kiosk Bid with a NFT outside of a native kiosk. Nft Token Id: ${txData?.nftTokenId}`,
+		);
+	}
+
+	if (!isBluemoveKioskBid(txData?.bidNonce)) {
+		if (txData?.sellerKiosk) {
+			return kioskTxWrapper({
+				txBlock: txData?.txBlock,
+				kioskOwner: txData?.itemOwner,
+				kiosk: txData?.sellerKiosk,
+				async tx(kioskTx) {
+					const item = kioskTx.take({
+						itemId: txData?.nftTokenId,
+						itemType: txData?.nftType,
+					});
+
+					addBluemoveAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: item });
+				},
+			});
+		}
+
+		addBluemoveAcceptCollectionBidTx(txData);
+	}
+}
+
+export function addTocenAcceptCollectionBidTxHandler(txData: AcceptCollectionBidTx) {
+	addTocenAcceptCollectionBidTx(txData);
+}

package/src/methods/acceptNftBids/acceptNftBids.ts

@@ -0,0 +1,100 @@
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchBidsById } from '../../graphql/queries/fetchBidsById';
+import { getNftTypeFromNft } from '../../helpers/getNftTypeFromNft';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import {
+	addBluemoveAcceptNftBidTx,
+	addOriginByteAcceptNftBidTx,
+	addTradePortAcceptNftBidTxHandler,
+} from './addAcceptNftBidTxs';
+
+export type AcceptNftBidTx = {
+	txBlock: TransactionBlock;
+	sharedObjects: any;
+	kioskTx?: any;
+	bidNonce: string;
+	nftType: string;
+	nftTokenId: string;
+	itemOwner: string;
+	listingPrice: number;
+	bidAmount: number;
+	sellerKiosk: string;
+	isListedOnBluemove: boolean;
+	bidMarketName: string;
+	royaltyRulePackageId?: string;
+};
+
+export type AcceptNftBid = {
+	bidId: string;
+};
+
+export type AcceptNftBids = {
+	bidIds: string[];
+};
+
+const ERROR_UNLIST_FIRST = 'Item must be unlisted first before you can accept a solo bid on it';
+
+export const acceptNftBids = async ({ bidIds }: AcceptNftBids): Promise<TransactionBlock> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchBidsById,
+		variables: { bidIds },
+	});
+
+	if (res?.bids?.length === 0) {
+		throw new Error('No bids found');
+	}
+
+	const txBlock = new TransactionBlock();
+
+	for (const bid of res.bids) {
+		if (bid?.status !== 'active') {
+			throw new Error('Bid not active');
+		}
+
+		if (bid?.type !== 'solo') {
+			throw new Error('Bid is not an individual item bid. Use acceptCollectionBid() instead.');
+		}
+
+		const sharedObjects = await getSharedObjects(
+			bid?.nft?.properties?.nft_type || bid?.nft?.contract?.properties?.nft_type,
+		);
+
+		const txData: AcceptNftBidTx = {
+			txBlock,
+			sharedObjects,
+			bidNonce: bid?.nonce,
+			nftType: getNftTypeFromNft(bid?.nft),
+			listingPrice: bid?.nft?.listings?.[0]?.price,
+			nftTokenId: bid?.nft?.token_id,
+			itemOwner: bid?.nft?.owner,
+			bidAmount: bid?.price,
+			sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
+			isListedOnBluemove: bid?.nft?.listings?.[0]?.market_name === 'bluemove',
+			bidMarketName: bid?.market_contract?.name,
+		};
+
+		switch (txData.bidMarketName) {
+			case 'tradeport':
+				if (txData?.listingPrice && txData?.listingPrice > 0) {
+					throw new Error(ERROR_UNLIST_FIRST);
+				}
+
+				await addTradePortAcceptNftBidTxHandler(txData);
+				break;
+			case 'clutchy':
+			case 'hyperspace':
+			case 'somis':
+				await addOriginByteAcceptNftBidTx(txData);
+				break;
+			case 'bluemove':
+				addBluemoveAcceptNftBidTx(txData);
+				break;
+			default:
+				throw new Error('Marketplace not supported');
+		}
+	}
+
+	return new TransactionBlock(txBlock);
+};

package/src/methods/acceptNftBids/addAcceptNftBidTxs.ts

@@ -0,0 +1,214 @@
+import { type TransactionObjectArgument } from '@mysten/sui.js/transactions';
+import {
+	BLUEMOVE_CREATOR_CONFIG_OBJECT,
+	BLUEMOVE_MARKET_CONFIG_OBJECT,
+	BLUEMOVE_OFFER_DATA_OBJECT,
+	BLUEMOVE_ROYALTY_COLLECTION_OBJECT,
+	TRADEPORT_BIDDING_STORE,
+	TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK,
+	TRADEPORT_KIOSK_BIDDING_STORE,
+} from '../../constants';
+import { getRulePackageId } from '../../helpers/kiosk/getRulePackageId';
+import { isTradePortKioskBid } from '../../helpers/kiosk/isTradePortKioskBid';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+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 { isOriginByteTx } from '../../helpers/originByte/isOriginByteTx';
+import { getObjectType } from '../../helpers/rpc/getObjectType';
+import { type AcceptNftBidTx } from './acceptNftBids';
+
+export function addTradeportAcceptNftBidTx({
+	txBlock,
+	sharedObjects,
+	bidNonce,
+	nftTokenId,
+	nftType,
+}: AcceptNftBidTx) {
+	const { collection, royaltyStrategy } = sharedObjects;
+
+	if (collection && royaltyStrategy) {
+		txBlock.moveCall({
+			target:
+				'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::ob_accept_bid',
+			arguments: [
+				txBlock.object(TRADEPORT_BIDDING_STORE),
+				txBlock.pure(bidNonce),
+				txBlock.pure(nftTokenId),
+				txBlock.object(collection),
+				txBlock.object(royaltyStrategy),
+			],
+			typeArguments: [nftType],
+		});
+	} else {
+		txBlock.moveCall({
+			target:
+				'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::accept_bid',
+			arguments: [
+				txBlock.object(TRADEPORT_BIDDING_STORE),
+				txBlock.pure(bidNonce),
+				txBlock.pure(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+	}
+}
+
+export async function addTradeportKioskAcceptNftBidTx({
+	txBlock,
+	sharedObjects,
+	kioskTx,
+	bidNonce,
+	nftTokenId,
+	nftType,
+	royaltyRulePackageId,
+}: AcceptNftBidTx) {
+	const { transferPolicy } = sharedObjects;
+
+	const [feeCoin, transferRequest] = txBlock.moveCall({
+		target:
+			'0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_biddings::accept_bid',
+		arguments: [
+			txBlock.object(TRADEPORT_KIOSK_BIDDING_STORE),
+			txBlock.pure(bidNonce),
+			txBlock.object(TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK),
+			txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+			txBlock.pure(nftTokenId),
+			txBlock.object(transferPolicy),
+		],
+		typeArguments: [nftType],
+	});
+
+	txBlock.moveCall({
+		target: `${royaltyRulePackageId}::royalty_rule::pay`,
+		typeArguments: [nftType],
+		arguments: [txBlock.object(transferPolicy), transferRequest, feeCoin],
+	});
+
+	await resolveTransferPolicies({
+		txBlock,
+		kioskTx,
+		nftType,
+		price: '0',
+		transferRequest,
+		kioskToLockRuleProve: TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK,
+		shouldSkipKioskLocking: true,
+		shouldSkipResolvingRoyaltyRule: true,
+	});
+}
+
+export async function addOriginByteAcceptNftBidTx({
+	txBlock,
+	sharedObjects,
+	sellerKiosk,
+	bidNonce,
+	nftTokenId,
+	nftType,
+}: AcceptNftBidTx) {
+	const receiverKiosk = await getOBBidderKiosk(bidNonce);
+
+	let transferRequest: TransactionObjectArgument;
+	if (sellerKiosk) {
+		transferRequest = txBlock.moveCall({
+			target:
+				'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::sell_nft_from_kiosk',
+			arguments: [
+				txBlock.object(bidNonce),
+				txBlock.object(sellerKiosk),
+				txBlock.object(receiverKiosk),
+				txBlock.pure(nftTokenId),
+			],
+			typeArguments: [nftType, '0x2::sui::SUI'],
+		});
+	} else {
+		transferRequest = txBlock.moveCall({
+			target:
+				'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::sell_nft',
+			arguments: [
+				txBlock.object(bidNonce),
+				txBlock.object(receiverKiosk),
+				txBlock.pure(nftTokenId),
+			],
+			typeArguments: [nftType, '0x2::sui::SUI'],
+		});
+	}
+
+	confirmOBTranfer({ txBlock, sharedObjects, transferRequest, nftType });
+}
+
+export function addBluemoveAcceptNftBidTx({
+	txBlock,
+	nftTokenId,
+	nftType,
+	bidNonce,
+	isListedOnBluemove,
+}: AcceptNftBidTx) {
+	if (isListedOnBluemove) {
+		txBlock.moveCall({
+			target:
+				'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist',
+			arguments: [txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT), txBlock.pure(nftTokenId)],
+			typeArguments: [nftType, nftType],
+		});
+	}
+
+	txBlock.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_item::accept_offer_nft',
+		arguments: [
+			txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+			txBlock.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+			txBlock.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+			txBlock.object(BLUEMOVE_OFFER_DATA_OBJECT),
+			txBlock.pure(bidNonce),
+			isListedOnBluemove
+				? {
+						kind: 'Result',
+						index: 0,
+					}
+				: txBlock.pure(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addTradePortAcceptNftBidTxHandler(txData: AcceptNftBidTx) {
+	const bidType = await getObjectType(txData?.bidNonce);
+
+	if (isOriginByteBid(bidType)) {
+		if (isOriginByteTx(txData?.sharedObjects)) {
+			await addOriginByteAcceptNftBidTx(txData);
+			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 royaltyRulePackageId = await getRulePackageId(txData.nftType, 'royalty_rule');
+			return kioskTxWrapper({
+				txBlock: txData?.txBlock,
+				kioskOwner: txData?.itemOwner,
+				kiosk: txData?.sellerKiosk,
+				async tx(kioskTx) {
+					await addTradeportKioskAcceptNftBidTx({
+						...txData,
+						kioskTx,
+						royaltyRulePackageId,
+					});
+				},
+			});
+		}
+
+		throw new Error(
+			`You cannot accept an Native Kiosk Bid with a NFT outside of a native kiosk. Nft Token Id: ${txData?.nftTokenId}`,
+		);
+	}
+
+	addTradeportAcceptNftBidTx(txData);
+}