@tradeport/sui-trading-sdk 0.5.3 → 0.5.4

package/src/methods/claimNfts/claimNfts.ts

@@ -0,0 +1,270 @@
+import type { KioskClient } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { Transaction } from '@mysten/sui/transactions';
+import { type RequestContext } from '../../SuiTradingClient';
+import {
+	BLUEMOVE_CLAIMABLE_CONTRACT_KEYS,
+	DELOREAN_TOKEN_IDS_TO_DISABLE,
+	DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE,
+} from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchNftsById } from '../../graphql/queries/fetchNftsById';
+import { getNftType } from '../../helpers/getNftType';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+import {
+	addBluemoveClaimAcceptedBidNft,
+	addClaimAcceptedBidNftTx,
+	addClaimAcceptedBidNftWithPurchaseCapTx,
+	addClaimTradeHoldTx,
+	addClaimTransferredNftTx,
+	addClaimTransferredNftWithPurchaseCapTx,
+} from './addClaimNftsTxs';
+
+export type ClaimTradeHoldTx = {
+	tx: Transaction;
+	kioskClient: KioskClient;
+	sharedKioskState?: SharedKioskState;
+	sharedObjects?: any;
+	transferPolicies: any;
+	nftType: string;
+	claimableTradeId: string;
+	claimableSellerKiosk: string;
+	claimableBuyerKiosk: string;
+};
+
+export type ClaimTransferredNftTx = {
+	tx: Transaction;
+	suiClient?: SuiGrpcClient;
+	kioskTx?: any;
+	kioskClient: KioskClient;
+	sharedKioskState?: SharedKioskState;
+	sharedObjects?: any;
+	transferPolicies: any;
+	claimer: string;
+	nftTokenId: string;
+	nftType: string;
+	sellerKiosk: string;
+	seller: string;
+	preloadedTransferPolicyId?: string;
+};
+
+export type ClaimAcceptedBidNftTx = {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	kioskTx?: any;
+	kioskClient: KioskClient;
+	sharedKioskState?: SharedKioskState;
+	sharedObjects?: any;
+	transferPolicies: any;
+	claimer: string;
+	nftTokenId: string;
+	nftType: string;
+	sellerKiosk: string;
+	seller: string;
+};
+
+export type ClaimNfts = {
+	nftIds: string[];
+	walletAddress: string;
+	tx?: Transaction;
+};
+export const claimNfts = async (
+	{ nftIds, walletAddress, tx: existingTx }: ClaimNfts,
+	context: RequestContext,
+	useOldClaim?: boolean,
+): Promise<Transaction> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchNftsById,
+		variables: { nftIds },
+	});
+
+	if (res?.nfts?.length === 0) {
+		throw new Error('No nfts found');
+	}
+
+	const nftsForTracking = [];
+	const tx = existingTx ?? new Transaction();
+
+	const sharedKioskState: SharedKioskState = {
+		kioskTx: undefined,
+	};
+
+	for (const nft of res.nfts) {
+		if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(nft?.token_id)) {
+			throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
+		}
+
+		if (!nft) {
+			throw new Error('No nft found');
+		}
+
+		if (!nft?.chain_state?.claimable) {
+			throw new Error(`Nft ID: ${nft?.id} is not claimable`);
+		}
+
+		const nftType = getNftType({
+			collectionId: nft?.collection?.id,
+			collectionChainState: nft?.collection?.chain_state,
+			nft,
+		});
+
+		const transferPolicies = nft?.collection?.chain_state?.transfer_policies;
+
+		// claim trade hold nft
+		if (nft?.chain_state?.claimable_trade_id) {
+			const txData: ClaimTradeHoldTx = {
+				tx,
+				kioskClient: context.kioskClient,
+				transferPolicies,
+				nftType,
+				claimableTradeId: nft?.chain_state?.claimable_trade_id,
+				claimableSellerKiosk: nft?.chain_state?.claimable_seller_kiosk,
+				claimableBuyerKiosk: nft?.chain_state?.claimable_buyer_kiosk,
+				sharedKioskState,
+			};
+
+			const sharedObjects = await getSharedObjects(nftType);
+			addClaimTradeHoldTx({ ...txData, sharedObjects });
+			continue;
+		}
+
+		// claim accepted bid nft
+		if (
+			['accept-token-offer', 'accept-collection-offer']?.includes(
+				nft?.chain_state?.claimable_reason,
+			)
+		) {
+			const txData: ClaimAcceptedBidNftTx = {
+				tx,
+				suiClient: context.suiClient,
+				kioskClient: context.kioskClient,
+				sharedKioskState,
+				transferPolicies,
+				claimer: walletAddress,
+				nftType,
+				nftTokenId: nft?.token_id,
+				sellerKiosk: nft?.chain_state?.kiosk_id,
+				seller: nft?.owner,
+			};
+
+			if (BLUEMOVE_CLAIMABLE_CONTRACT_KEYS?.includes(nft?.chain_state?.claimable_contract_key)) {
+				await kioskTxWrapper({
+					tx,
+					kioskClient: context.kioskClient,
+					kioskOwner: txData?.claimer,
+					kiosk: txData?.sellerKiosk,
+					shouldConvertToPersonalKiosk: true,
+					shouldAllowNftUnsharedKiosk: true,
+					sharedKioskState,
+					async runCommands(kioskTx) {
+						await addBluemoveClaimAcceptedBidNft({
+							...txData,
+							suiClient: context.suiClient,
+							kioskTx,
+						});
+					},
+				});
+
+				continue;
+			}
+
+			if (useOldClaim) {
+				await kioskTxWrapper({
+					tx,
+					kioskClient: context.kioskClient,
+					kioskOwner: txData?.claimer,
+					kiosk: txData?.sellerKiosk,
+					shouldConvertToPersonalKiosk: true,
+					shouldAllowNftUnsharedKiosk: true,
+					sharedKioskState,
+					async runCommands(kioskTx) {
+						await addClaimAcceptedBidNftTx({ ...txData, kioskTx });
+					},
+				});
+			} else {
+				await kioskTxWrapper({
+					tx,
+					kioskClient: context.kioskClient,
+					kioskOwner: txData?.claimer,
+					kiosk: txData?.sellerKiosk,
+					shouldConvertToPersonalKiosk: true,
+					shouldAssertNftInSharedKiosk: true,
+					sharedKioskState,
+					async runCommands(kioskTx) {
+						await addClaimAcceptedBidNftWithPurchaseCapTx({ ...txData, kioskTx });
+					},
+				});
+			}
+
+			continue;
+		}
+
+		// claim transferred nft
+		if (nft?.chain_state?.claimable_reason === 'offer-transfer') {
+			const txData: ClaimTransferredNftTx = {
+				tx,
+				suiClient: context.suiClient,
+				kioskClient: context.kioskClient,
+				transferPolicies,
+				claimer: walletAddress,
+				nftType,
+				nftTokenId: nft?.token_id,
+				sellerKiosk: nft?.chain_state?.kiosk_id,
+				seller: nft?.owner,
+				sharedKioskState,
+			};
+
+			if (useOldClaim) {
+				await kioskTxWrapper({
+					tx,
+					kioskClient: context.kioskClient,
+					kioskOwner: txData?.claimer,
+					kiosk: txData?.sellerKiosk,
+					kioskStrategy: 'exclude',
+					shouldConvertToPersonalKiosk: true,
+					shouldAllowNftUnsharedKiosk: true,
+					sharedKioskState,
+					async runCommands(kioskTx) {
+						await addClaimTransferredNftTx({ ...txData, kioskTx });
+					},
+				});
+			} else {
+				await kioskTxWrapper({
+					tx,
+					kioskClient: context.kioskClient,
+					kioskOwner: txData?.claimer,
+					kiosk: txData?.sellerKiosk,
+					kioskStrategy: 'exclude',
+					shouldConvertToPersonalKiosk: true,
+					shouldAllowNftUnsharedKiosk: true,
+					sharedKioskState,
+					async runCommands(kioskTx) {
+						await addClaimTransferredNftWithPurchaseCapTx({ ...txData, kioskTx });
+					},
+				});
+			}
+		}
+
+		// nftsForTracking.push({
+		// 	nftType,
+		// 	claimer: walletAddress,
+		// 	claimReason: nft?.chain_state?.claimable_reason,
+		// });
+	}
+
+	sharedKioskState?.kioskTx?.finalize();
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && nftsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'CLAIM_NFTS',
+	// 		items: nftsForTracking,
+	// 	});
+	// }
+
+	return Transaction.from(tx);
+};

