@tradeport/sui-trading-sdk 0.0.0

package/src/methods/buyListings/addBuyListingTxs.ts

@@ -0,0 +1,503 @@
+import {
+	BLUEMOVE_CREATOR_CONFIG_OBJECT,
+	BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT,
+	BLUEMOVE_MARKET_CONFIG_OBJECT,
+	BLUEMOVE_ROYALTY_COLLECTION_OBJECT,
+	HYPERSPACE_MP_TRANSFER_POLICY_TYPE,
+	HYPERSPACE_TRANSFER_POLICY_TYPE,
+	KEEPSAKE_MARKETPLACE_KIOSK,
+	KEEPSAKE_MARKETPLACE_OBJECT,
+	SOUFFL3_EXTENSION_OBJECT,
+	SOUFFL3_GENERIC_BUY_METHOD_COLLECTIONS,
+	SOUFFL3_MARKETPLACE_OBJECT,
+	SOUFFL3_VERSION_OBJECT,
+	TOCEN_MARKETPLACE_OBJECT,
+	TRADEPORT_KIOSK_LISTING_STORE,
+	TRADEPORT_LISTING_STORE,
+} from '../../constants';
+import { getCommissionByNftContractId } from '../../graphql/queries/getCommissionByListingId';
+import { destroyZeroCoin } from '../../helpers/destroyZeroCoin';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { resolveTransferPolicies } from '../../helpers/kiosk/resolveTransferPolicies';
+import { confirmOBTranfer } from '../../helpers/originByte/confirmOBTranfer';
+import { getOrCreateOBKiosk } from '../../helpers/originByte/getOrCreateOBKiosk';
+import { isOriginByteTx } from '../../helpers/originByte/isOriginByteTx';
+import { shareOriginByteKiosk } from '../../helpers/originByte/shareOriginByteKiosk';
+import { splitCoins } from '../../helpers/splitCoins';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { type BuyTx, type TocenBuyTx } from './buyListings';
+
+export function addTradePortBuyTx({ txBlock, nftType, listingNonce, price, sharedObjects }: BuyTx) {
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const { collection, royaltyStrategy } = sharedObjects;
+	if (collection && royaltyStrategy) {
+		txBlock.moveCall({
+			target:
+				'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::ob_buy',
+			arguments: [
+				txBlock.object(TRADEPORT_LISTING_STORE),
+				txBlock.pure(listingNonce),
+				txBlock.object(coin),
+				txBlock.object(collection),
+				txBlock.object(royaltyStrategy),
+			],
+			typeArguments: [nftType],
+		});
+	} else {
+		txBlock.moveCall({
+			target: '0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::buy',
+			arguments: [
+				txBlock.object(TRADEPORT_LISTING_STORE),
+				txBlock.pure(listingNonce),
+				txBlock.object(coin),
+			],
+			typeArguments: [nftType],
+		});
+	}
+
+	destroyZeroCoin({ txBlock, coin });
+}
+
+export const addTradeportKioskBuyTx = async ({
+	txBlock,
+	kioskTx,
+	nftType,
+	nftTokenId,
+	price,
+	sellerKiosk,
+}: BuyTx) => {
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const [kioskItem, transferRequest, kioskPrice] = txBlock.moveCall({
+		target:
+			'0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_listings::buy',
+		arguments: [
+			txBlock.object(TRADEPORT_KIOSK_LISTING_STORE),
+			txBlock.object(sellerKiosk),
+			txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			txBlock.pure(nftTokenId),
+			txBlock.object(coin),
+		],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		txBlock,
+		kioskTx,
+		nftType,
+		priceObjectArgument: kioskPrice,
+		kioskItem,
+		transferRequest,
+	});
+
+	destroyZeroCoin({ txBlock, coin });
+};
+
+export async function addOriginByteBuyTx({
+	txBlock,
+	sharedObjects,
+	buyer,
+	nftTokenId,
+	nftType,
+	listingNonce,
+	price,
+}: BuyTx) {
+	const { orderbook } = sharedObjects;
+	const { kiosk: buyerKiosk, isNewKiosk: isNewBuyerKiosk } = await getOrCreateOBKiosk({
+		txBlock,
+		address: buyer,
+	});
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const transferRequest = txBlock.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::buy_nft',
+		arguments: [
+			txBlock.object(orderbook),
+			txBlock.object(listingNonce),
+			txBlock.object(buyerKiosk),
+			txBlock.pure(nftTokenId),
+			txBlock.pure(price),
+			txBlock.object(coin),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	confirmOBTranfer({ txBlock, sharedObjects, transferRequest, nftType });
+
+	destroyZeroCoin({ txBlock, coin });
+
+	if (isNewBuyerKiosk) {
+		await shareOriginByteKiosk({ txBlock, kiosk: buyerKiosk });
+	}
+}
+
+export const addHyperspaceKioskBuyTx = async ({
+	txBlock,
+	kioskTx,
+	nftType,
+	nftTokenId,
+	price,
+	sellerKiosk,
+}: BuyTx) => {
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	const [kioskItem, transferRequest, hyperspaceTransferRequest, hyperspaceMpTransferRequest] =
+		txBlock.moveCall({
+			target:
+				'0x6ea97b03c441edd54ae89224bf9560e583ee66c37e6c246f5db35258e580ba94::hyperspace::purchase',
+			arguments: [txBlock.object(sellerKiosk), txBlock.pure(nftTokenId), txBlock.object(coin)],
+			typeArguments: [nftType, HYPERSPACE_MP_TRANSFER_POLICY_TYPE],
+		});
+
+	const customTransferPolicies = [
+		{
+			type: HYPERSPACE_TRANSFER_POLICY_TYPE,
+			transferRequest: hyperspaceTransferRequest,
+		},
+		{
+			type: HYPERSPACE_MP_TRANSFER_POLICY_TYPE,
+			transferRequest: hyperspaceMpTransferRequest,
+		},
+	];
+
+	await resolveTransferPolicies({
+		txBlock,
+		kioskTx,
+		nftType,
+		price: price?.toString(),
+		kioskItem,
+		transferRequest,
+		customTransferPolicies,
+	});
+};
+
+export function addBluemoveBuyTx({ txBlock, nftTokenId, nftType, price }: BuyTx) {
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	txBlock.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::buy_and_take',
+		arguments: [
+			txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+			txBlock.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+			txBlock.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+			txBlock.pure(nftTokenId),
+			txBlock.object(coin),
+			txBlock.pure(price),
+		],
+		typeArguments: [nftType, nftType],
+	});
+}
+
+export async function addBluemoveKioskBuyTx({
+	txBlock,
+	kioskTx,
+	sharedObjects,
+	nftTokenId,
+	nftType,
+	price,
+	sellerKiosk,
+}: BuyTx) {
+	const { transferPolicy } = sharedObjects;
+
+	const [coin1, coin2] = splitCoins({
+		txBlock,
+		amounts: [txBlock.pure(price), txBlock.pure(price * 0.025)],
+	});
+
+	if (!coin1 || !coin2) throw new Error('Coin could not be split');
+
+	txBlock.mergeCoins(txBlock.object(coin1), [txBlock.object(coin2)]);
+
+	const [kioskItem, transferRequest] = txBlock.moveCall({
+		target:
+			'0xcc97b74ed95c8e8a3ed88050a898727dee37896da579fc400d482b64db6149ff::kiosk_trade::kiosk_buy_v2',
+		arguments: [
+			txBlock.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
+			txBlock.object(sellerKiosk),
+			txBlock.object(transferPolicy),
+			txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+			txBlock.pure(nftTokenId),
+			txBlock.pure(price),
+			txBlock.object(coin1),
+		],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		txBlock,
+		kioskTx,
+		nftType,
+		price: price?.toString(),
+		kioskItem,
+		transferRequest,
+	});
+}
+
+export function addSouffl3BuyTx({
+	txBlock,
+	sharedObjects,
+	nftType,
+	price,
+	listingNonce,
+	collectionId,
+	buyer,
+}: BuyTx) {
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+
+	const { transferPolicy } = sharedObjects;
+
+	if (transferPolicy && !SOUFFL3_GENERIC_BUY_METHOD_COLLECTIONS?.includes(collectionId)) {
+		const [coinToDestroy] = txBlock.moveCall({
+			target:
+				'0x30d90b5b67be77e6e06f02dae9f0f2fcdad16e38854316ae8a7b4f5b4971f5e0::Market::buy_with_sui_with_ext',
+			arguments: [
+				txBlock.object(SOUFFL3_VERSION_OBJECT),
+				txBlock.object(SOUFFL3_EXTENSION_OBJECT),
+				txBlock.object(transferPolicy),
+				txBlock.object(listingNonce),
+				txBlock.pure(price),
+				txBlock.object(SOUFFL3_MARKETPLACE_OBJECT),
+				txBlock.object(coin),
+			],
+			typeArguments: [nftType],
+		});
+
+		destroyZeroCoin({ txBlock, coin: coinToDestroy });
+	} else {
+		const [coinToDestroy] = txBlock.moveCall({
+			target:
+				'0x30d90b5b67be77e6e06f02dae9f0f2fcdad16e38854316ae8a7b4f5b4971f5e0::Market::buy_generic_with_ext',
+			arguments: [
+				txBlock.object(SOUFFL3_VERSION_OBJECT),
+				txBlock.object(SOUFFL3_EXTENSION_OBJECT),
+				txBlock.object(listingNonce),
+				txBlock.pure(price),
+				txBlock.object(SOUFFL3_MARKETPLACE_OBJECT),
+				txBlock.object(coin),
+			],
+			typeArguments: [nftType, '0x2::sui::SUI'],
+		});
+
+		destroyZeroCoin({ txBlock, coin: coinToDestroy });
+	}
+}
+
+export function addSomisBuyTx({ txBlock, sharedObjects, nftTokenId, nftType, price }: BuyTx) {
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	txBlock.moveCall({
+		target:
+			'0xf0b0beb956e26bde50dbd6ac393026c4525aee3b194a9478f09748f7211b5a02::marketplace::buy_nft',
+		arguments: [
+			txBlock.object(sharedObjects?.marketplace),
+			txBlock.pure(nftTokenId),
+			txBlock.object(coin),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+}
+
+export function addKeepsakeBuyTx({
+	txBlock,
+	sharedObjects,
+	buyer,
+	nftTokenId,
+	nftType,
+	price,
+	royalty,
+}: BuyTx) {
+	const { keepsakeRoyaltyStrategy, transferPolicy } = sharedObjects;
+
+	const [coin1, coin2] = splitCoins({
+		txBlock,
+		amounts: [
+			txBlock.pure(price),
+			txBlock.pure((price * Number(royalty)) / 100 + price * Number(royalty) * 0.00005),
+		],
+	});
+
+	if (!coin1 || !coin2) throw new Error('Coin could not be split');
+
+	const [balance] = txBlock.moveCall({
+		target: '0x2::coin::into_balance',
+		arguments: [txBlock.object(coin2)],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+
+	if (!balance) throw new Error('Coin into_balance failed');
+
+	const [transferRequest] = txBlock.moveCall({
+		target:
+			'0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::keepsake_marketplace::buy',
+		arguments: [
+			txBlock.object(KEEPSAKE_MARKETPLACE_OBJECT),
+			txBlock.object(KEEPSAKE_MARKETPLACE_KIOSK),
+			txBlock.pure(nftTokenId),
+			txBlock.object(coin1),
+		],
+		typeArguments: [nftType],
+	});
+
+	if (!transferRequest) throw new Error('Transfer request could not be created');
+
+	txBlock.moveCall({
+		target:
+			'0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::keepsake_royalties::confirm_transfer_with_balance',
+		arguments: [
+			txBlock.object(keepsakeRoyaltyStrategy),
+			txBlock.object(transferRequest),
+			txBlock.object(balance),
+		],
+		typeArguments: [nftType],
+	});
+
+	txBlock.moveCall({
+		target:
+			'0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::transfer_policy::confirm_request',
+		arguments: [txBlock.object(transferPolicy), txBlock.object(transferRequest)],
+		typeArguments: [nftType],
+	});
+
+	const [balanceToTransfer] = txBlock.moveCall({
+		target: '0x2::coin::from_balance',
+		arguments: [txBlock.object(balance)],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+
+	if (!balanceToTransfer) throw new Error('Coin from_balance failed');
+
+	txBlock.transferObjects(
+		[txBlock.object(balanceToTransfer)],
+		txBlock.pure(addLeadingZerosAfter0x(buyer)),
+	);
+}
+
+export const addTocenBuyTx = ({ txBlock, nftTokenIds, nftType, price }: TocenBuyTx) => {
+	const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+
+	if (!coin) throw new Error('Coin could not be split');
+
+	txBlock.moveCall({
+		target:
+			'0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::buy_cart',
+		arguments: [
+			txBlock.pure(TOCEN_MARKETPLACE_OBJECT),
+			txBlock.pure(nftTokenIds),
+			txBlock.object(coin),
+		],
+		typeArguments: [nftType],
+	});
+};
+
+export async function addTradePortBuyTxHandler(txData: BuyTx) {
+	if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+		await addOriginByteBuyTx(txData);
+		return;
+	}
+
+	if (txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			txBlock: txData?.txBlock,
+			kioskOwner: txData?.buyer,
+			kiosk: txData?.sellerKiosk,
+			shouldConvertToPersonalKiosk: true,
+			async tx(kioskTx) {
+				await addTradeportKioskBuyTx({
+					...txData,
+					kioskTx,
+				});
+			},
+		});
+	}
+
+	addTradePortBuyTx(txData);
+}
+
+export async function addHyperspaceBuyTxHandler(txData: BuyTx) {
+	if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+		await addOriginByteBuyTx(txData);
+		return;
+	}
+
+	return kioskTxWrapper({
+		txBlock: txData?.txBlock,
+		kioskOwner: txData?.buyer,
+		kiosk: txData?.sellerKiosk,
+		shouldConvertToPersonalKiosk: true,
+		async tx(kioskTx) {
+			await addHyperspaceKioskBuyTx({
+				...txData,
+				kioskTx,
+			});
+		},
+	});
+}
+
+export async function addBluemoveBuyTxHandler(txData: BuyTx) {
+	if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+		await addOriginByteBuyTx(txData);
+		return;
+	}
+
+	if (txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			txBlock: txData?.txBlock,
+			kioskOwner: txData?.buyer,
+			kiosk: txData?.sellerKiosk,
+			shouldConvertToPersonalKiosk: true,
+			async tx(kioskTx) {
+				await addBluemoveKioskBuyTx({
+					...txData,
+					kioskTx,
+				});
+			},
+		});
+	}
+
+	addBluemoveBuyTx(txData);
+}
+
+export async function addClutchyBuyTxHandler(txData: BuyTx) {
+	await addOriginByteBuyTx(txData);
+}
+
+export async function addSouffl3BuyTxHandler(txData: BuyTx) {
+	addSouffl3BuyTx(txData);
+}
+
+export async function addSomisBuyTxHandler(txData: BuyTx) {
+	if (txData?.sharedObjects?.marketplace) {
+		addSomisBuyTx(txData);
+		return;
+	}
+
+	return addOriginByteBuyTx(txData);
+}
+
+export async function addKeepsakeBuyTxHandler(txData: BuyTx) {
+	const commission = await getCommissionByNftContractId(txData?.nftContractId);
+
+	addKeepsakeBuyTx({
+		...txData,
+		royalty: commission?.royalty,
+	});
+}
+
+export function addTocenBuyTxHandler(txData: TocenBuyTx) {
+	addTocenBuyTx(txData);
+}

