@tradeport/sui-trading-sdk 0.2.1 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tradeport/sui-trading-sdk",
   "license": "MIT",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",

package/src/methods/transferNfts/addTransferNftTx.ts

@@ -1,9 +1,23 @@
+import { type Transaction } from '@mysten/sui/dist/cjs/transactions';
 import { TRADEPORT_KIOSK_TRANSFERS_STORE } from '../../constants';
+import { destroyZeroCoin } from '../../helpers/destroyZeroCoin';
+import { getNftType } from '../../helpers/getNftType';
 import { assertNftInSharedKiosk } from '../../helpers/kiosk/assertNftInSharedKiosk';
 import { getKioskTransferPolicies } from '../../helpers/kiosk/getKioskTransferPolicies';
+import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
 import { getOBKiosk } from '../../helpers/originByte/getOBKiosk';
 import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
 import { type TransferNftTx } from './transferNfts';
+import { type KioskClient } from '@mysten/kiosk';
+
+type CollectionChainState = {
+	transfer_policies: TransferPolicy[];
+};
+type TransferPolicy = {
+	id: string;
+	rules: Array<{ type: string; min_amount?: string }>;
+	is_origin_byte: boolean;
+};
 
 export async function addOriginByteTransferNftTx({
 	tx,
@@ -69,3 +83,97 @@ export async function addTradeportKioskTransferTx({
 		typeArguments: [nftType],
 	});
 }
+
+export async function addTradeportKioskDirectTransferTx(
+	txData: {
+		tx: Transaction;
+		recipientAddress: string;
+		kioskClient: KioskClient;
+		senderAddress: string;
+	},
+	nfts: any[],
+) {
+	const { tx, recipientAddress, kioskClient, senderAddress } = txData;
+	if (nfts.length === 0) {
+		return;
+	}
+
+	const [receiverKiosk, receiverKioskCap] = tx.moveCall({
+		target: '0x2::kiosk::new',
+		arguments: [],
+	});
+	const recipientAddressWithPrefix = addLeadingZerosAfter0x(recipientAddress);
+	tx.moveCall({
+		target: '0x2::kiosk::set_owner_custom',
+		arguments: [
+			tx.object(receiverKiosk),
+			tx.object(receiverKioskCap),
+			tx.pure.address(recipientAddressWithPrefix),
+		],
+	});
+	const totalRoyaltyAmount = nfts.reduce(
+		(sum: bigint, nft) =>
+			sum +
+			BigInt(
+				getTransferPolicyForDirectTransfer(nft.collection.chain_state)?.rules?.find(
+					(rule) => rule.type === 'royalty_rule',
+				)?.min_amount ?? 0n,
+			),
+		0n,
+	);
+	const [royaltyCoin] = 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,
+			async runCommands(kioskTx) {
+				tx.moveCall({
+					target:
+						'0xd0ad5bf7ac7d372cdcfee5273d5e487dabad724040e089c626cba2a01127ccd6::kiosk_transfers::direct_transfer',
+					arguments: [
+						tx.object(kioskTx.getKiosk() as any),
+						tx.object(kioskTx.getKioskCap() as any),
+						tx.object(receiverKiosk),
+						tx.object(receiverKioskCap),
+						tx.pure.id(nft.token_id),
+						tx.object(getTransferPolicyForDirectTransfer(nft.collection.chain_state).id),
+						royaltyCoin,
+					],
+					typeArguments: [nftType],
+				});
+			},
+		});
+	}
+
+	tx.transferObjects([receiverKioskCap], tx.pure.address(recipientAddressWithPrefix));
+	tx.moveCall({
+		target: '0x2::transfer::public_share_object',
+		arguments: [receiverKiosk],
+		typeArguments: ['0x2::kiosk::Kiosk'],
+	});
+	destroyZeroCoin({ tx, coin: royaltyCoin });
+}
+
+export function canBeTransferedDirectly(collectionChainState?: CollectionChainState) {
+	return getTransferPolicyForDirectTransfer(collectionChainState) !== undefined;
+}
+
+export function getTransferPolicyForDirectTransfer(
+	collectionChainState?: CollectionChainState,
+): TransferPolicy | undefined {
+	return collectionChainState?.transfer_policies?.find(
+		(policy) =>
+			!policy.is_origin_byte &&
+			policy.rules?.filter(
+				(rule) => rule.type !== 'kiosk_lock_rule' && rule.type !== 'royalty_rule',
+			).length === 0,
+	);
+}

