@tradeport/sui-trading-sdk 0.5.3 → 0.5.4

package/src/methods/buyListings/buyListings.ts

@@ -0,0 +1,230 @@
+import type { KioskClient, 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 { fetchListingsById } from '../../graphql/queries/fetchListingsById';
+import { addThirdPartyTxFee } from '../../helpers/addThirdPartyTxFee';
+import { getNftType } from '../../helpers/getNftType';
+import {
+	preProcessSharedBulkBuyingData,
+	type SharedBulkBuyingDataByNftType,
+} from '../../helpers/kiosk/preProcessSharedBulkBuyingData';
+import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+import {
+	addBluemoveBuyTxHandler,
+	addClutchyBuyTxHandler,
+	addHyperspaceBuyTxHandler,
+	addKeepsakeBuyTxHandler,
+	addSomisBuyTxHandler,
+	addSouffl3BuyTxHandler,
+	addTocenBuyTxHandler,
+	addTradePortBuyTxHandler,
+} from './addBuyListingTxs';
+
+type BuyTxBase = {
+	tx: Transaction;
+	sharedObjects?: any;
+	transferPolicies: any;
+	suiClient: SuiGrpcClient;
+	kioskClient: KioskClient;
+	kioskTx?: any;
+	sharedKioskState?: SharedKioskState;
+	buyer: string;
+	seller: string;
+	nftTokenId: string;
+	nftType: string;
+	listingId: string;
+	listingNonce: string;
+	price: number;
+	sellerKiosk: string;
+	collectionId: string;
+	nftContractId: string;
+	remainingAccountBalance?: number;
+	royalty?: number;
+	sharedBulkBuyingDataByNftType?: SharedBulkBuyingDataByNftType;
+};
+
+type NormalBuyTx = {
+	coinToSplit?: any;
+	nftTokenIds?: never;
+} & BuyTxBase;
+
+export type TocenBuyTx = {
+	coinToSplit?: any;
+	nftTokenIds: string[];
+} & BuyTxBase;
+
+export type BuyTx = (NormalBuyTx | TocenBuyTx) & {
+	marketFeeDecimalPercent?: number;
+	beforeResolveKioskTransferRequest?: (transferRequest: any) => void | Promise<void>;
+};
+
+export type BuyListing = {
+	listingId: string;
+	walletAddress: string;
+};
+
+export type BuyListings = {
+	listingIds: string[];
+	walletAddress: string;
+	tx?: Transaction;
+	kioskTx?: KioskTransaction;
+	coinToSplit?: any;
+	beforeResolveKioskTransferRequest?: (transferRequest: any) => void | Promise<void>;
+};
+
+export const buyListings = async (
+	{
+		listingIds,
+		walletAddress,
+		tx: existingTx,
+		kioskTx,
+		coinToSplit,
+		beforeResolveKioskTransferRequest,
+	}: BuyListings,
+	context: RequestContext,
+	marketFeeDecimalPercent?: number,
+): Promise<Transaction> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchListingsById,
+		variables: { listingIds },
+	});
+
+	if (res?.listings?.length === 0) {
+		throw new Error('No listings found');
+	}
+
+	const listingsForTracking = [];
+	const tx = existingTx ?? new Transaction();
+
+	const tocenTokenIds: string[] = [];
+	let tocenNftType = '';
+	let tocenTotalPrice = 0;
+
+	const sharedKioskState: SharedKioskState = {
+		kioskTx: kioskTx ?? undefined,
+	};
+
+	let sharedBulkBuyingDataByNftType: SharedBulkBuyingDataByNftType;
+	if (res.listings.length > 1) {
+		sharedBulkBuyingDataByNftType = await preProcessSharedBulkBuyingData({
+			listings: res.listings,
+			suiClient: context.suiClient,
+			kioskClient: context.kioskClient,
+			walletAddress,
+		});
+	}
+
+	for (const listing of res.listings) {
+		if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(listing?.nft?.token_id)) {
+			throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
+		}
+
+		if (!listing?.listed) {
+			throw new Error(`Listing ${listing?.id} is not listed`);
+		}
+
+		const nftType = getNftType({
+			collectionId: listing?.collection?.id,
+			collectionChainState: listing?.collection?.chain_state,
+			nft: listing?.nft,
+		});
+
+		const transferPolicies = listing?.collection?.chain_state?.transfer_policies;
+
+		const buyTxData: BuyTx = {
+			tx,
+			kioskTx,
+			transferPolicies,
+			suiClient: context.suiClient,
+			kioskClient: context.kioskClient,
+			buyer: walletAddress,
+			seller: listing?.seller,
+			nftTokenId: listing.nft?.token_id,
+			nftType,
+			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,
+			coinToSplit,
+			marketFeeDecimalPercent,
+			beforeResolveKioskTransferRequest,
+			sharedKioskState,
+			sharedBulkBuyingDataByNftType,
+		};
+
+		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(tx, listing?.price);
+		}
+
+		listingsForTracking.push({
+			walletAddress,
+			nftType,
+			collectionId: listing?.nft?.collection_id,
+			price: listing?.price,
+			seller: listing?.seller,
+			marketName: listing?.market_name,
+		});
+	}
+
+	sharedKioskState?.kioskTx?.finalize();
+
+	if (tocenTokenIds?.length > 0) {
+		addTocenBuyTxHandler({
+			tx,
+			nftType: tocenNftType,
+			nftTokenIds: tocenTokenIds,
+			price: tocenTotalPrice,
+		} as TocenBuyTx);
+	}
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && listingsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'BUY_LISTINGS',
+	// 		items: listingsForTracking,
+	// 	});
+	// }
+
+	return tx;
+};

