@tradeport/sui-trading-sdk 0.5.3 → 0.5.5

package/src/helpers/kiosk/takeLockedNftFromKiosk.ts

@@ -0,0 +1,73 @@
+import { type KioskClient, type KioskTransaction, type TransferPolicy } from '@mysten/kiosk';
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { type Transaction } from '@mysten/sui/transactions';
+import { getNativeKioskTransferPolicies } from './getNativeKioskTransferPolicies';
+import { resolveTransferPolicies } from './resolveTransferPolicies';
+
+interface TakeLockedNftFromKioskProps {
+	tx: Transaction;
+	transferPolicies: TransferPolicy[];
+	suiClient: SuiGrpcClient;
+	kioskTx: KioskTransaction;
+	kioskClient: KioskClient;
+	nftTokenId: string;
+	nftType: string;
+	kioskOwner: string;
+}
+
+export const takeLockedNftFromKiosk = async ({
+	tx,
+	transferPolicies,
+	suiClient,
+	kioskTx,
+	kioskClient,
+	nftTokenId,
+	nftType,
+	kioskOwner,
+}: TakeLockedNftFromKioskProps) => {
+	const transferPolicy = getNativeKioskTransferPolicies(transferPolicies)?.at(0);
+	const hasFloorPriceRule = transferPolicy?.rules?.some(
+		(rule: any) => rule.type === 'floor_price_rule',
+	);
+	if (hasFloorPriceRule) {
+		throw new Error('Cannot take locked NFT from kiosk with a minimum floor price rule');
+	}
+
+	const [purchase_cap] = tx.moveCall({
+		target: '0x2::kiosk::list_with_purchase_cap',
+		arguments: [
+			tx.object(kioskTx.kiosk),
+			tx.object(kioskTx.kioskCap),
+			tx.pure.address(nftTokenId),
+			tx.pure.u64(0),
+		],
+		typeArguments: [nftType],
+	});
+
+	const [zeroCoin] = tx.moveCall({
+		target: '0x2::coin::zero',
+		arguments: [],
+		typeArguments: ['0x2::sui::SUI'],
+	});
+
+	const [nft, transferRequest] = tx.moveCall({
+		target: '0x2::kiosk::purchase_with_cap',
+		arguments: [tx.object(kioskTx.kiosk), purchase_cap, zeroCoin],
+		typeArguments: [nftType],
+	});
+
+	await resolveTransferPolicies({
+		tx,
+		transferPolicies,
+		suiClient,
+		walletAddress: kioskOwner,
+		kioskTx,
+		kioskClient,
+		nftType,
+		price: '0',
+		transferRequest,
+		shouldSkipKioskLocking: true,
+	});
+
+	return nft;
+};

package/src/helpers/kiosk/upgradeKioskRulesPackageId.ts

@@ -0,0 +1,17 @@
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+
+// @mysten/kiosk's mainnet rule defaults still point at v1 of the kiosk rules
+// package. The package has since been upgraded; newer collections (e.g. suirocks)
+// have linkage constraints that require the upgraded version, so calling v1
+// fails with InvalidLinkage. Remap the original packageId to the upgraded one
+// when it shows up in rule lookups.
+const KIOSK_RULES_ORIGINAL_PACKAGE_ID = normalizeSuiAddress(
+	'0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879',
+);
+const KIOSK_RULES_UPGRADED_PACKAGE_ID =
+	'0xdfb4f1d4e43e0c3ad834dcd369f0d39005c872e118c9dc1c5da9765bb93ee5f3';
+
+export const upgradeKioskRulesPackageId = (packageId: string): string =>
+	normalizeSuiAddress(packageId) === KIOSK_RULES_ORIGINAL_PACKAGE_ID
+		? KIOSK_RULES_UPGRADED_PACKAGE_ID
+		: packageId;

package/src/helpers/originByte/confirmOBTranfer.ts