package/src/methods/transferNfts/transferNfts.ts

@@ -7,14 +7,18 @@ import {
 } from '../../constants';
 import { gqlChainRequest } from '../../graphql/gqlChainRequest';
 import { fetchNftsById } from '../../graphql/queries/fetchNftsById';
-import { addOneDollarFee } from '../../helpers/addOneDollarFee';
 import { getNftType } from '../../helpers/getNftType';
 import { getSharedObjects } from '../../helpers/getSharedObjects';
 import { kioskTxWrapper } from '../../helpers/kiosk/kioskTxWrapper';
 import { isOBKiosk } from '../../helpers/originByte/isOBKiosk';
 import { getAccountBalance } from '../../helpers/rpc/getAcountBalance';
 import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
-import { addOriginByteTransferNftTx, addTradeportKioskTransferTx } from './addTransferNftTx';
+import {
+	addOriginByteTransferNftTx,
+	addTradeportKioskDirectTransferTx,
+	addTradeportKioskTransferTx,
+	canBeTransferedDirectly,
+} from './addTransferNftTx';
 
 export type TransferNftTx = {
 	tx: Transaction;
@@ -67,6 +71,7 @@ export const transferNfts = async (
 	}
 
 	const nftsForTracking = [];
+	const nftsToTransferDirectly = [];
 	const tx = new Transaction();
 
 	for (const nft of res.nfts) {
@@ -116,16 +121,22 @@ export const transferNfts = async (
 		}
 
 		// If NFT is inside native kiosk
-		await kioskTxWrapper({
-			tx: txData?.tx,
-			kioskClient: txData?.kioskClient,
-			kioskOwner: txData?.senderAddress,
-			kiosk: txData?.senderKiosk,
-			shouldAssertNftInSharedKiosk: true,
-			async runCommands(kioskTx) {
-				await addTradeportKioskTransferTx({ ...txData, kioskTx });
-			},
-		});
+
+		// If NFT can be transfered directly by creating new kiosk for receiver
+		if (canBeTransferedDirectly(nft?.collection?.chain_state)) {
+			nftsToTransferDirectly.push(nft);
+		} else {
+			await kioskTxWrapper({
+				tx: txData?.tx,
+				kioskClient: txData?.kioskClient,
+				kioskOwner: txData?.senderAddress,
+				kiosk: txData?.senderKiosk,
+				shouldAssertNftInSharedKiosk: true,
+				async runCommands(kioskTx) {
+					await addTradeportKioskTransferTx({ ...txData, kioskTx });
+				},
+			});
+		}
 
 		nftsForTracking.push({
 			nftType,
@@ -134,9 +145,15 @@ export const transferNfts = async (
 		});
 	}
 
-	if (res?.nfts?.length > 1) {
-		await addOneDollarFee(tx);
-	}
+	await addTradeportKioskDirectTransferTx(
+		{ tx, kioskClient: context.kioskClient, senderAddress: walletAddress, recipientAddress },
+		nftsToTransferDirectly,
+	);
+
+	// currently turned off $1 bulk transfer fee
+	// if (res?.nfts?.length > 1) {
+	// 	await addOneDollarFee(tx);
+	// }
 
 	// if (process.env.ENABLE_SEGMENT_TRACKING === 'true' && nftsForTracking.length > 0) {
 	// 	trackMethodCall({