@tradeport/sui-trading-sdk 0.5.3 → 0.5.4

package/src/methods/removeNftBids/addRemoveNftBidTxs.ts

@@ -0,0 +1,122 @@
+import { normalizeSuiObjectId } from '@mysten/sui/utils';
+import {
+	BLUEMOVE_OFFER_DATA_OBJECT,
+	TOCEN_MARKETPLACE_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 { isSingleBid } from '../../helpers/isSIngleBid';
+import { isTradePortKioskBid } from '../../helpers/kiosk/isTradePortKioskBid';
+import { isOriginByteBid } from '../../helpers/originByte/isOriginByteBid';
+import { getObjectType } from '../../helpers/rpc/getObjectType';
+import { type RemoveNftBidTx } from './removeNftBids';
+import { type Transaction } from '@mysten/sui/transactions';
+
+export function addTradeportRemoveNftBidTx({ tx, bidNonce, nftType }: RemoveNftBidTx) {
+	tx.moveCall({
+		target:
+			'0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::cancel_bid',
+		arguments: [tx.object(TRADEPORT_BIDDING_STORE), tx.pure.address(bidNonce)],
+		typeArguments: [nftType],
+	});
+}
+
+export function addTradeportKioskRemoveNftBidTx({ tx, bidNonce, nftType }: RemoveNftBidTx) {
+	tx.moveCall({
+		target:
+			'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::cancel_bid',
+		arguments: [tx.object(TRADEPORT_KIOSK_BIDDING_STORE), tx.pure.address(bidNonce)],
+		typeArguments: [nftType],
+	});
+}
+
+export function addOriginByteRemoveNftBidTx({ tx, bidNonce }: RemoveNftBidTx) {
+	tx.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::close_bid',
+		arguments: [tx.object(bidNonce)],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+}
+
+export function addBluemoveRemoveNftBidTx({ tx, bidNonce, nftTokenId, nftType }: RemoveNftBidTx) {
+	tx.moveCall({
+		target:
+			'0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_item::cancel_offer_nft',
+		arguments: [
+			tx.object(BLUEMOVE_OFFER_DATA_OBJECT),
+			tx.pure.address(nftTokenId),
+			tx.pure.u64(bidNonce),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export function addTocenRemoveNftBidTx({ tx, nftTokenId, bidAmount }: RemoveNftBidTx) {
+	tx.moveCall({
+		target:
+			'0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::cancel_offer',
+		arguments: [
+			tx.object(TOCEN_MARKETPLACE_OBJECT),
+			tx.pure.address(nftTokenId),
+			tx.pure.u64(bidAmount),
+		],
+		typeArguments: [],
+	});
+}
+
+export async function addSingleBidRemoveNftBidTx({ tx, bidNonce, multiBidId }: RemoveNftBidTx) {
+	const multiBidChainId = multiBidId
+		? (
+				await gqlChainRequest({
+					chain: 'sui',
+					query: fetchMultibidChainIdById,
+					variables: { multiBidId },
+				})
+			)?.multi_bids?.[0]?.chain_id
+		: undefined;
+	addCancelSingleBidForMultibidChainId(tx, bidNonce, multiBidChainId);
+}
+
+export function addCancelSingleBidForMultibidChainId(
+	tx: Transaction,
+	bidNonce: string,
+	multiBidChainId?: string,
+) {
+	tx.moveCall({
+		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::cancel_bid`,
+		arguments: [
+			tx.object(TRADEPORT_MULTI_BID_STORE),
+			tx.pure.id(normalizeSuiObjectId(bidNonce)),
+			tx.pure.option('id', multiBidChainId),
+		],
+	});
+}
+
+export async function addTradePortRemoveNftBidTxHandler(txData: RemoveNftBidTx) {
+	const bidType = await getObjectType({
+		suiClient: txData?.suiClient,
+		objectId: normalizeSuiObjectId(txData?.bidNonce),
+	});
+
+	if (isSingleBid(bidType)) {
+		await addSingleBidRemoveNftBidTx(txData);
+		return;
+	}
+
+	if (isOriginByteBid(bidType)) {
+		addOriginByteRemoveNftBidTx(txData);
+		return;
+	}
+
+	if (isTradePortKioskBid(bidType)) {
+		addTradeportKioskRemoveNftBidTx(txData);
+		return;
+	}
+
+	addTradeportRemoveNftBidTx(txData);
+}

package/src/methods/removeNftBids/removeNftBids.ts

@@ -0,0 +1,116 @@
+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 {
+	addBluemoveRemoveNftBidTx,
+	addOriginByteRemoveNftBidTx,
+	addTocenRemoveNftBidTx,
+	addTradePortRemoveNftBidTxHandler,
+} from './addRemoveNftBidTxs';
+
+export type RemoveNftBidTx = {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	sharedObjects?: any;
+	bidNonce: string;
+	nftType: string;
+	nftTokenId: string;
+	bidAmount: number;
+	sellerKiosk: string;
+	bidMarketName: string;
+	multiBidId?: string;
+};
+
+export type RemoveNftBid = {
+	bidId: string;
+};
+
+export type RemoveNftBids = {
+	bidIds: string[];
+	tx?: Transaction | string;
+};
+
+export const removeNftBids = async (
+	{ bidIds, tx: existingTx }: RemoveNftBids,
+	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 ? Transaction.from(existingTx) : new Transaction();
+
+	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);
+		}
+
+		const nftType = getNftType({
+			collectionId: bid?.collection?.id,
+			collectionChainState: bid?.collection?.chain_state,
+			nft: bid?.nft,
+		});
+
+		const txData: RemoveNftBidTx = {
+			tx,
+			suiClient: context.suiClient,
+			bidNonce: bid?.nonce,
+			nftType,
+			nftTokenId: bid?.nft?.token_id,
+			bidAmount: bid?.price,
+			sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
+			bidMarketName: bid?.market_contract?.name,
+			multiBidId: bid?.multi_bid_id,
+		};
+
+		switch (txData.bidMarketName) {
+			case 'tradeport':
+				await addTradePortRemoveNftBidTxHandler(txData);
+				break;
+			case 'clutchy':
+				addOriginByteRemoveNftBidTx(txData);
+				break;
+			case 'bluemove':
+				addBluemoveRemoveNftBidTx(txData);
+				break;
+			case 'tocen':
+				addTocenRemoveNftBidTx(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,
+			bidder: bid?.bidder,
+		});
+	}
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && bidsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'REMOVE_NFT_BIDS',
+	// 		items: bidsForTracking,
+	// 	});
+	// }
+
+	return Transaction.from(tx);
+};

package/src/methods/sponsorNftListing/addSponsorNftListingTx.ts

@@ -0,0 +1,40 @@
+import { coinWithBalance, type Transaction } from '@mysten/sui/transactions';
+import BigNumber from '../../bigNumberConfig';
+import {
+	TRADEPORT_LISTINGS_PACKAGE,
+	TRADEPORT_LISTINGS_STORE,
+	USDC_COIN_TYPE,
+} from '../../constants';
+import { type SponsorNftListingOptions } from './sponsorNftListing';
+
+export const addSponsorListingTx = async ({
+	tx,
+	nftTokenId,
+	nftType,
+	sponsorOptions,
+}: {
+	tx: Transaction;
+	nftTokenId: string;
+	nftType: string;
+	sponsorOptions: SponsorNftListingOptions;
+}) => {
+	const totalFee = new BigNumber(sponsorOptions?.usdcFeeAmountPerPeriod)
+		?.times(sponsorOptions?.numOfPeriods)
+		.toString();
+
+	const sponsorCoin = sponsorOptions.coinToSplit
+		? tx.splitCoins(sponsorOptions.coinToSplit, [tx.pure.u64(totalFee)])[0]
+		: coinWithBalance({ type: USDC_COIN_TYPE, balance: BigInt(totalFee) });
+
+	tx.moveCall({
+		target: `${TRADEPORT_LISTINGS_PACKAGE}::tradeport_listings::add_sponsored_listing`,
+		arguments: [
+			tx.object(TRADEPORT_LISTINGS_STORE),
+			tx.object.clock(),
+			tx.pure.id(nftTokenId),
+			tx.pure.u64(sponsorOptions?.numOfPeriods),
+			tx.object(sponsorCoin),
+		],
+		typeArguments: [nftType],
+	});
+};

package/src/methods/sponsorNftListing/sponsorNftListing.ts

@@ -0,0 +1,60 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchNftCollectionChainState } from '../../graphql/queries/fetchNftCollectionChainState';
+import { getNftType } from '../../helpers/getNftType';
+import { isOriginByteCollection } from '../../helpers/originByte/isOriginByteCollection';
+import { addSponsorListingTx } from './addSponsorNftListingTx';
+
+export type SponsorNftListingOptions = {
+	shouldSponsor?: boolean;
+	numOfPeriods?: number;
+	usdcFeeAmountPerPeriod?: number;
+	coinToSplit?: any;
+};
+
+export type SponsorNftListing = {
+	tx?: Transaction;
+	nftTokenId: string;
+	options: SponsorNftListingOptions;
+};
+
+export const sponsorNftListing = async ({
+	tx: existingTx,
+	nftTokenId,
+	options,
+}: SponsorNftListing): Promise<Transaction> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchNftCollectionChainState,
+		variables: { nftTokenId },
+	});
+
+	if (res?.nfts?.length === 0) {
+		throw new Error(`No nft found with token id ${nftTokenId}`);
+	}
+
+	const nft = res?.nfts?.[0];
+
+	const nftType = getNftType({
+		collectionId: nft?.collection?.id,
+		collectionChainState: nft?.collection?.chain_state,
+		nft,
+	});
+
+	const transferPolicies = nft?.collection?.chain_state?.transfer_policies;
+
+	if (isOriginByteCollection(transferPolicies)) {
+		throw new Error(`You cannot sponsor an Origin Byte NFT. Nft Token Id: ${nftTokenId}`);
+	}
+
+	const tx = existingTx ?? new Transaction();
+
+	await addSponsorListingTx({
+		tx,
+		nftTokenId,
+		nftType,
+		sponsorOptions: options,
+	});
+
+	return tx;
+};

package/src/methods/transferNfts/addTransferNftTx.ts

@@ -0,0 +1,220 @@
+import { type KioskClient } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { type Transaction } from '@mysten/sui/transactions';
+import {
+	MYSTEN_TRANSFER_POLICY_RULES_PACKAGE_ID,
+	MYSTEN_TRANSFER_POLICY_RULES_PACKAGE_ID_V2,
+	TRADEPORT_KIOSK_TRANSFERS_STORE,
+} from '../../constants';
+import { destroyZeroCoin } from '../../helpers/destroyZeroCoin';
+import { getNftType } from '../../helpers/getNftType';
+import { getTransferPolicyRuleNamesFromSuiObject } from '../../helpers/getTransferPolicyRuleNamesFromSuiObject';
+import { assertNftInSharedKiosk } from '../../helpers/kiosk/assertNftInSharedKiosk';
+import { getNativeKioskTransferPolicies } from '../../helpers/kiosk/getNativeKioskTransferPolicies';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
+import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+import { getOBKiosk } from '../../helpers/originByte/getOBKiosk';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { type TransferNftTx } from './transferNfts';
+
+type CollectionChainState = {
+	transfer_policies: TransferPolicy[];
+};
+type TransferPolicy = {
+	id: string;
+	rules: Array<{ type: string; min_amount?: string }>;
+	is_origin_byte: boolean;
+	is_disabled: boolean;
+};
+
+export async function addOriginByteTransferNftTx({
+	tx,
+	nftTokenId,
+	nftType,
+	recipientAddress,
+	senderKiosk,
+	senderAddress,
+	sharedKioskState,
+}: TransferNftTx) {
+	await assertNftInSharedKiosk({
+		kioskId: senderKiosk,
+		walletAddress: senderAddress,
+		sharedKioskState,
+	});
+
+	const recipientOBKiosk = await getOBKiosk({ wallet: recipientAddress, sharedKioskState });
+
+	if (recipientOBKiosk) {
+		tx.moveCall({
+			target:
+				'0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer',
+			arguments: [tx.object(senderKiosk), tx.object(recipientOBKiosk), tx.pure.address(nftTokenId)],
+			typeArguments: [nftType],
+		});
+	} else {
+		tx.moveCall({
+			target:
+				'0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer_and_create_target_kiosk',
+			arguments: [
+				tx.object(senderKiosk),
+				tx.pure.address(addLeadingZerosAfter0x(recipientAddress)),
+				tx.pure.address(nftTokenId),
+			],
+			typeArguments: [nftType],
+		});
+	}
+}
+
+export async function addTradeportKioskTransferTx({
+	tx,
+	kioskTx,
+	nftTokenId,
+	nftType,
+	recipientAddress,
+	transferPolicy,
+	transferPolicies,
+}: TransferNftTx) {
+	const existingTransferPolicy =
+		transferPolicy ?? getNativeKioskTransferPolicies(transferPolicies)?.at(0);
+	const hasFloorPriceRule = existingTransferPolicy?.rules?.some(
+		(rule: any) => rule.type === 'floor_price_rule',
+	);
+	if (hasFloorPriceRule) {
+		throw new Error('Cannot transfer NFT with a minimum floor price rule');
+	}
+
+	tx.moveCall({
+		target:
+			'0x49642273ca7db3d942f9fd810c93467974c40e73ea7f03e8e7a632f1222aca73::kiosk_transfers::transfer_with_purchase_capability',
+		arguments: [
+			tx.object(TRADEPORT_KIOSK_TRANSFERS_STORE),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(nftTokenId),
+			tx.pure.address(addLeadingZerosAfter0x(recipientAddress)),
+		],
+		typeArguments: [nftType],
+	});
+}
+
+export async function addTradeportKioskDirectTransferTx(
+	txData: {
+		tx: Transaction;
+		recipientAddress: string;
+		kioskClient: KioskClient;
+		senderAddress: string;
+		sharedKioskState?: SharedKioskState;
+	},
+	nfts: any[],
+	suiClient: SuiGrpcClient,
+) {
+	const { tx, recipientAddress, kioskClient, sharedKioskState, senderAddress } = txData;
+	if (nfts.length === 0) {
+		return;
+	}
+
+	const transferPolicies = new Map<string, TransferPolicy>(
+		await Promise.all(
+			nfts.map(
+				async (nft): Promise<[string, TransferPolicy]> => [
+					nft.id as string,
+					await getTransferPolicyForDirectTransfer(suiClient, nft.collection.chain_state),
+				],
+			),
+		),
+	);
+	const royaltyAmounts = [...transferPolicies.values()].map((transferPolicy) =>
+		BigInt(transferPolicy?.rules.find((rule) => rule.type === 'royalty_rule')?.min_amount ?? 0n),
+	);
+
+	const totalRoyaltyAmount = royaltyAmounts.reduce((sum: bigint, amount) => sum + amount, 0n);
+	// When no royalty is due, avoid touching the gas coin: sponsored transactions
+	// (e.g. Enoki) reject any PTB that uses GasCoin as an argument.
+	const [royaltyCoin] =
+		totalRoyaltyAmount === 0n
+			? tx.moveCall({
+					target: '0x2::coin::zero',
+					arguments: [],
+					typeArguments: ['0x2::sui::SUI'],
+				})
+			: tx.splitCoins(tx.gas, [tx.pure.u64(totalRoyaltyAmount)]);
+	for (const nft of nfts) {
+		const nftType = getNftType({
+			collectionId: nft?.collection?.id,
+			collectionChainState: nft?.collection?.chain_state,
+			nft,
+		});
+
+		await kioskTxWrapper({
+			tx,
+			kioskClient,
+			kioskOwner: senderAddress,
+			kiosk: nft?.chain_state?.kiosk_id,
+			sharedKioskState,
+			shouldUseSharedKioskTx: false,
+			async runCommands(kioskTx) {
+				tx.moveCall({
+					target:
+						'0x4acc0efedd243eb61ab8f8a3e9c24b09a1838c43d16029e8c8985004dfd67239::kiosk_transfers::direct_transfer_to_receiver',
+					arguments: [
+						tx.object(kioskTx.getKiosk() as any),
+						tx.object(kioskTx.getKioskCap() as any),
+						tx.pure.address(recipientAddress),
+						tx.pure.id(nft.token_id),
+						tx.object(transferPolicies.get(nft.id).id),
+						royaltyCoin,
+					],
+					typeArguments: [nftType],
+				});
+			},
+		});
+	}
+
+	destroyZeroCoin({ tx, coin: royaltyCoin });
+}
+
+export async function canBeTransferedDirectly(
+	suiClient: SuiGrpcClient,
+	collectionChainState?: CollectionChainState,
+) {
+	return (
+		(await getTransferPolicyForDirectTransfer(suiClient, collectionChainState, true)) !== undefined
+	);
+}
+
+export async function getTransferPolicyForDirectTransfer(
+	suiClient: SuiGrpcClient,
+	collectionChainState?: CollectionChainState,
+	validateRules = false,
+): Promise<TransferPolicy | undefined> {
+	const candidatePolicy = collectionChainState?.transfer_policies?.find(
+		(policy) =>
+			!policy.is_origin_byte &&
+			!policy.is_disabled &&
+			policy.rules.length > 0 &&
+			policy.rules?.filter(
+				(rule) =>
+					rule.type !== 'kiosk_lock_rule' &&
+					rule.type !== 'royalty_rule' &&
+					rule.type !== 'personal_kiosk_rule',
+			).length === 0,
+	);
+
+	if (validateRules && candidatePolicy) {
+		const ruleNames = await getTransferPolicyRuleNamesFromSuiObject({
+			suiClient,
+			transferPolicyId: candidatePolicy.id,
+		});
+		if (
+			!ruleNames.every(
+				(name) =>
+					name.startsWith(MYSTEN_TRANSFER_POLICY_RULES_PACKAGE_ID) ||
+					name.startsWith(MYSTEN_TRANSFER_POLICY_RULES_PACKAGE_ID_V2),
+			)
+		) {
+			return undefined;
+		}
+	}
+
+	return candidatePolicy;
+}