@tradeport/sui-trading-sdk 0.0.0

package/src/helpers/kiosk/resolveTransferPolicies.ts

@@ -0,0 +1,150 @@
+import { getNormalizedRuleType, type ObjectArgument } from '@mysten/kiosk';
+import { type TransactionBlock, type TransactionObjectArgument } from '@mysten/sui.js/transactions';
+import kioskClient from '../../apiClients/kioskClient';
+import { resolveFloorPriceRule } from './resolveFloorPriceRule';
+import { resolveKioskLockRule } from './resolveKioskLockRule';
+import { resolvePersonalKioskRule } from './resolvePersonalKioskRule';
+import { resolveRoyaltyRule } from './resolveRoyaltyRule';
+
+export type Policy = {
+	data: any;
+	transferRequest: TransactionObjectArgument;
+	isCustom: boolean;
+	type?: string;
+};
+
+type Props = {
+	txBlock: TransactionBlock;
+	kioskTx: any;
+	nftType: string;
+	kioskToLockRuleProve?: ObjectArgument;
+	kioskItem?: ObjectArgument;
+	transferRequest: TransactionObjectArgument;
+	customTransferPolicies?: any;
+	price?: string;
+	priceObjectArgument?: ObjectArgument;
+	shouldSkipKioskLocking?: boolean;
+	shouldSkipResolvingRoyaltyRule?: boolean;
+};
+
+export const resolveTransferPolicies = async ({
+	txBlock,
+	kioskTx,
+	nftType,
+	kioskToLockRuleProve,
+	kioskItem,
+	transferRequest,
+	customTransferPolicies,
+	price,
+	priceObjectArgument,
+	shouldSkipKioskLocking,
+	shouldSkipResolvingRoyaltyRule,
+}: Props) => {
+	const transferPolicies = await kioskClient.getTransferPolicies({
+		type: nftType,
+	});
+
+	let policies: Policy[] =
+		transferPolicies.length > 0
+			? [
+					{
+						data: transferPolicies[0],
+						transferRequest,
+						isCustom: false,
+					},
+			  ]
+			: [];
+
+	if (customTransferPolicies) {
+		for (const customTransferPolicy of customTransferPolicies) {
+			const customPolicy = await kioskClient.getTransferPolicies({
+				type: customTransferPolicy?.type,
+			});
+			policies = [
+				...policies,
+				{
+					data: customPolicy[0],
+					transferRequest: customTransferPolicy?.transferRequest,
+					isCustom: true,
+					type: customTransferPolicy?.type,
+				},
+			];
+		}
+	}
+
+	let canTransferOutsideKiosk = true;
+
+	for (const policy of policies) {
+		for (const rule of policy.data.rules) {
+			const ruleDefinition = kioskClient.rules.find(
+				(x) => getNormalizedRuleType(x.rule) === getNormalizedRuleType(rule),
+			);
+
+			let rulePackageId = ruleDefinition?.packageId;
+			if (!rulePackageId) {
+				rulePackageId = rule?.split('::')?.[0];
+			}
+
+			switch (rule?.split('::')?.[1]) {
+				case 'royalty_rule':
+				case 'kiosk_royalty_rule':
+					if (shouldSkipResolvingRoyaltyRule) break;
+					resolveRoyaltyRule({
+						txBlock,
+						packageId: rulePackageId,
+						moduleName: rule?.split('::')?.[1],
+						policyId: policy.data.id,
+						transferRequest: policy.transferRequest,
+						nftType: policy.isCustom && policy.type ? policy.type : nftType,
+						price,
+						priceObjectArgument,
+					});
+					break;
+				case 'kiosk_lock_rule':
+					canTransferOutsideKiosk = false;
+					resolveKioskLockRule({
+						txBlock,
+						packageId: rulePackageId,
+						policyId: policy.data.id,
+						transferRequest: policy.transferRequest,
+						nftType: policy.isCustom && policy.type ? policy.type : nftType,
+						kiosk: kioskToLockRuleProve ? kioskToLockRuleProve : kioskTx.kiosk,
+						kioskCap: kioskTx.kioskCap,
+						kioskItem,
+						shouldSkipLocking: shouldSkipKioskLocking,
+					});
+					break;
+				case 'personal_kiosk_rule':
+					resolvePersonalKioskRule({
+						txBlock,
+						packageId: rulePackageId,
+						nftType: policy.isCustom && policy.type ? policy.type : nftType,
+						kiosk: kioskTx.kiosk,
+						transferRequest: policy.transferRequest,
+					});
+					break;
+				case 'floor_price_rule':
+					resolveFloorPriceRule({
+						txBlock,
+						packageId: rulePackageId,
+						nftType: policy.isCustom && policy.type ? policy.type : nftType,
+						policyId: policy.data.id,
+						transferRequest: policy.transferRequest,
+					});
+					break;
+				default:
+					throw new Error(`No resolver for the following rule: ${rule}.`);
+			}
+		}
+
+		txBlock.moveCall({
+			target: '0x2::transfer_policy::confirm_request',
+			arguments: [txBlock.object(policy.data.id), policy.transferRequest],
+			typeArguments: [policy.isCustom && policy.type ? policy.type : nftType],
+		});
+	}
+
+	if (canTransferOutsideKiosk && kioskItem) {
+		kioskTx.place({ itemType: nftType, item: kioskItem });
+	}
+};