@@ -0,0 +1,33 @@
+import { type Transaction } from '@mysten/sui/transactions';
+
+type Args = {
+	tx: Transaction;
+	sharedObjects: any;
+	transferRequest: any;
+	nftType: string;
+};
+
+export const confirmOBTranfer = ({ tx, sharedObjects, transferRequest, nftType }: Args) => {
+	tx.moveCall({
+		target:
+			'0x6f42ec2355fcda5ebeee2399d901ae9f71cb214e640a45a0007f1f1cdf9f7b5e::transfer_allowlist::confirm_transfer',
+		arguments: [tx.object(sharedObjects?.allowList), tx.object(transferRequest)],
+		typeArguments: [nftType],
+	});
+
+	if (sharedObjects?.royaltyStrategy) {
+		tx.moveCall({
+			target:
+				'0x6f42ec2355fcda5ebeee2399d901ae9f71cb214e640a45a0007f1f1cdf9f7b5e::royalty_strategy_bps::confirm_transfer',
+			arguments: [tx.object(sharedObjects?.royaltyStrategy), tx.object(transferRequest)],
+			typeArguments: [nftType, '0x2::sui::SUI'],
+		});
+	}
+
+	tx.moveCall({
+		target:
+			'0xadf32ebafc587cc86e1e56e59f7b17c7e8cbeb3315193be63c6f73157d4e88b9::transfer_request::confirm',
+		arguments: [tx.object(transferRequest), tx.object(sharedObjects?.transferPolicy)],
+		typeArguments: [nftType, '0x2::sui::SUI'],
+	});
+};

package/src/helpers/originByte/createOBKiosk.ts

@@ -0,0 +1,14 @@
+type Args = {
+	tx: any;
+	createMethod?: string;
+};
+
+export const createOBKiosk = async ({ tx, createMethod = 'new' }: Args) => {
+	const [kiosk] = tx.moveCall({
+		target: `0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::${createMethod}`,
+		arguments: [],
+		typeArguments: [],
+	});
+
+	return [kiosk];
+};

package/src/helpers/originByte/depositNftIntoOBKiosk.ts

@@ -0,0 +1,16 @@
+import { type Transaction } from '@mysten/sui/transactions';
+
+type Args = {
+	tx: Transaction;
+	kiosk: string;
+	nftTokenId: string;
+	nftType: string;
+};
+
+export const depositItemIntoOBKiosk = ({ tx, kiosk, nftTokenId, nftType }: Args) => {
+	tx.moveCall({
+		target: '0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::deposit',
+		arguments: [tx.object(kiosk), tx.object(nftTokenId)],
+		typeArguments: [nftType],
+	});
+};

package/src/helpers/originByte/getOBBidderKiosk.ts

@@ -0,0 +1,12 @@
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+
+export const getOBBidderKiosk = async ({
+	suiClient,
+	bidNonce,
+}: {
+	suiClient: SuiGrpcClient;
+	bidNonce: string;
+}) => {
+	const bidObject = await suiClient.getObject({ objectId: bidNonce, include: { json: true } });
+	return (bidObject.object?.json as any)?.kiosk;
+};

package/src/helpers/originByte/getOBKiosk.ts

@@ -0,0 +1,24 @@
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchWalletKiosks } from '../../graphql/queries/fetchWalletKiosks';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+import { type SharedKioskState } from '../kiosk/sharedKioskState.type';
+
+export const getOBKiosk = async ({
+	wallet,
+	sharedKioskState,
+}: {
+	wallet: string;
+	sharedKioskState?: SharedKioskState;
+}): Promise<any> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchWalletKiosks,
+		variables: { wallet: addLeadingZerosAfter0x(wallet) },
+	});
+
+	if (sharedKioskState && !sharedKioskState?.ownerKiosks) {
+		sharedKioskState.ownerKiosks = res?.kiosks;
+	}
+
+	return res?.kiosks?.filter((kiosk: any) => kiosk?.is_origin_byte && kiosk?.is_shared)?.[0]?.id;
+};

package/src/helpers/originByte/getOrCreateOBKiosk.ts

@@ -0,0 +1,42 @@
+import { type SharedKioskState } from '../kiosk/sharedKioskState.type';
+import { createOBKiosk } from './createOBKiosk';
+import { getOBKiosk } from './getOBKiosk';
+
+type Args = {
+	tx: any;
+	address: string;
+	kioskToUseIfExists?: string;
+	createMethod?: string;
+	sharedKioskState?: SharedKioskState;
+};
+
+export const getOrCreateOBKiosk = async ({
+	tx,
+	address,
+	kioskToUseIfExists,
+	createMethod,
+	sharedKioskState,
+}: Args) => {
+	if (kioskToUseIfExists) {
+		return {
+			kiosk: kioskToUseIfExists,
+			isNewKiosk: false,
+		};
+	}
+
+	if (!sharedKioskState?.ownerKiosks) {
+		const existingKiosk = await getOBKiosk({ wallet: address, sharedKioskState });
+		if (existingKiosk) {
+			return {
+				kiosk: existingKiosk,
+				isNewKiosk: false,
+			};
+		}
+	}
+
+	const [newKiosk] = await createOBKiosk({ tx, createMethod });
+	return {
+		kiosk: newKiosk,
+		isNewKiosk: true,
+	};
+};