package/src/methods/buyListings/buyListings.ts

@@ -0,0 +1,143 @@
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchListingsById } from '../../graphql/queries/fetchListingsById';
+import { addThirdPartyTxFee } from '../../helpers/addThirdPartyTxFee';
+import { getNftTypeFromNft } from '../../helpers/getNftTypeFromNft';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import {
+	addBluemoveBuyTxHandler,
+	addClutchyBuyTxHandler,
+	addHyperspaceBuyTxHandler,
+	addKeepsakeBuyTxHandler,
+	addSomisBuyTxHandler,
+	addSouffl3BuyTxHandler,
+	addTocenBuyTxHandler,
+	addTradePortBuyTxHandler,
+} from './addBuyListingTxs';
+
+type BuyTxBase = {
+	txBlock: TransactionBlock;
+	sharedObjects: any;
+	kioskTx?: any;
+	buyer: string;
+	nftTokenId: string;
+	nftType: string;
+	listingId: string;
+	listingNonce: string;
+	price: number;
+	sellerKiosk: string;
+	collectionId: string;
+	nftContractId: string;
+	remainingAccountBalance?: number;
+	royalty?: number;
+};
+
+type NormalBuyTx = {
+	nftTokenIds?: never;
+} & BuyTxBase;
+
+export type TocenBuyTx = {
+	nftTokenIds: string[];
+} & BuyTxBase;
+
+export type BuyTx = NormalBuyTx | TocenBuyTx;
+
+export type BuyListing = {
+	listingId: string;
+	walletAddress: string;
+};
+
+export type BuyListings = {
+	listingIds: string[];
+	walletAddress: string;
+};
+
+export const buyListings = async ({
+	listingIds,
+	walletAddress,
+}: BuyListings): Promise<TransactionBlock> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchListingsById,
+		variables: { listingIds },
+	});
+
+	if (res?.listings?.length === 0) {
+		throw new Error('No listings found');
+	}
+
+	const txBlock = new TransactionBlock();
+	const tocenTokenIds: string[] = [];
+	let tocenNftType = '';
+	let tocenTotalPrice = 0;
+
+	for (const listing of res.listings) {
+		if (!listing?.listed) {
+			throw new Error(`Listing ${listing?.id} is not listed`);
+		}
+
+		const sharedObjects = await getSharedObjects(
+			listing?.nft?.properties?.nft_type || listing?.nft?.contract?.properties?.nft_type,
+		);
+
+		const buyTxData: BuyTx = {
+			txBlock,
+			sharedObjects,
+			buyer: walletAddress,
+			nftTokenId: listing.nft?.token_id,
+			nftType: getNftTypeFromNft(listing?.nft),
+			listingId: listing?.id,
+			listingNonce: listing?.nonce,
+			price: listing?.price,
+			sellerKiosk: listing.nft?.chain_state?.kiosk_id,
+			collectionId: listing?.nft?.collection_id,
+			nftContractId: listing?.nft?.contract_id,
+		};
+
+		switch (listing?.market_name) {
+			case 'tradeport':
+				await addTradePortBuyTxHandler(buyTxData);
+				break;
+			case 'hyperspace':
+				await addHyperspaceBuyTxHandler(buyTxData);
+				break;
+			case 'bluemove':
+				await addBluemoveBuyTxHandler(buyTxData);
+				break;
+			case 'clutchy':
+				await addClutchyBuyTxHandler(buyTxData);
+				break;
+			case 'souffl3':
+				await addSouffl3BuyTxHandler(buyTxData);
+				break;
+			case 'somis':
+				await addSomisBuyTxHandler(buyTxData);
+				break;
+			case 'keepsake':
+				await addKeepsakeBuyTxHandler(buyTxData);
+				break;
+			case 'tocen':
+				tocenTokenIds.push(buyTxData?.nftTokenId);
+				tocenNftType = buyTxData?.nftType;
+				tocenTotalPrice += Number(listing.price);
+				break;
+			default:
+				throw new Error('Marketplace not supported');
+		}
+
+		if (listing?.market_name !== 'tradeport') {
+			await addThirdPartyTxFee(txBlock, listing?.price);
+		}
+	}
+
+	if (tocenTokenIds?.length > 0) {
+		addTocenBuyTxHandler({
+			txBlock,
+			nftType: tocenNftType,
+			nftTokenIds: tocenTokenIds,
+			price: tocenTotalPrice,
+		} as TocenBuyTx);
+	}
+
+	return new TransactionBlock(txBlock);
+};