package/src/helpers/originByte/confirmOBTranfer.ts

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

package/src/helpers/originByte/createOBKiosk.ts

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

package/src/helpers/originByte/depositNftIntoOBKiosk.ts

@@ -0,0 +1,14 @@
+type Args = {
+	txBlock: any;
+	kiosk: string;
+	nftTokenId: string;
+	nftType: string;
+};
+
+export const depositItemIntoOBKiosk = ({ txBlock, kiosk, nftTokenId, nftType }: Args) => {
+	txBlock.moveCall({
+		target: '0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::deposit',
+		arguments: [txBlock.object(kiosk), txBlock.pure(nftTokenId)],
+		typeArguments: [nftType],
+	});
+};

package/src/helpers/originByte/getOBBidderKiosk.ts

@@ -0,0 +1,9 @@
+import suiClient from '../../apiClients/suiClient';
+
+export const getOBBidderKiosk = async (bidNonce: string) => {
+	const bidObject = (await suiClient.call('sui_getObject', [
+		bidNonce,
+		{ showContent: true },
+	])) as any;
+	return bidObject.data?.content?.fields?.kiosk;
+};

package/src/helpers/originByte/getOBKiosk.ts

@@ -0,0 +1,24 @@
+import { gql } from 'graphql-request';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+
+const fetchAccountKiosks = gql`
+	query fetchAccountKiosks($accountAddress: String!) {
+		kiosks: kiosks_by_owner_address(owner_address: $accountAddress) {
+			id
+			is_origin_byte
+			owner_address
+			profits
+		}
+	}
+`;
+
+export const getOBKiosk = async (accountAddress: string): Promise<any> => {
+	const res = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchAccountKiosks,
+		variables: { accountAddress: addLeadingZerosAfter0x(accountAddress) },
+	});
+
+	return res?.kiosks?.filter((kiosk: any) => kiosk?.is_origin_byte)?.[0]?.id;
+};

package/src/helpers/originByte/getOrCreateOBKiosk.ts