package/src/methods/createMultiBid/createMultiBid.ts

@@ -0,0 +1,36 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { TRADEPORT_MULTI_BID_PACKAGE, TRADEPORT_MULTI_BID_STORE } from '../../constants';
+import { updateMultiBid } from '../updateMultiBid/updateMultiBid';
+
+export interface CreateMultiBid {
+	walletAddress: string;
+	name?: string;
+	amount?: bigint;
+	tx?: Transaction;
+}
+
+export async function createMultiBid({
+	walletAddress,
+	name,
+	amount,
+	tx: existingTx,
+}: CreateMultiBid): Promise<{ multiBidChainId: any; tx: Transaction }> {
+	const tx = existingTx ?? new Transaction();
+
+	const multiBidChainId = tx.moveCall({
+		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::create_multi_bid`,
+		arguments: [tx.object(TRADEPORT_MULTI_BID_STORE), tx.pure.option('string', name)],
+	});
+
+	if (amount > 0n) {
+		await updateMultiBid({
+			walletAddress,
+			multiBidChainId,
+			amount,
+			name,
+			tx,
+		});
+	}
+
+	return { multiBidChainId, tx };
+}

package/src/methods/listNfts/addListTxs.ts

@@ -0,0 +1,210 @@
+import {
+	ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK,
+	TRADEPORT_BENEFICIARY_ADDRESS,
+	TRADEPORT_LISTINGS_PACKAGE,
+	TRADEPORT_LISTINGS_STORE,
+	TRADEPORT_ORDERBOOK_STORE,
+} from '../../constants';
+import { getMarketFeePrice } from '../../helpers/getMarketFeePrice';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { hasNativeKioskTransferPolicyRules } from '../../helpers/hasTransferPolicyRules';
+import { assertNftInSharedKiosk } from '../../helpers/kiosk/assertNftInSharedKiosk';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { takeAndBorrowNftFromKiosk } from '../../helpers/kiosk/takeAndBorrowNftFromKiosk';
+import { depositItemIntoOBKiosk } from '../../helpers/originByte/depositNftIntoOBKiosk';
+import { getOrCreateOBKiosk } from '../../helpers/originByte/getOrCreateOBKiosk';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { shareOriginByteKiosk } from '../../helpers/originByte/shareOriginByteKiosk';
+import { normalizedNftType } from '../../utils/normalizeNftType';
+import { validateMinFloorPrice } from '../../helpers/validateMinFloorPrice';
+import { type ListNftTx } from './listNfts';
+
+export async function addOriginByteListTx({
+	tx,
+	sharedObjects,
+	nftTokenId,
+	nftType,
+	seller,
+	listPrice,
+	collectionId,
+	sellerKiosk,
+	sharedKioskState,
+}: ListNftTx) {
+	const { orderbook } = sharedObjects;
+
+	await assertNftInSharedKiosk({
+		kioskId: sellerKiosk,
+		walletAddress: seller,
+		sharedKioskState,
+	});
+
+	const { kiosk, isNewKiosk } = await getOrCreateOBKiosk({
+		tx,
+		address: seller,
+		kioskToUseIfExists: sellerKiosk,
+		sharedKioskState,
+	});
+
+	if (isNewKiosk) {
+		depositItemIntoOBKiosk({
+			tx,
+			kiosk: sellerKiosk,
+			nftTokenId,
+			nftType,
+		});
+	}
+
+	const marketFeePrice = getMarketFeePrice({ price: listPrice, collectionId });
+
+	tx.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::create_ask_with_commission',
+		arguments: [
+			tx.object(orderbook),
+			tx.object(kiosk),
+			tx.pure.u64(listPrice),
+			tx.pure.address(nftTokenId),
+			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
+			tx.pure.u64(marketFeePrice),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	if (isNewKiosk) {
+		shareOriginByteKiosk({ tx, kiosk });
+	}
+}
+
+export function addTradePortListTx({
+	tx,
+	nftTokenId,
+	borrowedItem,
+	nftType,
+	listPrice,
+}: ListNftTx) {
+	tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::create_ob_listing_without_transfer_policy`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(TRADEPORT_ORDERBOOK_STORE),
+			borrowedItem ? tx.object(borrowedItem) : tx.object(nftTokenId),
+			tx.pure.u64(listPrice),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addKioskTradePortListTx({
+	tx,
+	kioskTx,
+	transferPolicies,
+	nftTokenId,
+	nftType,
+	listPrice,
+	seller,
+}: ListNftTx) {
+	validateMinFloorPrice({ transferPolicies, listPrice });
+
+	tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::create_ob_listing_with_transfer_policy`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(TRADEPORT_ORDERBOOK_STORE),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(seller),
+			tx.pure.id(nftTokenId),
+			tx.pure.u64(listPrice),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addTradePortListTxHandler(txData: ListNftTx) {
+	// If NFT is an Origin Byte collection, create an Origin Byte listing
+	if (
+		isOriginByteCollection(txData?.transferPolicies) &&
+		!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
+	) {
+		const sharedObjects = await getSharedObjects(txData?.nftType);
+		await addOriginByteListTx({ ...txData, sharedObjects });
+
+		return;
+	}
+
+	// If nft has no transfer policy rule but is inside a kiosk, take it out of the kiosk
+	if (
+		!hasNativeKioskTransferPolicyRules(txData?.transferPolicies) &&
+		txData?.sellerKiosk &&
+		txData?.nftType !==
+			'0xbf1431324a4a6eadd70e0ac6c5a16f36492f255ed4d011978b2cf34ad738efe6::day_one::DayOne'
+	) {
+		return kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: txData?.kioskClient,
+			kioskOwner: txData?.seller,
+			kiosk: txData?.sellerKiosk,
+			shouldAssertNftInSharedKiosk: true,
+			sharedKioskState: txData?.sharedKioskState,
+			shouldUseSharedKioskTx: false,
+			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,
+				});
+
+				addTradePortListTx({ ...txData, borrowedItem });
+			},
+		});
+	}
+
+	// If NFT is in a kiosk, create a kiosk listing
+	if (txData?.sellerKiosk) {
+		return kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: txData?.kioskClient,
+			kioskOwner: txData?.seller,
+			kiosk: txData?.sellerKiosk,
+			shouldAssertNftInSharedKiosk: true,
+			sharedKioskState: txData?.sharedKioskState,
+			shouldUseSharedKioskTx: false,
+			async runCommands(kioskTx) {
+				await addKioskTradePortListTx({
+					...txData,
+					kioskTx,
+				});
+			},
+		});
+	}
+
+	// If NFT is not in a kiosk, but nft type has a transfer policy rule, create kiosk and place NFT in kiosk first
+	if (!txData?.sellerKiosk && hasNativeKioskTransferPolicyRules(txData?.transferPolicies)) {
+		return kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: txData?.kioskClient,
+			kioskOwner: txData?.seller,
+			kiosk: txData?.sellerKiosk,
+			sharedKioskState: txData?.sharedKioskState,
+			shouldUseSharedKioskTx: false,
+			async runCommands(kioskTx) {
+				kioskTx.place({
+					item: txData?.nftTokenId,
+					itemType: txData?.nftType,
+				});
+				await addKioskTradePortListTx({
+					...txData,
+					kioskTx,
+				});
+			},
+		});
+	}
+
+	// Fallback to non-kiosk listing
+	addTradePortListTx(txData);
+}

package/src/methods/listNfts/addRelistTxs.ts

@@ -0,0 +1,87 @@
+import { type KioskClient, type ObjectArgument } from '@mysten/kiosk';
+import { type Transaction, type TransactionObjectArgument } from '@mysten/sui/transactions';
+import {
+	BLUEMOVE_MARKET_CONFIG_OBJECT,
+	TOCEN_MARKETPLACE_OBJECT,
+	TRADEPORT_LISTINGS_PACKAGE,
+	TRADEPORT_LISTINGS_STORE,
+	TRADEPORT_ORDERBOOK_STORE,
+} from '../../constants';
+import { addTradePortListTx } from './addListTxs';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+
+export type RelistNftTx = {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	kioskTx?: any;
+	kioskClient: KioskClient;
+	transferPolicies: any;
+	seller: string;
+	collectionId: string;
+	nftTokenId?: string;
+	borrowedItem?: ObjectArgument;
+	nftType: string;
+	listPrice: number;
+	listingNonce: string;
+	sellerKiosk: string;
+};
+
+export function addTradePortRelistTx({ tx, nftTokenId, nftType, listPrice }: RelistNftTx) {
+	tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::relist_ob_listing_without_transfer_policy`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(TRADEPORT_ORDERBOOK_STORE),
+			tx.pure.id(nftTokenId),
+			tx.pure.u64(listPrice),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addKioskTradePortRelistTx({
+	tx,
+	kioskTx,
+	nftTokenId,
+	nftType,
+	listPrice,
+}: RelistNftTx) {
+	tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::relist_ob_listing_with_transfer_policy`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object(TRADEPORT_ORDERBOOK_STORE),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.id(nftTokenId),
+			tx.pure.u64(listPrice),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export function addBlueMoveRelistTx(txData: RelistNftTx) {
+	const { tx, nftTokenId, nftType, listPrice } = txData;
+
+	const borrowedItem = tx.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist',
+		arguments: [tx.object(BLUEMOVE_MARKET_CONFIG_OBJECT), tx.pure.address(nftTokenId)],
+		typeArguments: [nftType, nftType],
+	}) as TransactionObjectArgument;
+
+	addTradePortListTx({ ...txData, listPrice, borrowedItem });
+}
+
+export function addTocenRelistTx(txData: RelistNftTx) {
+	const { tx, nftTokenId, nftType, listPrice } = txData;
+
+	const borrowedItem = tx.moveCall({
+		target:
+			'0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::delist',
+		arguments: [tx.object(TOCEN_MARKETPLACE_OBJECT), tx.pure.address(nftTokenId)],
+		typeArguments: [nftType],
+	}) as any;
+
+	addTradePortListTx({ ...txData, listPrice, borrowedItem });
+}