package/src/helpers/originByte/isOBKiosk.ts

@@ -0,0 +1,13 @@
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchAccountKiosks } from '../../graphql/queries/fetchAccountKiosks';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+
+export const isOBKiosk = async (accountAddress: string, kiosk: any): Promise<boolean> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchAccountKiosks,
+		variables: { accountAddress: addLeadingZerosAfter0x(accountAddress) },
+	});
+
+	return res?.kiosks?.filter((k: any) => k?.id === kiosk)?.[0]?.is_origin_byte;
+};

package/src/helpers/originByte/isOriginByteBid.ts

@@ -0,0 +1,30 @@
+import { normalizeStructTag } from '@mysten/sui/utils';
+import { ORIGIN_BYTE_BID_NONCE_TYPE } from '../../constants';
+
+// The gRPC client returns Move types with fully-padded addresses
+// (e.g. `0x0000…0002::kiosk::Kiosk`), while the JSON-RPC client used the
+// abbreviated form (`0x2::kiosk::Kiosk`). Normalize both sides so the
+// comparison is independent of address format / type-argument padding.
+const safeNormalizeStructTag = (type: string): string => {
+	try {
+		return normalizeStructTag(type);
+	} catch {
+		return type;
+	}
+};
+
+// Precomputed once. `normalizeStructTag` preserves module-name casing, so the
+// legacy capitalized `Kiosk` variant is kept alongside the canonical lowercase one.
+const ORIGIN_BYTE_BID_TYPES = new Set(
+	[ORIGIN_BYTE_BID_NONCE_TYPE, '0x2::kiosk::Kiosk', '0x2::Kiosk::Kiosk'].map(
+		safeNormalizeStructTag,
+	),
+);
+
+export const isOriginByteBid = (bidType: string): boolean => {
+	if (!bidType) {
+		return false;
+	}
+
+	return ORIGIN_BYTE_BID_TYPES.has(safeNormalizeStructTag(bidType));
+};

package/src/helpers/originByte/isOriginByteCollection.ts

@@ -0,0 +1,11 @@
+export const isOriginByteCollection = (transferPolicies: any): boolean => {
+	const hasOriginBytePolicies =
+		transferPolicies?.filter((policy: any) => policy?.is_origin_byte && !policy?.is_disabled)
+			?.length > 0;
+
+	const hasNonOriginBytePoliciesWithRules = transferPolicies
+		?.filter((policy: any) => !policy?.is_origin_byte && !policy?.is_disabled)
+		?.some((policy: any) => policy?.rules?.length > 0);
+
+	return Boolean(hasOriginBytePolicies && !hasNonOriginBytePoliciesWithRules);
+};

package/src/helpers/originByte/shareOriginByteKiosk.ts

@@ -0,0 +1,14 @@
+import { type Transaction } from '@mysten/sui/transactions';
+
+type Args = {
+	tx: Transaction;
+	kiosk: string;
+};
+
+export const shareOriginByteKiosk = ({ tx, kiosk }: Args) => {
+	tx.moveCall({
+		target: '0x2::transfer::public_share_object',
+		arguments: [tx.object(kiosk)],
+		typeArguments: ['0x2::kiosk::Kiosk'],
+	});
+};

package/src/helpers/rpc/getAcountBalance.ts

@@ -0,0 +1,18 @@
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+
+type Args = {
+	suiClient: SuiGrpcClient;
+	owner: string;
+};
+
+export const getAccountBalance = async ({ suiClient, owner }: Args): Promise<number> => {
+	try {
+		const res = await suiClient.getBalance({
+			owner: addLeadingZerosAfter0x(owner),
+		});
+		return Number(res?.balance?.balance);
+	} catch (err) {
+		return 0;
+	}
+};

package/src/helpers/rpc/getObjectType.ts

@@ -0,0 +1,25 @@
+import { type SuiGrpcClient } from '@mysten/sui/grpc';
+import { isValidSuiObjectId } from '@mysten/sui/utils';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+
+export const getObjectType = async ({
+	suiClient,
+	objectId,
+}: {
+	suiClient: SuiGrpcClient;
+	objectId: string;
+}): Promise<string> => {
+	const normalizedObjectId = objectId.startsWith('0x')
+		? addLeadingZerosAfter0x(objectId)
+		: objectId;
+	if (isValidSuiObjectId(normalizedObjectId)) {
+		try {
+			const res = await suiClient.getObject({ objectId: normalizedObjectId, include: {} });
+			return res.object?.type ?? '';
+		} catch {
+			return '';
+		}
+	}
+
+	return '';
+};

