@tradeport/sui-trading-sdk 0.4.62 → 0.4.64

package/src/methods/sponsorNftListing/addSponsorNftListingTx.ts

@@ -1,58 +1,30 @@
-import type { Transaction } from '@mysten/sui/transactions';
-import { USDC_COIN_TYPE } from '../../constants';
-import type { SuiClient } from '@mysten/sui/client';
-import { TRADEPORT_LISTINGS_PACKAGE, TRADEPORT_LISTINGS_STORE } from '../../constants';
-import { type SponsorNftListingOptions } from './sponsorNftListing';
+import { coinWithBalance, type Transaction } from '@mysten/sui/transactions';
 import BigNumber from '../../bigNumberConfig';
-import { calculateSwapInputAmountWithSlippage, swapCoins } from '../swapCoins/swapCoins';
+import {
+	TRADEPORT_LISTINGS_PACKAGE,
+	TRADEPORT_LISTINGS_STORE,
+	USDC_COIN_TYPE,
+} from '../../constants';
+import { type SponsorNftListingOptions } from './sponsorNftListing';
 
 export const addSponsorListingTx = async ({
 	tx,
 	nftTokenId,
 	nftType,
-	suiClient,
-	walletAddress,
 	sponsorOptions,
-	defiRouterUrl,
 }: {
 	tx: Transaction;
 	nftTokenId: string;
 	nftType: string;
-	suiClient: SuiClient;
-	walletAddress: string;
 	sponsorOptions: SponsorNftListingOptions;
-	defiRouterUrl: string;
 }) => {
-	const coinInAmount =
-		sponsorOptions?.coinInAmount ??
-		(await calculateSwapInputAmountWithSlippage({
-			coinInType: sponsorOptions?.coinInType,
-			coinOutType: USDC_COIN_TYPE,
-			coinOutAmount: new BigNumber(sponsorOptions?.usdcFeeAmountPerPeriod)
-				?.times(sponsorOptions?.numOfPeriods)
-				.toString(),
-			slippage: sponsorOptions?.slippage,
-		}));
+	const totalFee = new BigNumber(sponsorOptions?.usdcFeeAmountPerPeriod)
+		?.times(sponsorOptions?.numOfPeriods)
+		.toString();
 
-	const { coinOut } = await swapCoins(
-		{
-			walletAddress,
-			coinInType: sponsorOptions?.coinInType,
-			coinInAmount: coinInAmount.toString(),
-			coinOutType: USDC_COIN_TYPE,
-			slippage: sponsorOptions?.slippage,
-			tx,
-		},
-		{ suiClient, defiRouterUrl },
-	);
-
-	const [sponsorFeeCoin] = tx.splitCoins(coinOut, [
-		tx.pure.u64(
-			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`,
@@ -61,10 +33,8 @@ export const addSponsorListingTx = async ({
 			tx.object.clock(),
 			tx.pure.id(nftTokenId),
 			tx.pure.u64(sponsorOptions?.numOfPeriods),
-			tx.object(sponsorFeeCoin),
+			tx.object(sponsorCoin),
 		],
 		typeArguments: [nftType],
 	});
-
-	tx.transferObjects([coinOut], walletAddress);
 };

package/src/methods/sponsorNftListing/sponsorNftListing.ts

@@ -1,30 +1,28 @@
 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 type { RequestContext } from '../../SuiTradingClient';
 import { addSponsorListingTx } from './addSponsorNftListingTx';
-import { getNftType } from '../../helpers/getNftType';
 
 export type SponsorNftListingOptions = {
 	shouldSponsor?: boolean;
 	numOfPeriods?: number;
-	slippage?: number;
-	coinInType?: string;
-	coinInAmount?: string;
 	usdcFeeAmountPerPeriod?: number;
+	coinToSplit?: any;
 };
 
 export type SponsorNftListing = {
+	tx?: Transaction;
 	nftTokenId: string;
-	walletAddress: string;
 	options: SponsorNftListingOptions;
 };
 
-export const sponsorNftListing = async (
-	{ nftTokenId, walletAddress, options }: SponsorNftListing,
-	context: RequestContext,
-): Promise<Transaction> => {
+export const sponsorNftListing = async ({
+	tx: existingTx,
+	nftTokenId,
+	options,
+}: SponsorNftListing): Promise<Transaction> => {
 	const res = await gqlChainRequest({
 		chain: 'sui',
 		query: fetchNftCollectionChainState,
@@ -49,17 +47,14 @@ export const sponsorNftListing = async (
 		throw new Error(`You cannot sponsor an Origin Byte NFT. Nft Token Id: ${nftTokenId}`);
 	}
 
-	const tx = new Transaction();
+	const tx = existingTx ?? new Transaction();
 
 	await addSponsorListingTx({
 		tx,
-		suiClient: context.suiClient,
 		nftTokenId,
 		nftType,
-		walletAddress,
 		sponsorOptions: options,
-		defiRouterUrl: context.defiRouterUrl,
 	});
 
-	return tx instanceof Transaction ? tx : Transaction.from(tx);
+	return tx;
 };

package/src/methods/updateMultiBid/updateMultiBid.ts

@@ -1,9 +1,8 @@
-import { type Transaction } from '@mysten/sui/transactions';
+import { Transaction } from '@mysten/sui/transactions';
 import { TRADEPORT_MULTI_BID_PACKAGE, TRADEPORT_MULTI_BID_STORE } from '../../constants';
 import { gqlChainRequest } from '../../graphql/gqlChainRequest';
 import { fetchMultibidChainIdById } from '../../graphql/queries/fetchMultibidById';
-import { deserializeOrCreateTxBlock } from '../../helpers/deserializeOrCreateTxBlock';
-import { extractSwapResultCoinFromTxBlock } from '../../helpers/extractSwapResultCoin';
+import { type RequestContext } from '../../SuiTradingClient';
 
 export interface UpdateMultiBid {
 	walletAddress: string;
@@ -11,20 +10,25 @@ export interface UpdateMultiBid {
 	name?: string;
 	amount?: bigint;
 	amountToWithdraw?: bigint;
-	tx?: Transaction | string;
+	tx?: Transaction;
 	multiBidChainId?: any;
+	coinToSplit?: any;
 }
 
-export async function updateMultiBid({
-	multiBidId,
-	name,
-	amount,
-	amountToWithdraw,
-	tx: existingTx,
-	multiBidChainId,
-}: UpdateMultiBid): Promise<Transaction> {
-	const tx = deserializeOrCreateTxBlock({ existingTx });
-	const swapResultCoin = extractSwapResultCoinFromTxBlock(tx);
+export async function updateMultiBid(
+	{
+		walletAddress,
+		multiBidId,
+		name,
+		amount,
+		amountToWithdraw,
+		tx: existingTx,
+		multiBidChainId,
+		coinToSplit,
+	}: UpdateMultiBid,
+	context?: Pick<RequestContext, 'suiClient' | 'tradeportRouterUrl'>,
+): Promise<Transaction> {
+	const tx = existingTx ?? new Transaction();
 
 	if (!multiBidChainId) {
 		const { chain_id: chainId, cancelled_at } =
@@ -46,7 +50,7 @@ export async function updateMultiBid({
 		multiBidChainId = chainId;
 	}
 
-	const [coin] = tx.splitCoins(swapResultCoin ? swapResultCoin : tx.gas, [amount ?? 0n]);
+	const [coin] = tx.splitCoins(coinToSplit ? coinToSplit : tx.gas, [amount ?? 0n]);
 	tx.moveCall({
 		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::update_multi_bid`,
 		arguments: [

package/src/utils/addLeadingZerosAfter0x.ts

@@ -1,2 +1,9 @@
 export const addLeadingZerosAfter0x = (str: string): string =>
 	`0x${str?.replace('0x', '').padStart(64, '0')}`;
+
+export const addLeadingZerosToPackage = (str: string, skip0x?: boolean) => {
+	const address = str?.split('::')[0];
+	const suffix = `::${str?.split('::').slice(1).join('::')}`;
+
+	return `${skip0x ? '' : '0x'}${address?.replace('0x', '').padStart(64, '0')}${suffix}`;
+};

package/.claude/settings.local.json

@@ -1,5 +0,0 @@
-{
-	"permissions": {
-		"allow": ["Bash(xxd:*)", "Bash(pnpm tsc:*)", "Bash(npx tsc:*)"]
-	}
-}

package/src/helpers/deserializeOrCreateTxBlock.ts

@@ -1,13 +0,0 @@
-import { Transaction } from '@mysten/sui/transactions';
-
-export const deserializeOrCreateTxBlock = ({
-	existingTx,
-}: {
-	existingTx: Transaction | string;
-}) => {
-	if (typeof existingTx === 'string') {
-		return Transaction.from(existingTx);
-	}
-
-	return existingTx ?? new Transaction();
-};

package/src/helpers/extractSwapResultCoin.ts

@@ -1,17 +0,0 @@
-import { type Transaction } from '@mysten/sui/transactions';
-
-export const extractSwapResultCoinFromTxBlock = (txBlock: Transaction | string) => {
-	if (!txBlock) return undefined;
-
-	const tx = typeof txBlock === 'string' ? JSON.parse(txBlock) : txBlock?.getData();
-	const commands = tx.commands ?? [];
-
-	const index = commands.findIndex(
-		(cmd: any) =>
-			cmd?.MoveCall?.module === 'universal_router' && cmd?.MoveCall?.function === 'settle',
-	);
-
-	if (index === -1) return undefined;
-
-	return { $kind: 'Result', Result: index };
-};

package/src/methods/swapCoins/swapCoins.ts

@@ -1,400 +0,0 @@
-import {
-	AggregatorQuoter,
-	type Coin,
-	CoinProvider,
-	type Commission,
-	type GetRoutesResult,
-	Protocol,
-	type Route,
-	TradeBuilder,
-} from '@flowx-finance/sdk';
-import BigNumber from '../../bigNumberConfig';
-import { coinWithBalance, Transaction, type TransactionResult } from '@mysten/sui/transactions';
-import { normalizeStructTag, normalizeSuiAddress, SUI_TYPE_ARG } from '@mysten/sui/utils';
-import ms, { type StringValue } from 'ms';
-import { type RequestContext } from '../../SuiTradingClient';
-import {
-	DexConstants,
-	TRADEPORT_NFT_STRATEGY_MANAGER_ID,
-	TRADEPORT_NFT_STRATEGY_PACKAGE_ID,
-} from '../../constants';
-import { getCollectionChainStateByFtType } from '../../helpers/getCollectionChainState';
-import { toDecimalValue, toPureValue } from '../../utils/pureValues';
-
-export type SwapCoins = {
-	walletAddress: string;
-	coinInType: string;
-	coinInAmount: string;
-	coinOutType: string;
-	slippage?: number;
-	ttl?: StringValue;
-	excludeSources?: Protocol[];
-	routes?: Array<Route<Coin, Coin>>;
-	commission?: Commission;
-	tx?: Transaction;
-};
-
-export type SwapRoutesArgs = {
-	walletAddress: string;
-	coinInType: string;
-	coinOutType: string;
-	amountToSwap: bigint;
-	excludeSources?: Protocol[];
-	commission?: Commission;
-};
-
-export async function swapCoins(
-	{
-		walletAddress,
-		coinInType,
-		coinInAmount,
-		coinOutType,
-		slippage = 1000, // 0.1%
-		ttl = '5m',
-		excludeSources = [Protocol.STEAMM, Protocol.BOLT],
-		routes,
-		commission,
-		tx: existingTx,
-	}: SwapCoins,
-	{ suiClient, defiRouterUrl }: Pick<RequestContext, 'suiClient' | 'defiRouterUrl'>,
-): Promise<{
-	tx: Transaction;
-	coinOut: TransactionResult;
-}> {
-	const inAmount = BigInt(coinInAmount);
-	const tx = existingTx ?? new Transaction();
-	coinInType = normalizeStructTag(coinInType);
-	coinOutType = normalizeStructTag(coinOutType);
-	walletAddress = normalizeSuiAddress(walletAddress);
-	tx.setSenderIfNotSet(normalizeSuiAddress(walletAddress));
-
-	// Zero input amount, return zero output amount
-	if (inAmount === 0n) {
-		const zeroCoin = tx.moveCall({
-			target: '0x2::coin::zero',
-			typeArguments: [coinOutType],
-		});
-		return {
-			tx,
-			coinOut: zeroCoin,
-		};
-	}
-
-	// Input Coin and Out Coin are the same, no need to swap
-	if (coinInType === coinOutType) {
-		const getCoin = coinWithBalance({
-			type: coinInType,
-			balance: inAmount,
-		});
-		return {
-			tx,
-			coinOut: getCoin(tx),
-		};
-	}
-
-	const types = await getAffectedNftAndFtTypes(coinInType, coinOutType);
-	const { feeAndReward, amountToSwap } = calculateSwapAmounts(types.length, inAmount);
-
-	if (!routes) {
-		routes = (
-			await buildSwapRoutes(
-				{
-					walletAddress,
-					coinInType,
-					coinOutType,
-
-					amountToSwap,
-					excludeSources,
-					commission,
-				},
-				{ defiRouterUrl },
-			)
-		).routes;
-	}
-
-	const tradeBuilder = new TradeBuilder('mainnet', routes);
-	if (commission) {
-		tradeBuilder.commission(commission);
-	}
-
-	const trade = tradeBuilder
-		.sender(walletAddress)
-		.slippage(slippage)
-		.deadline(Date.now() + ms(ttl))
-		.build();
-
-	const coinOut = (await trade.swap({ client: suiClient, tx })) as TransactionResult;
-
-	let suiFeeAndRewardCoin: TransactionResult;
-	if (coinInType === normalizeStructTag(SUI_TYPE_ARG)) {
-		suiFeeAndRewardCoin = tx.splitCoins(tx.gas, [
-			tx.pure.u64(feeAndReward),
-		])[0] as unknown as TransactionResult;
-	} else {
-		// Swap to SUI for fee and reward
-		const suiFeeAndRewardRoutes = await buildSwapRoutes(
-			{
-				walletAddress,
-				coinInType,
-				coinOutType: SUI_TYPE_ARG,
-				amountToSwap: feeAndReward,
-				excludeSources,
-			},
-			{ defiRouterUrl },
-		);
-		const suiFeeTradeBuilder = new TradeBuilder('mainnet', suiFeeAndRewardRoutes.routes);
-		const suiFeeTrade = suiFeeTradeBuilder
-			.sender(walletAddress)
-			.slippage(slippage)
-			.deadline(Date.now() + ms(ttl))
-			.build();
-		suiFeeAndRewardCoin = (await suiFeeTrade.swap({ client: suiClient, tx })) as TransactionResult;
-	}
-
-	if (types.length > 0) {
-		if (types.length > 2) {
-			throw new Error('Unexpected affected types count greater than 2');
-		}
-
-		let usedSuiCoin = suiFeeAndRewardCoin;
-		if (types.length === 2) {
-			const suiFeeAndRewardCoinBalance = tx.moveCall({
-				target: '0x2::coin::value',
-				typeArguments: [SUI_TYPE_ARG],
-				arguments: [suiFeeAndRewardCoin],
-			});
-			const halfSuiCoinAmount = tx.moveCall({
-				target: '0x2::math::divide_and_round_up',
-				arguments: [suiFeeAndRewardCoinBalance, tx.pure.u64(2)],
-			});
-			const [coin] = tx.splitCoins(usedSuiCoin, [halfSuiCoinAmount]);
-			usedSuiCoin = coin as unknown as TransactionResult; // 1/2 of SUI for 1st iteration, remaining SUI for 2nd iteration
-		}
-
-		for (const data of types) {
-			// max 2 iterations
-			const { nftType, ftType, type } = data;
-			switch (type) {
-				case 'liquidNft': {
-					// Pay 4% fee + reward for liquid nft, the contract will split this balance itself
-					tx.moveCall({
-						target: `${DexConstants.commission}::commission::pay`,
-						arguments: [
-							tx.object(DexConstants.commissionManager),
-							tx.pure.string('swap'),
-							usedSuiCoin,
-							tx.pure.option('string', nftType),
-						],
-						typeArguments: [SUI_TYPE_ARG],
-					});
-					break;
-				}
-
-				case 'nftStrategy': {
-					// Pay 1% fee + 3% reward for nft strategy
-					const suiFeeAndRewardCoinBalance = tx.moveCall({
-						target: '0x2::coin::value',
-						typeArguments: [SUI_TYPE_ARG],
-						arguments: [usedSuiCoin],
-					});
-					const feeAmount = tx.moveCall({
-						target: '0x2::math::divide_and_round_up',
-						arguments: [suiFeeAndRewardCoinBalance, tx.pure.u64(4)],
-					});
-					const [feeCoin] = tx.splitCoins(usedSuiCoin, [feeAmount]);
-					tx.moveCall({
-						target: `${DexConstants.commission}::commission::pay`,
-						arguments: [
-							tx.object(DexConstants.commissionManager),
-							tx.pure.string('swap'),
-							feeCoin,
-							tx.pure.option('string', undefined),
-						],
-						typeArguments: [SUI_TYPE_ARG],
-					});
-					tx.moveCall({
-						target: `${TRADEPORT_NFT_STRATEGY_PACKAGE_ID}::tradeport_nft_strategy::reward_strategy`,
-						arguments: [
-							tx.object(TRADEPORT_NFT_STRATEGY_MANAGER_ID),
-							usedSuiCoin, //  3/4 retained coin for reward
-						],
-						typeArguments: [nftType, ftType],
-					});
-					break;
-				}
-
-				default: {
-					throw new Error(`Unexpected type ${type as string}`);
-				}
-			}
-
-			usedSuiCoin = suiFeeAndRewardCoin; // remaining SUI after 1st iteration
-		}
-	} else {
-		// Default, get 1% fee
-		tx.moveCall({
-			target: `${DexConstants.commission}::commission::pay`,
-			arguments: [
-				tx.object(DexConstants.commissionManager),
-				tx.pure.string('swap'),
-				suiFeeAndRewardCoin,
-				tx.pure.option('string', undefined),
-			],
-			typeArguments: [SUI_TYPE_ARG],
-		});
-	}
-
-	return {
-		tx,
-		coinOut,
-	};
-}
-
-export async function calculateAmountToSwap({
-	coinInType,
-	coinOutType,
-	coinInAmount,
-}: Pick<SwapCoins, 'coinInType' | 'coinOutType' | 'coinInAmount'>): Promise<bigint> {
-	const types = await getAffectedNftAndFtTypes(coinInType, coinOutType);
-	const { amountToSwap } = calculateSwapAmounts(types.length, BigInt(coinInAmount));
-	return amountToSwap;
-}
-
-export async function calculateSwapInputAmountWithSlippage({
-	coinInType,
-	coinOutType,
-	coinOutAmount,
-	slippage = 0,
-}: {
-	coinInType: string;
-	coinOutType: string;
-	coinOutAmount: string | number;
-	slippage?: number;
-}): Promise<BigNumber> {
-	if (coinInType === coinOutType) {
-		return new BigNumber(coinOutAmount);
-	}
-
-	const provider = new CoinProvider('mainnet');
-
-	const coinQueryResult = await provider.getCoins({
-		limit: 2,
-		coinTypes: [coinInType, coinOutType],
-	});
-
-	const coinIn = coinQueryResult?.find(
-		(coin) => normalizeStructTag(coin.coinType) === normalizeStructTag(coinInType),
-	);
-	const coinOut = coinQueryResult?.find(
-		(coin) => normalizeStructTag(coin.coinType) === normalizeStructTag(coinOutType),
-	);
-
-	const exchangeRate = new BigNumber(coinOut.derivedPriceInUSD ?? 0)?.gt(0)
-		? new BigNumber(coinIn?.derivedPriceInUSD ?? 1)?.div(coinOut?.derivedPriceInUSD ?? 1)
-		: new BigNumber(0);
-
-	const amountSell = toDecimalValue(coinOutAmount.toString(), coinOut?.decimals).div(exchangeRate);
-
-	const slippageMultiplier = 1 + parseInt(slippage.toString() || '0', 10) / 1000000;
-
-	const amountWithSlippage = amountSell.times(slippageMultiplier);
-
-	const coinInAmount = toPureValue(amountWithSlippage, coinIn?.decimals);
-
-	return coinInAmount;
-}
-
-export async function buildSwapRoutes(
-	options: SwapRoutesArgs,
-	{ defiRouterUrl }: { defiRouterUrl?: string },
-): Promise<GetRoutesResult<Coin, Coin>> {
-	const aggregatorQuoter = new AggregatorQuoter('mainnet');
-	const routes = await aggregatorQuoter.getRoutes({
-		tokenIn: options.coinInType,
-		tokenOut: options.coinOutType,
-		amountIn: options.amountToSwap.toString(),
-		commission: options.commission,
-		excludeSources: options.excludeSources,
-	});
-
-	if (defiRouterUrl && options.walletAddress) {
-		await makeDefiRouterRequest(`${defiRouterUrl}/start`, {
-			walletId: options.walletAddress,
-			coinTypeIn: options.coinInType,
-			coinTypeOut: options.coinOutType,
-			amountIn: options.amountToSwap.toString(),
-		});
-	}
-
-	return routes;
-}
-
-function calculateSwapAmounts(
-	affectedTypesCount: number,
-	inAmount: bigint,
-): { feeAndReward: bigint; amountToSwap: bigint } {
-	// 4% (or 8%) fee and reward budget or 1% fee if neither nft strategy, nor liquid nft involved
-	const feeAndReward =
-		affectedTypesCount > 0 ? (BigInt(affectedTypesCount) * inAmount) / 25n : inAmount / 100n;
-	const amountToSwap = inAmount - feeAndReward; // amount after deducting fee and reward budget
-
-	if (amountToSwap <= 0n) {
-		throw new Error('Amount to swap is too small');
-	}
-
-	return { feeAndReward, amountToSwap };
-}
-
-async function getAffectedNftAndFtTypes(
-	coinInType: string,
-	coinOutType: string,
-): Promise<Array<{ nftType: string; ftType: string; type: 'liquidNft' | 'nftStrategy' }>> {
-	const normalizedSuiType = normalizeStructTag(SUI_TYPE_ARG);
-	const coinTypes = [coinInType, coinOutType].filter((type) => type !== normalizedSuiType);
-	const types = await Promise.all(
-		coinTypes.map(async (type) => {
-			const chainState = await getCollectionChainStateByFtType(type);
-			return chainState
-				? {
-						nftType: chainState.nft_type as string,
-						ftType: type,
-						type: chainState.ft_type ? 'liquidNft' : 'nftStrategy',
-					}
-				: undefined;
-		}),
-	);
-
-	return types.filter(Boolean) as Array<{
-		nftType: string;
-		ftType: string;
-		type: 'liquidNft' | 'nftStrategy';
-	}>;
-}
-
-async function makeDefiRouterRequest(
-	url: string,
-	body: Record<string, unknown>,
-	defaultResponse: unknown = undefined,
-): Promise<unknown> {
-	try {
-		const response = await fetch(url, {
-			method: 'POST',
-			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify(body),
-		});
-
-		if (!response.ok) {
-			console.warn(`DeFi router request failed with status ${response.status}`);
-			return defaultResponse;
-		}
-
-		if (response.headers.get('Content-Type')?.includes('application/json')) {
-			return await response.json();
-		}
-
-		return defaultResponse;
-	} catch (error) {
-		console.warn(`DeFi router request error: ${(error as Error).message}`);
-		return defaultResponse;
-	}
-}