package/src/methods/cancelMultiBid/cancelMultiBid.ts

@@ -0,0 +1,51 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { TRADEPORT_MULTI_BID_PACKAGE, TRADEPORT_MULTI_BID_STORE } from '../../constants';
+import {
+	fetchMultibidChainIdAndSingleBidsById,
+	fetchMultibidChainIdById,
+} from '../../graphql/queries/fetchMultibidById';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { addCancelSingleBidForMultibidChainId } from '../removeNftBids/addRemoveNftBidTxs';
+
+export interface CancelMultiBid {
+	walletAddress: string;
+	multiBidId: string;
+}
+
+export async function cancelMultiBid({ multiBidId }: CancelMultiBid): Promise<Transaction> {
+	const {
+		chain_id: multiBidChainId,
+		cancelled_at,
+		bids,
+	} = (
+		await gqlChainRequest({
+			chain: 'sui',
+			query: fetchMultibidChainIdAndSingleBidsById,
+			variables: { multiBidId },
+		})
+	)?.multi_bids?.[0] ?? {};
+	if (!multiBidChainId) {
+		throw new Error(`MultiBid ${multiBidId} not found`);
+	}
+
+	if (cancelled_at) {
+		throw new Error(`MultiBid ${multiBidId} already cancelled`);
+	}
+
+	const tx = new Transaction();
+	if (bids.length > 1022) {
+		// Transaction block is limited to 1024 txs
+		throw new Error(`Too many bids to cancel in one transaction`);
+	}
+
+	for (const bid of bids ?? []) {
+		addCancelSingleBidForMultibidChainId(tx, bid.nonce, multiBidChainId);
+	}
+
+	tx.moveCall({
+		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::cancel_multi_bid`,
+		arguments: [tx.object(TRADEPORT_MULTI_BID_STORE), tx.pure.id(multiBidChainId)],
+	});
+
+	return tx;
+}

package/src/methods/cancelNftTransfers/addCancelNftTransfersTx.ts

@@ -0,0 +1,20 @@
+import { TRADEPORT_KIOSK_TRANSFERS_STORE } from '../../constants';
+import { type CancelNftTransfersTx } from './cancelNftTransfers';
+
+export async function addTradeportKioskCancelNftTransferTx({
+	tx,
+	kioskTx,
+	nftTokenId,
+	nftType,
+}: CancelNftTransfersTx) {
+	tx.moveCall({
+		target:
+			'0x49642273ca7db3d942f9fd810c93467974c40e73ea7f03e8e7a632f1222aca73::kiosk_transfers::cancel_with_purchase_cap',
+		arguments: [
+			tx.object(TRADEPORT_KIOSK_TRANSFERS_STORE),
+			tx.object(kioskTx.kiosk),
+			tx.pure.address(nftTokenId),
+		],
+		typeArguments: [nftType],
+	});
+}

package/src/methods/cancelNftTransfers/cancelNftTransfers.ts

@@ -0,0 +1,118 @@
+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 { 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 { isOBKiosk } from '../../helpers/originByte/isOBKiosk';
+import { addTradeportKioskCancelNftTransferTx } from './addCancelNftTransfersTx';
+
+export type CancelNftTransfersTx = {
+	tx: Transaction;
+	nftType: string;
+	nftTokenId: string;
+	senderKiosk: string;
+	senderAddress: string;
+	sharedObjects?: any;
+	kioskTx?: any;
+	sharedKioskState?: SharedKioskState;
+};
+
+export type CancelNftTransfers = {
+	nftIds: string[];
+	walletAddress: string;
+};
+
+export const cancelNftTransfers = async (
+	{ nftIds, walletAddress }: CancelNftTransfers,
+	context: RequestContext,
+): 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 = 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?.chain_state?.claimable_reason !== 'offer-transfer') {
+			throw new Error('Cannot cancel transfer of NFT that is not currently transferring');
+		}
+
+		const nftType = getNftType({
+			collectionId: nft?.collection?.id,
+			collectionChainState: nft?.collection?.chain_state,
+			nft,
+		});
+
+		const sharedObjects = await getSharedObjects(nftType);
+
+		const txData: CancelNftTransfersTx = {
+			tx,
+			sharedKioskState,
+			nftType,
+			nftTokenId: nft?.token_id,
+			senderKiosk: nft?.chain_state?.kiosk_id,
+			senderAddress: walletAddress,
+			sharedObjects,
+		};
+
+		const isSenderKioskOriginByte = await isOBKiosk(txData.senderAddress, txData.senderKiosk);
+
+		// If NFT is not inside native kiosk, throw error
+		if (!txData.senderKiosk || isSenderKioskOriginByte) {
+			throw new Error('NFT is not inside a native kiosk, cannot cancel transfer');
+		}
+
+		await kioskTxWrapper({
+			tx: txData?.tx,
+			kioskClient: context.kioskClient,
+			kioskOwner: txData?.senderAddress,
+			kiosk: txData?.senderKiosk,
+			shouldAllowNftUnsharedKiosk: true,
+			sharedKioskState: txData?.sharedKioskState,
+			shouldUseSharedKioskTx: false,
+			async runCommands(kioskTx) {
+				await addTradeportKioskCancelNftTransferTx({ ...txData, kioskTx });
+			},
+		});
+
+		// nftsForTracking.push({
+		// 	nftType,
+		// 	senderAddress: walletAddress,
+		// });
+	}
+
+	sharedKioskState?.kioskTx?.finalize();
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && nftsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'CANCEL_NFT_TRANSFERS',
+	// 		items: nftsForTracking,
+	// 	});
+	// }
+
+	return Transaction.from(tx);
+};

package/src/methods/claimNfts/addClaimNftsTxs.ts

@@ -0,0 +1,247 @@
+import {
+	BLUEMOVE_KIOSK_OFFER_COLLECTION_BIDDER_BAG,
+	TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK,
+	TRADEPORT_KIOSK_BIDDING_STORE,
+	TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK,
+	TRADEPORT_KIOSK_TRANSFERS_STORE,
+} from '../../constants';
+import { getKioskCollectionRoyaltyFeeAmount } from '../../helpers/kiosk/getKioskCollectionRoyaltyFeeAmount';
+import { getNativeKioskTransferPolicies } from '../../helpers/kiosk/getNativeKioskTransferPolicies';
+import { resolveTransferPolicies } from '../../helpers/kiosk/resolveTransferPolicies';
+import { confirmOBTranfer } from '../../helpers/originByte/confirmOBTranfer';
+import { splitCoins } from '../../helpers/splitCoins';
+import {
+	type ClaimAcceptedBidNftTx,
+	type ClaimTradeHoldTx,
+	type ClaimTransferredNftTx,
+} from './claimNfts';
+
+export const addClaimTradeHoldTx = ({
+	tx,
+	sharedObjects,
+	nftType,
+	claimableTradeId,
+	claimableSellerKiosk,
+	claimableBuyerKiosk,
+}: ClaimTradeHoldTx) => {
+	const { orderbook } = sharedObjects;
+
+	const transferRequest = tx.moveCall({
+		target:
+			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::finish_trade',
+		arguments: [
+			tx.object(orderbook),
+			tx.pure.address(claimableTradeId),
+			tx.object(claimableSellerKiosk),
+			tx.object(claimableBuyerKiosk),
+		],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+
+	confirmOBTranfer({ tx, sharedObjects, transferRequest, nftType });
+};
+
+export const addClaimAcceptedBidNftTx = async ({
+	tx,
+	suiClient,
+	claimer,
+	kioskTx,
+	kioskClient,
+	nftTokenId,
+	nftType,
+	transferPolicies,
+}: ClaimAcceptedBidNftTx) => {
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const [transferRequest] = tx.moveCall({
+		target:
+			'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::claim_bid',
+		arguments: [
+			tx.object(TRADEPORT_KIOSK_BIDDING_STORE),
+			tx.object(TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(nftTokenId),
+			tx.object(transferPolicyId),
+		],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		tx,
+		transferPolicies,
+		suiClient,
+		walletAddress: claimer,
+		kioskTx,
+		kioskClient,
+		nftType,
+		price: '0',
+		transferRequest,
+		shouldSkipKioskLocking: true,
+	});
+};
+
+export const addClaimAcceptedBidNftWithPurchaseCapTx = async ({
+	tx,
+	suiClient,
+	claimer,
+	kioskTx,
+	kioskClient,
+	nftTokenId,
+	nftType,
+	sellerKiosk,
+	transferPolicies,
+}: ClaimAcceptedBidNftTx) => {
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const [transferRequest] = tx.moveCall({
+		target:
+			'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::claim_bid_with_purchase_cap',
+		arguments: [
+			tx.object(TRADEPORT_KIOSK_BIDDING_STORE),
+			tx.object(sellerKiosk),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(nftTokenId),
+			tx.object(transferPolicyId),
+		],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		tx,
+		transferPolicies,
+		suiClient,
+		walletAddress: claimer,
+		kioskTx,
+		kioskClient,
+		nftType,
+		price: '0',
+		transferRequest,
+		shouldSkipKioskLocking: true,
+	});
+};
+
+export const addClaimTransferredNftTx = async ({
+	tx,
+	suiClient,
+	claimer,
+	kioskTx,
+	kioskClient,
+	nftTokenId,
+	nftType,
+	transferPolicies,
+}: ClaimTransferredNftTx) => {
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const [transferRequest] = tx.moveCall({
+		target:
+			'0x49642273ca7db3d942f9fd810c93467974c40e73ea7f03e8e7a632f1222aca73::kiosk_transfers::claim',
+		arguments: [
+			tx.object(TRADEPORT_KIOSK_TRANSFERS_STORE),
+			tx.object(TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(nftTokenId),
+			tx.object(transferPolicyId),
+		],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		tx,
+		transferPolicies,
+		suiClient,
+		walletAddress: claimer,
+		kioskTx,
+		kioskClient,
+		nftType,
+		price: '0',
+		transferRequest,
+		shouldSkipKioskLocking: true,
+	});
+};
+
+export const addClaimTransferredNftWithPurchaseCapTx = async ({
+	tx,
+	suiClient,
+	claimer,
+	kioskTx,
+	kioskClient,
+	nftTokenId,
+	nftType,
+	sellerKiosk,
+	transferPolicies,
+	preloadedTransferPolicyId,
+}: ClaimTransferredNftTx) => {
+	const transferPolicyId =
+		preloadedTransferPolicyId ?? getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const [transferRequest] = tx.moveCall({
+		target:
+			'0x49642273ca7db3d942f9fd810c93467974c40e73ea7f03e8e7a632f1222aca73::kiosk_transfers::claim_with_purchase_cap',
+		arguments: [
+			tx.object(TRADEPORT_KIOSK_TRANSFERS_STORE),
+			tx.object(sellerKiosk),
+			kioskTx.kiosk,
+			kioskTx.kioskCap,
+			tx.pure.address(nftTokenId),
+			tx.object(transferPolicyId),
+		],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		tx,
+		transferPolicies,
+		suiClient,
+		walletAddress: claimer,
+		kioskTx,
+		kioskClient,
+		nftType,
+		price: '0',
+		transferRequest,
+		shouldSkipKioskLocking: true,
+	});
+};
+
+export const addBluemoveClaimAcceptedBidNft = async ({
+	tx,
+	suiClient,
+	claimer,
+	kioskTx,
+	nftTokenId,
+	nftType,
+	sellerKiosk,
+	transferPolicies,
+}: ClaimTransferredNftTx) => {
+	const transferPolicyId = getNativeKioskTransferPolicies(transferPolicies)?.at(0)?.id;
+
+	const royaltyFeeAmount = await getKioskCollectionRoyaltyFeeAmount({
+		tx,
+		suiClient,
+		walletAddress: claimer,
+		royaltyRulePackageId: '0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879',
+		royaltyRuleModule: 'royalty_rule',
+		transferPolicyId,
+		price: '0',
+		nftType,
+	});
+
+	const [coin] = splitCoins({ tx, amounts: [royaltyFeeAmount] });
+
+	tx.moveCall({
+		target:
+			'0xcc97b74ed95c8e8a3ed88050a898727dee37896da579fc400d482b64db6149ff::kiosk_offer_collection_v2::claim_nft_v2',
+		arguments: [
+			tx.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_BIDDER_BAG),
+			tx.object(transferPolicyId),
+			tx.object(sellerKiosk),
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(nftTokenId),
+			tx.object(coin),
+		],
+		typeArguments: [nftType],
+	});
+};