package/src/helpers/splitCoins.ts

@@ -0,0 +1,12 @@
+import { type Transaction } from '@mysten/sui/transactions';
+
+type Args = {
+	tx: Transaction;
+	amounts: any;
+};
+
+export const splitCoins = ({ tx, amounts }: Args) => {
+	const res = tx.splitCoins(tx.gas, amounts);
+
+	return res;
+};

package/src/helpers/track.ts

@@ -0,0 +1,20 @@
+interface TrackMethodCallArgs {
+	apiUser: string;
+	apiKey: string;
+	event: string;
+	items?: any[];
+}
+
+export const trackMethodCall = ({ apiUser, apiKey, event, items }: TrackMethodCallArgs) => {
+	// analytics.track({
+	// 	userId: apiUser,
+	// 	event,
+	// 	properties: {
+	// 		chain: 'sui',
+	// 		apiUser,
+	// 		apiKey,
+	// 		items,
+	// 	},
+	// });
+	// void analytics.flush();
+};

package/src/helpers/validateMinFloorPrice.ts

@@ -0,0 +1,22 @@
+import { getNativeKioskTransferPolicies } from './kiosk/getNativeKioskTransferPolicies';
+
+interface ValidateMinFloorPriceArgs {
+	transferPolicies: any;
+	listPrice: number;
+}
+
+export function validateMinFloorPrice({ transferPolicies, listPrice }: ValidateMinFloorPriceArgs) {
+	const transferPolicy = getNativeKioskTransferPolicies(transferPolicies)?.at(0);
+	const minFloorPrice = transferPolicy?.rules?.filter(
+		(rule: any) => rule?.type === 'floor_price_rule',
+	)?.[0]?.floor_price;
+
+	if (minFloorPrice) {
+		if (listPrice < minFloorPrice) {
+			const formattedMinFloorPrice = Number(minFloorPrice) / 1000000000;
+			throw new Error(
+				`NFT Transfer Policy has a miminum floor price rule. Item cannot be listed for less than ${formattedMinFloorPrice} SUI`,
+			);
+		}
+	}
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+import SuiTradingClient from './SuiTradingClient';
+export { SuiTradingClient };

package/src/methods/acceptCollectionBid/acceptCollectionBid.ts

@@ -0,0 +1,189 @@
+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 { fetchNftById } from '../../graphql/queries/fetchNftsById';
+import { getNftType } from '../../helpers/getNftType';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { type SharedKioskState } from '../../helpers/kiosk/sharedKioskState.type';
+import {
+	addBluemoveAcceptCollectionBidTxHandler,
+	addOriginByteAcceptCollectionBidTx,
+	addTocenAcceptCollectionBidTxHandler,
+	addTradePortAcceptCollectionBidTxHandler,
+} from './addAcceptCollectionBIdTxs';
+
+export type AcceptCollectionBidTx = {
+	tx: Transaction;
+	suiClient: SuiGrpcClient;
+	kioskClient: KioskClient;
+	kioskTx?: any;
+	sharedObjects?: any;
+	transferPolicies: any;
+	sharedKioskState?: SharedKioskState;
+	bidNonce: string;
+	nftType: string;
+	nftTokenId: string;
+	listingPrice: number;
+	listingNonce: string;
+	itemOwner: string;
+	bidAmount: number;
+	bidder: string;
+	seller: string;
+	sellerKiosk: string;
+	collectionId: string;
+	isListedOnBluemove: boolean;
+	bidMarketName: string;
+	itemTakenOutOfNativeKiosk?: any;
+	royaltyRulePackageId?: string;
+	royaltyRuleModule?: string;
+	shouldSplitRoyaltyFromUserGasCoins?: boolean;
+	multiBidId?: string;
+	beforeResolveKioskTransferRequest?: (coin: any, transferRequest: any) => void | Promise<void>;
+};
+
+export type AcceptCollectionBid = {
+	bidId: string;
+	nftId: string;
+	walletAddress: string;
+};
+
+export type InternalAcceptCollectionBid = {
+	bid: any;
+	nftId: string;
+	walletAddress: string;
+	tx?: Transaction;
+	kioskTx?: KioskTransaction;
+	shouldSplitRoyaltyFromUserGasCoins?: boolean;
+	beforeResolveKioskTransferRequest?: (coin: any, transferRequest: any) => void | Promise<void>;
+};
+
+const ERROR_UNLIST_FIRST =
+	'Item must be unlisted first before you can accept a collection bid with it';
+
+export const acceptCollectionBid = async (
+	{
+		bid,
+		nftId,
+		walletAddress,
+		tx: existingTx,
+		kioskTx,
+		shouldSplitRoyaltyFromUserGasCoins,
+		beforeResolveKioskTransferRequest,
+	}: InternalAcceptCollectionBid,
+	context: RequestContext,
+): Promise<Transaction> => {
+	const nftRes = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchNftById,
+		variables: { nftId },
+	});
+	const nft = nftRes?.nfts?.[0];
+
+	if (!nft) {
+		throw new Error('No nft found');
+	}
+
+	if (DELOREAN_TOKEN_IDS_TO_DISABLE?.includes(nft?.token_id)) {
+		throw new Error(DELOREAN_TOKEN_IDS_TO_DISABLE_MESSAGE);
+	}
+
+	const bidsForTracking = [];
+	const tx = existingTx ?? new Transaction();
+
+	const sharedKioskState: SharedKioskState = {
+		kioskTx: kioskTx ?? undefined,
+	};
+
+	const nftType = getNftType({
+		collectionId: nft?.collection_id,
+		collectionChainState: nft?.collection?.chain_state,
+		nft,
+	});
+
+	const transferPolicies = nft?.collection?.chain_state?.transfer_policies;
+
+	const txData: AcceptCollectionBidTx = {
+		tx,
+		kioskTx,
+		transferPolicies,
+		suiClient: context.suiClient,
+		kioskClient: context.kioskClient,
+		sharedKioskState,
+		bidNonce: bid?.nonce,
+		nftType,
+		nftTokenId: nft?.token_id,
+		itemOwner: nft?.owner,
+		listingPrice: nft?.listings?.[0]?.price,
+		listingNonce: nft?.listings?.[0]?.nonce,
+		bidAmount: bid?.price,
+		bidder: bid?.bidder,
+		seller: walletAddress,
+		sellerKiosk: nft?.chain_state?.kiosk_id,
+		collectionId: nft?.collection_id,
+		isListedOnBluemove: nft?.listings?.[0]?.market_name === 'bluemove',
+		bidMarketName: bid?.market_contract?.name,
+		multiBidId: bid.multi_bid_id,
+		shouldSplitRoyaltyFromUserGasCoins,
+		beforeResolveKioskTransferRequest,
+	};
+
+	switch (txData.bidMarketName) {
+		case 'tradeport':
+			if (txData?.listingPrice && txData?.listingPrice > 0) {
+				throw new Error(ERROR_UNLIST_FIRST);
+			}
+
+			await addTradePortAcceptCollectionBidTxHandler(txData);
+			break;
+		case 'clutchy': {
+			const sharedObjects = await getSharedObjects(txData?.nftType);
+			await addOriginByteAcceptCollectionBidTx({ ...txData, sharedObjects });
+			break;
+		}
+
+		case 'bluemove':
+			if (txData?.listingPrice && txData?.listingPrice > 0 && !txData?.isListedOnBluemove) {
+				throw new Error(ERROR_UNLIST_FIRST);
+			}
+
+			await addBluemoveAcceptCollectionBidTxHandler(txData);
+			break;
+		case 'tocen':
+			if (txData?.listingPrice && txData?.listingPrice > 0) {
+				throw new Error(ERROR_UNLIST_FIRST);
+			}
+
+			addTocenAcceptCollectionBidTxHandler(txData);
+			break;
+		default:
+			throw new Error('Marketplace not supported');
+	}
+
+	bidsForTracking.push({
+		nftType,
+		collectionId: nft?.collection_id,
+		bidAmount: bid?.price,
+		bidMarketName: bid?.market_contract?.name,
+		itemOwner: nft?.owner,
+		bidder: bid?.bidder,
+	});
+
+	sharedKioskState?.kioskTx?.finalize();
+
+	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && bidsForTracking.length > 0) {
+	// 	trackMethodCall({
+	// 		apiUser: context.apiUser,
+	// 		apiKey: context.apiKey,
+	// 		event: 'ACCEPT_COLLECTION_BID',
+	// 		items: bidsForTracking,
+	// 	});
+	// }
+
+	return Transaction.from(tx);
+};