@tradeport/sui-trading-sdk 0.5.2 → 0.5.3

package/src/methods/removeNftBids/addRemoveNftBidTxs.ts

@@ -1,122 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,220 +0,0 @@
-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;
-}