@@ -0,0 +1,37 @@
+import { createOBKiosk } from './createOBKiosk';
+import { getOBKiosk } from './getOBKiosk';
+
+type Args = {
+	txBlock: any;
+	address: string;
+	kioskToUseIfExists?: string;
+	createMethod?: string;
+};
+
+export const getOrCreateOBKiosk = async ({
+	txBlock,
+	address,
+	kioskToUseIfExists,
+	createMethod,
+}: Args) => {
+	if (kioskToUseIfExists) {
+		return {
+			kiosk: kioskToUseIfExists,
+			isNewKiosk: false,
+		};
+	}
+
+	const existingKiosk = await getOBKiosk(address);
+	if (existingKiosk) {
+		return {
+			kiosk: existingKiosk,
+			isNewKiosk: false,
+		};
+	}
+
+	const [newKiosk] = await createOBKiosk({ txBlock, 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,6 @@
+import { ORIGIN_BYTE_BID_NONCE_TYPE } from '../../constants';
+
+export const isOriginByteBid = (bidType: string): boolean =>
+	bidType === ORIGIN_BYTE_BID_NONCE_TYPE ||
+	bidType === '0x2::Kiosk::Kiosk' ||
+	bidType === '0x2::kiosk::Kiosk';

package/src/helpers/originByte/isOriginByteTx.ts

@@ -0,0 +1,2 @@
+export const isOriginByteTx = (sharedObjects: any): boolean =>
+	Boolean(sharedObjects?.orderbook && sharedObjects?.collection);

package/src/helpers/originByte/shareOriginByteKiosk.ts

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

package/src/helpers/rpc/getAcountBalance.ts

@@ -0,0 +1,17 @@
+import suiClient from '../../apiClients/suiClient';
+import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
+
+type Args = {
+	owner: string;
+};
+
+export const getAccountBalance = async ({ owner }: Args): Promise<string> => {
+	try {
+		const res = await suiClient.getBalance({
+			owner: addLeadingZerosAfter0x(owner),
+		});
+		return res?.totalBalance;
+	} catch (err) {
+		return '';
+	}
+};

package/src/helpers/rpc/getObjectType.ts

@@ -0,0 +1,10 @@
+import suiClient from '../../apiClients/suiClient';
+
+export const getObjectType = async (objectId: string): Promise<string> => {
+	try {
+		const res = await suiClient.getObject({ id: objectId, options: { showType: true } });
+		return res?.data?.type;
+	} catch (err) {
+		return '';
+	}
+};

package/src/helpers/splitCoins.ts

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

package/src/index.ts

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

package/src/methods/acceptCollectionBid/acceptCollectionBid.ts

@@ -0,0 +1,119 @@
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchNftById } from '../../graphql/queries/fetchNftsById';
+import { getNftTypeFromNft } from '../../helpers/getNftTypeFromNft';
+import { getSharedObjects } from '../../helpers/getSharedObjects';
+import {
+	addBluemoveAcceptCollectionBidTxHandler,
+	addOriginByteAcceptCollectionBidTx,
+	addTocenAcceptCollectionBidTxHandler,
+	addTradePortAcceptCollectionBidTxHandler,
+} from './addAcceptCollectionBIdTxs';
+
+export type AcceptCollectionBidTx = {
+	txBlock: TransactionBlock;
+	sharedObjects: any;
+	kioskTx?: any;
+	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;
+};
+
+export type AcceptCollectionBid = {
+	bidId: string;
+	nftId: string;
+	walletAddress: string;
+};
+
+export type InternalAcceptCollectionBid = {
+	bid: any;
+	nftId: string;
+	walletAddress: string;
+};
+
+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,
+}: InternalAcceptCollectionBid): Promise<TransactionBlock> => {
+	const nftRes = await gqlChainRequest({
+		chain: 'sui',
+		query: fetchNftById,
+		variables: { nftId },
+	});
+	const nft = nftRes?.nfts?.[0];
+
+	if (!nft) {
+		throw new Error('No nft found');
+	}
+
+	const txBlock = new TransactionBlock();
+
+	const sharedObjects = await getSharedObjects(
+		nft?.properties?.nft_type || nft?.contract?.properties?.nft_type,
+	);
+
+	const txData: AcceptCollectionBidTx = {
+		txBlock,
+		sharedObjects,
+		bidNonce: bid?.nonce,
+		nftType: getNftTypeFromNft(nft),
+		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,
+	};
+
+	switch (txData.bidMarketName) {
+		case 'tradeport':
+			if (txData?.listingPrice && txData?.listingPrice > 0) {
+				throw new Error(ERROR_UNLIST_FIRST);
+			}
+
+			await addTradePortAcceptCollectionBidTxHandler(txData);
+			break;
+		case 'clutchy':
+			await addOriginByteAcceptCollectionBidTx(txData);
+			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');
+	}
+
+	return new TransactionBlock(txBlock);
+};