@tradeport/sui-trading-sdk 0.5.3 → 0.5.4

package/src/methods/acceptCollectionBid/addAcceptCollectionBIdTxs.ts

@@ -0,0 +1,398 @@
+import { type TransactionObjectInput } from '@mysten/sui/transactions';
+import { normalizeSuiObjectId } from '@mysten/sui/utils';
+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 { getRoyaltyRuleModule } from '../../helpers/getRoyaltyRuleModule';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { hasPersonalKioskRule } from '../../helpers/hasPersonalKioskRule';
+import { hasNativeKioskTransferPolicyRules } from '../../helpers/hasTransferPolicyRules';
+import { isSingleBid } from '../../helpers/isSIngleBid';
+import { assertNftInSharedKiosk } from '../../helpers/kiosk/assertNftInSharedKiosk';
+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 { takeAndBorrowNftFromKiosk } from '../../helpers/kiosk/takeAndBorrowNftFromKiosk';
+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 { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { shareOriginByteKiosk } from '../../helpers/originByte/shareOriginByteKiosk';
+import { getObjectType } from '../../helpers/rpc/getObjectType';
+import {
+	addSingleBidAcceptNftBidTx,
+	addTradeportKioskAcceptNftBidTx,
+} from '../acceptNftBids/addAcceptNftBidTxs';
+import { addOriginByteUnlistTx } from '../unlistListings/addUnlistListingTxs';
+import { type AcceptCollectionBidTx } from './acceptCollectionBid';
+
+export function addTradeportAcceptCollectionBidTx({
+	tx,
+	sharedObjects,
+	nftTokenId,
+	nftType,
+	itemTakenOutOfNativeKiosk,
+	bidNonce,
+}: AcceptCollectionBidTx) {
+	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),
+				itemTakenOutOfNativeKiosk ? tx.object(itemTakenOutOfNativeKiosk) : 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),
+				itemTakenOutOfNativeKiosk ? tx.object(itemTakenOutOfNativeKiosk) : tx.object(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+	}
+}
+
+export const addTradeportKioskAcceptCollectionBidTx = async (txData: AcceptCollectionBidTx) => {
+	await addTradeportKioskAcceptNftBidTx(txData);
+};
+
+export async function addOriginByteAcceptCollectionBidTx(txData: AcceptCollectionBidTx) {
+	const {
+		tx,
+		sharedObjects,
+		sellerKiosk,
+		itemOwner,
+		nftTokenId,
+		nftType,
+		bidAmount,
+		bidNonce,
+		listingPrice,
+	} = txData;
+
+	await assertNftInSharedKiosk({
+		kioskId: sellerKiosk,
+		walletAddress: itemOwner,
+	});
+
+	if (listingPrice && listingPrice > 0) {
+		addOriginByteUnlistTx({
+			...txData,
+			sharedObjects,
+			price: txData?.listingPrice,
+		});
+	}
+
+	const { kiosk, isNewKiosk } = await getOrCreateOBKiosk({
+		tx,
+		address: itemOwner,
+		kioskToUseIfExists: sellerKiosk,
+	});
+
+	if (isNewKiosk) {
+		depositItemIntoOBKiosk({
+			tx,
+			kiosk,
+			nftTokenId,
+			nftType,
+		});
+	}
+
+	const { orderbook } = sharedObjects;
+
+	const [tradeInfo] = tx.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::market_sell',
+		arguments: [
+			tx.object(orderbook),
+			tx.object(kiosk),
+			tx.pure.u64(bidAmount),
+			tx.object(nftTokenId),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	const [id] = tx.moveCall({
+		target:
+			'0xa0bab69d913e5a0ce8b448235a08bcf4c42da45c50622743dc9cab2dc0dff30f::orderbook::trade_id',
+		arguments: [tx.object(tradeInfo)],
+		typeArguments: [],
+	});
+
+	const transferRequest = tx.moveCall({
+		target:
+			'0xa0bab69d913e5a0ce8b448235a08bcf4c42da45c50622743dc9cab2dc0dff30f::orderbook::finish_trade',
+		arguments: [tx.object(orderbook), tx.object(id), tx.object(kiosk), tx.object(bidNonce)],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	confirmOBTranfer({ tx, sharedObjects, transferRequest, nftType });
+
+	if (isNewKiosk) {
+		shareOriginByteKiosk({ tx, kiosk });
+	}
+}
+
+export function addBluemoveAcceptCollectionBidTx({
+	tx,
+	nftTokenId,
+	nftType,
+	bidNonce,
+	listingPrice,
+	itemTakenOutOfNativeKiosk,
+}: AcceptCollectionBidTx) {
+	let unlistedItem: TransactionObjectInput;
+	if (listingPrice && listingPrice > 0) {
+		unlistedItem = 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_collection::accept_offer_collection',
+		arguments: [
+			tx.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+			tx.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+			tx.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+			tx.object(BLUEMOVE_OFFER_COLLECTION_DATA_OBJECT),
+			tx.pure.u64(bidNonce),
+			itemTakenOutOfNativeKiosk
+				? tx.object(itemTakenOutOfNativeKiosk)
+				: unlistedItem
+					? tx.object(unlistedItem)
+					: tx.object(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addBluemoveKioskAcceptCollectionBidTx({
+	tx,
+	kioskTx,
+	nftTokenId,
+	nftType,
+	bidNonce,
+}: AcceptCollectionBidTx) {
+	tx.moveCall({
+		target:
+			'0xcc97b74ed95c8e8a3ed88050a898727dee37896da579fc400d482b64db6149ff::kiosk_offer_collection_v2::accept_offer_collection_v2',
+		arguments: [
+			tx.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
+			tx.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_DATA_OBJECT),
+			tx.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_BIDDER_BAG),
+			tx.pure.u64(bidNonce),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export function addTocenAcceptCollectionBidTx({
+	tx,
+	nftTokenId,
+	nftType,
+	bidAmount,
+	bidder,
+}: AcceptCollectionBidTx) {
+	tx.moveCall({
+		target:
+			'0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::accept_offer_list',
+		arguments: [
+			tx.object(TOCEN_MARKETPLACE_OBJECT),
+			tx.pure.address(nftTokenId),
+			tx.pure.address(bidder),
+			tx.pure.u64(bidAmount),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addTradePortAcceptCollectionBidTxHandler(txData: AcceptCollectionBidTx) {
+	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 addOriginByteAcceptCollectionBidTx({ ...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 nft has no transfer policy rules but is inside a kiosk, take it out of the kiosk
+	if (!hasNativeKioskTransferPolicyRules(txData?.transferPolicies) && txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: txData?.kioskClient,
+			kioskOwner: txData?.seller,
+			kiosk: txData?.sellerKiosk,
+			shouldAssertNftInSharedKiosk: true,
+			sharedKioskState: txData?.sharedKioskState,
+			async runCommands(kioskTx) {
+				const borrowedItem = await takeAndBorrowNftFromKiosk({
+					tx: txData?.tx,
+					transferPolicies: txData?.transferPolicies,
+					kioskTx,
+					kioskClient: txData?.kioskClient,
+					nftTokenId: txData?.nftTokenId,
+					nftType: txData?.nftType,
+					suiClient: txData?.suiClient,
+					kioskOwner: txData?.seller,
+				});
+
+				addTradeportAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: borrowedItem });
+			},
+		});
+	}
+
+	if (isTradePortKioskBid(bidType)) {
+		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 addTradeportKioskAcceptCollectionBidTx({
+					...txData,
+					kioskTx,
+					royaltyRulePackageId,
+					royaltyRuleModule,
+				});
+			},
+		});
+	}
+
+	const sharedObjects = await getSharedObjects(txData?.nftType);
+	addTradeportAcceptCollectionBidTx({ ...txData, sharedObjects });
+}
+
+export async function addBluemoveAcceptCollectionBidTxHandler(txData: AcceptCollectionBidTx) {
+	const bidType = await getObjectType({ suiClient: txData?.suiClient, objectId: txData?.bidNonce });
+
+	if (isOriginByteBid(bidType)) {
+		if (isOriginByteCollection(txData?.transferPolicies)) {
+			const sharedObjects = await getSharedObjects(txData?.nftType);
+			await addOriginByteAcceptCollectionBidTx({ ...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 (isBluemoveKioskBid(txData?.bidNonce)) {
+		if (txData?.sellerKiosk) {
+			return kioskTxWrapper({
+				tx: txData?.tx,
+				kioskClient: txData?.kioskClient,
+				kioskOwner: txData?.itemOwner,
+				kiosk: txData?.sellerKiosk,
+				shouldAssertNftInSharedKiosk: true,
+				sharedKioskState: txData?.sharedKioskState,
+				async runCommands(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({
+				tx: txData?.tx,
+				kioskClient: txData?.kioskClient,
+				kioskOwner: txData?.itemOwner,
+				kiosk: txData?.sellerKiosk,
+				shouldAssertNftInSharedKiosk: true,
+				sharedKioskState: txData?.sharedKioskState,
+				async runCommands(kioskTx) {
+					const borrowedItem = await takeAndBorrowNftFromKiosk({
+						tx: txData?.tx,
+						transferPolicies: txData?.transferPolicies,
+						kioskTx,
+						kioskClient: txData?.kioskClient,
+						nftTokenId: txData?.nftTokenId,
+						nftType: txData?.nftType,
+						suiClient: txData?.suiClient,
+						kioskOwner: txData?.itemOwner,
+					});
+
+					addBluemoveAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: borrowedItem });
+				},
+			});
+		}
+
+		addBluemoveAcceptCollectionBidTx(txData);
+	}
+}
+
+export function addTocenAcceptCollectionBidTxHandler(txData: AcceptCollectionBidTx) {
+	addTocenAcceptCollectionBidTx(txData);
+}

package/src/methods/acceptNftBids/acceptNftBids.ts

@@ -0,0 +1,174 @@
+import { type KioskClient, type KioskTransaction } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { Transaction } from '@mysten/sui/transactions';
+import { type RequestContext } from '../../SuiTradingClient';
+import {
+	DELOREAN_TOKEN_IDS_TO_DISABLE,
+	DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE,
+} from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchBidsById } from '../../graphql/queries/fetchBidsById';
+import { getNftType } from '../../helpers/getNftType';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import {
+	addBluemoveAcceptNftBidTx,
+	addOriginByteAcceptNftBidTx,
+	addTradePortAcceptNftBidTxHandler,
+} from './addAcceptNftBidTxs';
+
+export type AcceptNftBidTx = {
+	tx: Transaction;
+	sharedObjects?: any;
+	transferPolicies: any;
+	suiClient: SuiGrpcClient;
+	kioskClient: KioskClient;
+	kioskTx?: any;
+	sharedKioskState?: SharedKioskState;
+	seller?: string;
+	bidNonce: string;
+	nftType: string;
+	nftTokenId: string;
+	itemOwner: string;
+	listingPrice: number;
+	bidAmount: number;
+	sellerKiosk: string;
+	isListedOnBluemove: boolean;
+	bidMarketName: string;
+	royaltyRulePackageId?: string;
+	royaltyRuleModule?: string;
+	shouldSplitRoyaltyFromUserGasCoins?: boolean;
+	beforeResolveKioskTransferRequest?: (coin: any, transferRequest: any) => void | Promise<void>;
+	multiBidId?: string;
+};
+
+export type AcceptNftBids = {
+	bidIds: string[];
+	walletAddress: string;
+	tx?: Transaction;
+	kioskTx?: KioskTransaction;
+	beforeResolveKioskTransferRequest?: (coin: any, transferRequest: any) => void | Promise<void>;
+};
+
+const ERROR_UNLIST_FIRST = 'Item must be unlisted first before you can accept a solo bid on it';
+
+export const acceptNftBids = async (
+	{
+		bidIds,
+		walletAddress,
+		tx: existingTx,
+		kioskTx,
+		beforeResolveKioskTransferRequest,
+	}: AcceptNftBids,
+	context: RequestContext,
+): Promise<Transaction> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchBidsById,
+		variables: { bidIds },
+	});
+
+	if (res?.bids?.length === 0) {
+		throw new Error('No bids found');
+	}
+
+	const bidsForTracking = [];
+	const tx = existingTx ?? new Transaction();
+
+	const sharedKioskState: SharedKioskState = {
+		kioskTx: kioskTx ?? undefined,
+	};
+
+	for (const bid of res.bids) {
+		if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(bid?.nft?.token_id)) {
+			throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
+		}
+
+		if (addLeadingZerosAfter0x(bid?.bidder) === addLeadingZerosAfter0x(walletAddress)) {
+			throw new Error('Wallet cannot accept its own bid');
+		}
+
+		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 nftType = getNftType({
+			collectionId: bid?.collection?.id,
+			collectionChainState: bid?.collection?.chain_state,
+			nft: bid?.nft,
+		});
+
+		const transferPolicies = bid?.collection?.chain_state?.transfer_policies;
+
+		const txData: AcceptNftBidTx = {
+			tx,
+			kioskTx,
+			sharedKioskState,
+			transferPolicies,
+			suiClient: context.suiClient,
+			kioskClient: context.kioskClient,
+			bidNonce: bid?.nonce,
+			nftType,
+			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,
+			seller: bid?.nft?.owner,
+			isListedOnBluemove: bid?.nft?.listings?.[0]?.market_name === 'bluemove',
+			bidMarketName: bid?.market_contract?.name,
+			multiBidId: bid?.multi_bid_id,
+			beforeResolveKioskTransferRequest,
+		};
+
+		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': {
+				const sharedObjects = await getSharedObjects(txData?.nftType);
+				await addOriginByteAcceptNftBidTx({ ...txData, sharedObjects });
+				break;
+			}
+
+			case 'bluemove':
+				addBluemoveAcceptNftBidTx(txData);
+				break;
+			default:
+				throw new Error('Marketplace not supported');
+		}
+
+		bidsForTracking.push({
+			nftType,
+			collectionId: bid?.nft?.collection_id,
+			bidAmount: bid?.price,
+			bidMarketName: bid?.market_contract?.name,
+			itemOwner: bid?.nft?.owner,
+			bidder: bid?.bidder,
+		});
+	}
+
+	sharedKioskState?.kioskTx?.finalize();
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && bidsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'ACCEPT_NFT_BIDS',
+	// 		items: bidsForTracking,
+	// 	});
+	// }
+
+	return Transaction.from(tx);
+};