@tradeport/sui-trading-sdk 0.3.8 → 0.4.0

package/src/methods/placeNftBids/addPlaceNftBidTxs.ts

@@ -1,263 +1,133 @@
 import {
 	ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK,
-	TRADEPORT_BENEFICIARY_ADDRESS,
-	TRADEPORT_BIDDING_STORE,
-	TRADEPORT_KIOSK_BIDDING_STORE,
+	TRADEPORT_MULTI_BID_PACKAGE,
+	TRADEPORT_MULTI_BID_STORE,
+	DYNAMIC_COLLECTION_IDS,
 } from '../../constants';
-import { destroyZeroCoin } from '../../helpers/destroyZeroCoin';
-import { getMarketFeePrice } from '../../helpers/getMarketFeePrice';
-import { getRoyaltyRuleModule } from '../../helpers/getRoyaltyRuleModule';
-import { getTradeportBiddingContractBidAmount } from '../../helpers/getTradeportBiddingContractBidAmount';
-import { hasTransferPolicyRules } from '../../helpers/hasTransferPolicyRules';
-import { getKioskPlaceBidCoin } from '../../helpers/kiosk/getKioskPlaceBidCoin';
 import { getKioskTransferPolicies } from '../../helpers/kiosk/getKioskTransferPolicies';
-import { getRulePackageId } from '../../helpers/kiosk/getRulePackageId';
-import { getOrCreateOBKiosk } from '../../helpers/originByte/getOrCreateOBKiosk';
-import { isOriginByteTx } from '../../helpers/originByte/isOriginByteTx';
-import { splitCoins } from '../../helpers/splitCoins';
 import { normalizedNftType } from '../../utils/normalizeNftType';
 import { type PlaceNftBidTx } from './placeNftBids';
+import { type SuiClient } from '@mysten/sui/client';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchMultibidChainIdById } from '../../graphql/queries/fetchMultibidById';
+import { fromHex, normalizeSuiObjectId } from '@mysten/sui/utils';
+import { isOriginByteTx } from '../../helpers/originByte/isOriginByteTx';
 
-function addTradePortPlaceNftBidTx({
-	tx,
-	collectionId,
-	nftTokenId,
-	nftType,
-	bidAmount,
-}: PlaceNftBidTx) {
-	const amountToBid = getTradeportBiddingContractBidAmount({ bidAmount, collectionId });
-	const marketFeePrice = getMarketFeePrice({ price: amountToBid, collectionId });
-
-	const [coin] = splitCoins({ tx, amounts: [tx.pure.u64(amountToBid + marketFeePrice)] });
-
-	tx.moveCall({
-		target: '0x398aae1ad267d989dcc99ba449b0a30101a6b851ec1284ccddab5937df66bfcf::biddings::bid',
-		arguments: [
-			tx.object(TRADEPORT_BIDDING_STORE),
-			tx.pure.address(nftTokenId),
-			tx.pure.u64(amountToBid),
-			tx.object(coin),
-			tx.pure.u64(marketFeePrice),
-			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
-		],
-		typeArguments: [nftType],
-	});
-
-	destroyZeroCoin({ tx, coin });
-}
-
-type KumoBidAttributes = {
-	accessory?: string;
-	background?: string;
-	eyes?: string;
-	fur_colour?: string;
-	mouth?: string;
-	tail?: string;
-	one_of_one?: string;
-};
-
-async function addTradePortKioskPlaceNftBidTx({
-	tx,
-	suiClient,
-	bidder,
-	collectionId,
-	nftTokenId,
-	nftType,
-	bidAmount,
-	royaltyRulePackageId,
-	royaltyRuleModule,
-}: PlaceNftBidTx) {
-	const transferPolicyId = await getKioskTransferPolicies(nftType).then(
-		(policies) => policies?.[0]?.id,
-	);
-	const marketFeePrice = getMarketFeePrice({ price: bidAmount, collectionId });
+export async function addTradePortPlaceNftBidTxHandler(txData: PlaceNftBidTx) {
+	if (
+		isOriginByteTx(txData?.sharedObjects) &&
+		!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
+	) {
+		throw new Error('OriginByte bidding not supported currently');
+	}
 
-	const coin = await getKioskPlaceBidCoin({
+	const {
 		tx,
-		suiClient,
-		bidder,
 		nftType,
-		bidAmount,
-		marketFeePrice,
-		royaltyRulePackageId,
-		royaltyRuleModule,
-		transferPolicyId,
-	});
+		multiBidId,
+		multiBidChainId: existingMultiBidChainId,
+		nftTokenId,
+		collectionId,
+		bcsHex,
+		expireAt,
+	} = txData;
+	let bcs: Uint8Array | undefined;
+	if (nftTokenId && isDynamicCollection(collectionId)) {
+		if (!bcsHex) {
+			throw new Error(`No BCS found for token ${nftTokenId}`);
+		}
 
-	tx.moveCall({
-		target:
-			'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::bid',
-		arguments: [
-			tx.object(TRADEPORT_KIOSK_BIDDING_STORE),
-			tx.pure.address(nftTokenId),
-			tx.pure.u64(bidAmount),
-			tx.object(coin),
-			tx.pure.u64(marketFeePrice),
-			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
-		],
-		typeArguments: [nftType],
-	});
+		bcs = fromHex(bcsHex);
+	}
 
-	destroyZeroCoin({ tx, coin });
-}
+	let multiBidChainId;
+	if (existingMultiBidChainId) {
+		multiBidChainId = existingMultiBidChainId;
+	} else {
+		const { chain_id: chainId, cancelled_at } = multiBidId
+			? ((
+					await gqlChainRequest({
+						chain: 'sui',
+						query: fetchMultibidChainIdById,
+						variables: { multiBidId },
+					})
+				)?.multi_bids?.[0] ?? {})
+			: {};
+
+		if (chainId && cancelled_at) {
+			throw new Error(`MultiBid ${chainId} already cancelled`);
+		}
 
-async function addKumoTradePortKioskPlaceNftBidTx({
-	tx,
-	suiClient,
-	bidder,
-	collectionId,
-	nftTokenId,
-	nftType,
-	bidAmount,
-	royaltyRulePackageId,
-	royaltyRuleModule,
-}: PlaceNftBidTx) {
-	const transferPolicyId = await getKioskTransferPolicies(nftType).then(
-		(policies) => policies?.[0]?.id,
-	);
-	const marketFeePrice = getMarketFeePrice({ price: bidAmount, collectionId });
+		multiBidChainId = chainId;
+	}
 
-	const coin = await getKioskPlaceBidCoin({
-		tx,
-		suiClient,
-		bidder,
-		nftType,
-		bidAmount,
-		marketFeePrice,
-		royaltyRulePackageId,
-		royaltyRuleModule,
-		transferPolicyId,
-	});
+	const transferPolicies = await getKioskTransferPolicies(nftType);
+	const transferPolicy = transferPolicies?.find(
+		(policy: { rules: any[] }) => policy?.rules?.length > 0,
+	);
+	const price = BigInt(txData?.bidAmount ?? 0n);
+	const fee = (BigInt(txData?.bidAmount ?? 0) * (await getBidFeeBps(txData?.suiClient))) / 10_000n;
+	let royalty = 0n;
+	const royaltyRule = (transferPolicy?.rules ?? []).find((r: { type: string }) =>
+		r.type.endsWith('royalty_rule'),
+	);
 
-	const kumoAttributes = await fetchKumoNftAttributes(suiClient, nftTokenId);
-	const normalizedAttributes = normalizeKumoAttributes(kumoAttributes);
+	if (royaltyRule) {
+		const { amount_bp, min_amount } = royaltyRule;
+		royalty = BigInt((price * BigInt(amount_bp)) / 10_000n);
+		if (royalty < BigInt(min_amount ?? 0n)) {
+			royalty = BigInt(min_amount ?? 0n);
+		}
+	}
 
+	const [coin] = tx.splitCoins(tx.gas, [multiBidChainId ? 0n : price + fee + royalty]);
 	tx.moveCall({
-		target:
-			'0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::kumo_bid',
-		arguments: [
-			tx.object(TRADEPORT_KIOSK_BIDDING_STORE),
-			tx.pure.address(nftTokenId),
-			tx.pure.u64(bidAmount),
-			tx.object(coin),
-			tx.pure.u64(marketFeePrice),
-			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
-			...Object.values(normalizedAttributes).map((attr) => tx.pure.option('string', attr)),
-		],
+		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::create_bid_with${transferPolicy ? '' : 'out'}_transfer_policy`,
 		typeArguments: [nftType],
-	});
-
-	destroyZeroCoin({ tx, coin });
-}
-
-async function addOriginBytePlaceNftBidTx({
-	tx,
-	nftTokenId,
-	collectionId,
-	bidAmount,
-	bidder,
-}: PlaceNftBidTx) {
-	const { kiosk: bidderKiosk, isNewKiosk: isNewBidderKiosk } = await getOrCreateOBKiosk({
-		tx,
-		address: bidder,
-		createMethod: 'create_for_sender',
-	});
-
-	const marketFeePrice = getMarketFeePrice({ price: bidAmount, collectionId });
-
-	const [coin] = splitCoins({ tx, amounts: [tx.pure.u64(bidAmount + marketFeePrice)] });
-
-	tx.moveCall({
-		target:
-			'0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::create_bid_with_commission',
 		arguments: [
-			isNewBidderKiosk ? tx.object(bidderKiosk) : tx.pure.address(bidderKiosk),
-			tx.pure.address(nftTokenId),
-			tx.pure.u64(bidAmount),
-			tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS),
-			tx.pure.u64(marketFeePrice),
+			tx.object(TRADEPORT_MULTI_BID_STORE),
+			tx.pure.u64(nftTokenId ? 1 : 0),
+			multiBidChainId
+				? typeof multiBidChainId === 'string'
+					? tx.pure.option('id', normalizeSuiObjectId(multiBidChainId))
+					: tx.moveCall({
+							target: '0x1::option::some',
+							typeArguments: ['0x2::object::ID'],
+							arguments: [multiBidChainId],
+						})
+				: undefined,
+			tx.pure.option('id', nftTokenId ? normalizeSuiObjectId(nftTokenId) : undefined),
+			tx.pure.option('vector<u8>', bcs ? [...bcs] : undefined),
+			tx.pure.option('u64', expireAt?.getTime()),
+			tx.pure.u64(price),
+			...(transferPolicy ? [tx.object(transferPolicy.id)] : []),
 			tx.object(coin),
 		],
-		typeArguments: ['0x2::sui::SUI'],
 	});
-
-	destroyZeroCoin({ tx, coin });
 }
 
-export async function addTradePortPlaceNftBidTxHandler(txData: PlaceNftBidTx) {
-	if (
-		isOriginByteTx(txData?.sharedObjects) &&
-		!ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))
-	) {
-		throw new Error('OriginByte bidding not supported currently');
-
-		// await addOriginBytePlaceNftBidTx(txData);
-		// return;
-	}
-
-	if ((await hasTransferPolicyRules(txData?.nftType)) && txData?.sellerKiosk) {
-		const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
-		const royaltyRulePackageId = await getRulePackageId({
-			nftType: txData?.nftType,
-			ruleType: royaltyRuleModule,
-			kioskClient: txData?.kioskClient,
-		});
+let bidFeeBps: bigint | undefined;
 
-		if (txData?.collectionId === '67aca668-31b0-4713-91cf-079d392b041a') {
-			await addKumoTradePortKioskPlaceNftBidTx({
-				...txData,
-				royaltyRulePackageId,
-				royaltyRuleModule,
-			});
-			return;
-		}
-
-		await addTradePortKioskPlaceNftBidTx({ ...txData, royaltyRulePackageId, royaltyRuleModule });
-		return;
+export async function getBidFeeBps(suiClient: SuiClient) {
+	if (bidFeeBps !== undefined) {
+		return bidFeeBps;
 	}
 
-	addTradePortPlaceNftBidTx(txData);
-}
-
-async function fetchKumoNftAttributes(
-	suiClient: any,
-	nftTokenId: string,
-): Promise<KumoBidAttributes> {
-	if (!nftTokenId) {
-		throw new Error('NFT Token ID is required to fetch Kumo attributes');
-	}
-
-	let res;
-	try {
-		res = await suiClient.getObject({
-			id: nftTokenId,
-			options: { showContent: true },
-		});
-	} catch (error) {
-		throw new Error(
-			`Failed to fetch Kumo token object data: ${error instanceof Error ? error.message : 'Unknown error'}`,
-		);
-	}
-
-	if (!res.data) {
-		throw new Error(`NFT object data not found: ${nftTokenId}`);
-	}
-
-	if (res.data?.content?.dataType !== 'moveObject') {
-		throw new Error('Invalid NFT Token ID - not a move object');
+	const res = await suiClient.getObject({
+		id: TRADEPORT_MULTI_BID_STORE,
+		options: { showContent: true },
+	});
+	if (res.error) {
+		throw new Error(`Error on getting SUI object ${TRADEPORT_MULTI_BID_STORE}: ${res.error.code}`);
 	}
 
-	const { accessory, background, eyes, fur_colour, mouth, tail, one_of_one } =
-		(res.data?.content?.fields as KumoBidAttributes) || {};
+	bidFeeBps = BigInt(
+		(res?.data?.content as unknown as { fields: { fee_bps: string } })?.fields?.fee_bps ?? 0,
+	);
 
-	return { accessory, background, eyes, fur_colour, mouth, tail, one_of_one };
+	return bidFeeBps;
 }
 
-function normalizeKumoAttributes(attributes: KumoBidAttributes) {
-	const normalizeAttribute = (attr: string | undefined) =>
-		!attr || attr === 'Default' || attr === 'None' ? null : attr;
-
-	return Object.fromEntries(
-		Object.entries(attributes).map(([key, value]) => [key, normalizeAttribute(value)]),
-	);
+export function isDynamicCollection(collectionId: string): boolean {
+	return DYNAMIC_COLLECTION_IDS.includes(collectionId);
 }

package/src/methods/placeNftBids/placeNftBids.ts

@@ -1,4 +1,3 @@
-import type { KioskClient } from '@mysten/kiosk';
 import { type SuiClient } from '@mysten/sui/client';
 import { Transaction } from '@mysten/sui/transactions';
 import { type RequestContext } from '../../SuiTradingClient';
@@ -15,22 +14,25 @@ import {
 export type PlaceNftBidTx = {
 	tx: Transaction;
 	suiClient: SuiClient;
-	kioskClient: KioskClient;
-	sharedObjects: any;
 	bidder: string;
 	collectionId: string;
-	nftTokenId: string;
+	nftTokenId?: string;
 	nftType: string;
-	bidAmount: number;
-	sellerKiosk: string;
-	royaltyRulePackageId?: string;
-	royaltyRuleModule?: string;
+	bidAmount: bigint;
+	multiBidId?: string;
+	multiBidChainId?: any;
+	expireAt?: Date;
+	sharedObjects?: any;
+	bcsHex?: string;
 };
 
 export type PlaceNftBid = {
 	nftId: string;
 	bidAmountInMist: number;
 	walletAddress: string;
+	multiBidId?: string;
+	multiBidChainId?: any;
+	tx?: Transaction;
 };
 
 export type PlaceNftBids = {
@@ -39,12 +41,17 @@ export type PlaceNftBids = {
 		bidAmountInMist: number;
 	}>;
 	walletAddress: string;
+	multiBidId?: string;
+	multiBidChainId?: any;
+	expireAt?: Date;
+	tx?: Transaction;
 };
 
 export const placeNftBids = async (
-	{ nfts, walletAddress }: PlaceNftBids,
+	{ nfts, walletAddress, multiBidId, multiBidChainId, expireAt, tx: existingTx }: PlaceNftBids,
 	context: RequestContext,
 ): Promise<Transaction> => {
+	const tx = existingTx ?? new Transaction();
 	const res = await gqlChainRequest({
 		chain: 'sui',
 		query: fetchNftsById,
@@ -56,8 +63,6 @@ export const placeNftBids = async (
 	}
 
 	const nftsForTracking = [];
-	const tx = new Transaction();
-
 	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);
@@ -74,14 +79,16 @@ export const placeNftBids = async (
 		const txData: PlaceNftBidTx = {
 			tx,
 			suiClient: context.suiClient,
-			kioskClient: context.kioskClient,
 			sharedObjects,
 			bidder: walletAddress,
 			collectionId: nft?.collection_id,
 			nftTokenId: nft?.token_id,
 			nftType,
-			bidAmount: nfts?.find((n) => n.id === nft?.id)?.bidAmountInMist,
-			sellerKiosk: nft?.chain_state?.kiosk_id,
+			bidAmount: BigInt(nfts?.find((n) => n.id === nft?.id)?.bidAmountInMist ?? 0n),
+			bcsHex: nft.chain_state?.bcs?.bcsHex,
+			multiBidId,
+			multiBidChainId,
+			expireAt,
 		};
 
 		await addTradePortPlaceNftBidTxHandler(txData);

package/src/methods/removeCollectionBids/addRemoveCollectionBidsTxs.ts

@@ -4,12 +4,16 @@ import {
 	TRADEPORT_BIDDING_STORE,
 } from '../../constants';
 import { getSharedObjects } from '../../helpers/getSharedObjects';
+import { isSingleBid } from '../../helpers/isSIngleBid';
 import { isBluemoveKioskBid } from '../../helpers/kiosk/isBluemoveKioskBid';
 import { isTradePortKioskBid } from '../../helpers/kiosk/isTradePortKioskBid';
 import { isOriginByteBid } from '../../helpers/originByte/isOriginByteBid';
 import { getObjectType } from '../../helpers/rpc/getObjectType';
 import { addLeadingZerosAfter0x } from '../../utils/addLeadingZerosAfter0x';
-import { addTradeportKioskRemoveNftBidTx } from '../removeNftBids/addRemoveNftBidTxs';
+import {
+	addSingleBidRemoveNftBidTx,
+	addTradeportKioskRemoveNftBidTx,
+} from '../removeNftBids/addRemoveNftBidTxs';
 import { type RemoveCollectionBidTx } from './removeCollectionBids';
 
 export function addTradeportRemoveCollectionBidTx({
@@ -99,6 +103,11 @@ export async function addTradePortRemoveCollectionBidTxHandler(txData: RemoveCol
 export async function addBluemoveRemoveCollectionBidTxHandler(txData: RemoveCollectionBidTx) {
 	const bidType = await getObjectType({ suiClient: txData?.suiClient, objectId: txData?.bidNonce });
 
+	if (isSingleBid(bidType)) {
+		await addSingleBidRemoveNftBidTx(txData);
+		return;
+	}
+
 	if (isOriginByteBid(bidType)) {
 		const sharedObjects = await getSharedObjects(txData?.nftType);
 		addOriginByteRemoveCollectionBidTx({ ...txData, sharedObjects });

package/src/methods/removeNftBids/addRemoveNftBidTxs.ts

@@ -3,7 +3,12 @@ import {
 	TOCEN_MARKETPLACE_OBJECT,
 	TRADEPORT_BIDDING_STORE,
 	TRADEPORT_KIOSK_BIDDING_STORE,
+	TRADEPORT_MULTI_BID_PACKAGE,
+	TRADEPORT_MULTI_BID_STORE,
 } from '../../constants';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+import { fetchMultibidChainIdById } from '../../graphql/queries/fetchMultibidById';
+import { isSingleBid } from '../../helpers/isSIngleBid';
 import { isTradePortKioskBid } from '../../helpers/kiosk/isTradePortKioskBid';
 import { isOriginByteBid } from '../../helpers/originByte/isOriginByteBid';
 import { getObjectType } from '../../helpers/rpc/getObjectType';
@@ -62,9 +67,34 @@ export function addTocenRemoveNftBidTx({ tx, nftTokenId, bidAmount }: RemoveNftB
 	});
 }
 
+export async function addSingleBidRemoveNftBidTx({ tx, bidNonce, multiBidId }: RemoveNftBidTx) {
+	const multiBidChainId = multiBidId
+		? (
+				await gqlChainRequest({
+					chain: 'sui',
+					query: fetchMultibidChainIdById,
+					variables: { multiBidId },
+				})
+			)?.multi_bids?.[0]?.chain_id
+		: undefined;
+	tx.moveCall({
+		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::cancel_bid`,
+		arguments: [
+			tx.object(TRADEPORT_MULTI_BID_STORE),
+			tx.pure.id(bidNonce),
+			tx.pure.option('id', multiBidChainId),
+		],
+	});
+}
+
 export async function addTradePortRemoveNftBidTxHandler(txData: RemoveNftBidTx) {
 	const bidType = await getObjectType({ suiClient: txData?.suiClient, objectId: txData?.bidNonce });
 
+	if (isSingleBid(bidType)) {
+		await addSingleBidRemoveNftBidTx(txData);
+		return;
+	}
+
 	if (isOriginByteBid(bidType)) {
 		addOriginByteRemoveNftBidTx(txData);
 		return;

package/src/methods/removeNftBids/removeNftBids.ts

@@ -25,6 +25,7 @@ export type RemoveNftBidTx = {
 	bidAmount: number;
 	sellerKiosk: string;
 	bidMarketName: string;
+	multiBidId?: string;
 };
 
 export type RemoveNftBid = {
@@ -73,6 +74,7 @@ export const removeNftBids = async (
 			bidAmount: bid?.price,
 			sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
 			bidMarketName: bid?.market_contract?.name,
+			multiBidId: bid?.multi_bid_id,
 		};
 
 		switch (txData.bidMarketName) {

package/src/methods/updateMultiBid/updateMultiBid.ts

@@ -0,0 +1,59 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { TRADEPORT_MULTI_BID_PACKAGE, TRADEPORT_MULTI_BID_STORE } from '../../constants';
+import { fetchMultibidChainIdById } from '../../graphql/queries/fetchMultibidById';
+import { gqlChainRequest } from '../../graphql/gqlChainRequest';
+
+export interface UpdateMultiBid {
+	walletAddress: string;
+	multiBidId?: string;
+	name?: string;
+	amount?: bigint;
+	amountToWithdraw?: bigint;
+	tx?: Transaction;
+	multiBidChainId?: any;
+}
+
+export async function updateMultiBid({
+	multiBidId,
+	name,
+	amount,
+	amountToWithdraw,
+	tx: existingTx,
+	multiBidChainId,
+}: UpdateMultiBid): Promise<Transaction> {
+	const tx = existingTx ?? new Transaction();
+
+	if (!multiBidChainId) {
+		const { chain_id: chainId, cancelled_at } =
+			(
+				await gqlChainRequest({
+					chain: 'sui',
+					query: fetchMultibidChainIdById,
+					variables: { multiBidId },
+				})
+			)?.multi_bids?.[0] ?? {};
+		if (!chainId) {
+			throw new Error(`MultiBid ${multiBidId} not found`);
+		}
+
+		if (cancelled_at) {
+			throw new Error(`MultiBid ${multiBidId} already cancelled`);
+		}
+
+		multiBidChainId = chainId;
+	}
+
+	const [coin] = tx.splitCoins(tx.gas, [amount ?? 0n]);
+	tx.moveCall({
+		target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::update_multi_bid`,
+		arguments: [
+			tx.object(TRADEPORT_MULTI_BID_STORE),
+			typeof multiBidChainId === 'string' ? tx.pure.id(multiBidChainId) : multiBidChainId,
+			tx.pure.option('string', name),
+			coin,
+			tx.pure.option('u64', amountToWithdraw),
+		],
+	});
+
+	return tx;
+}

package/src/tests/SuiWallet.ts

@@ -28,7 +28,7 @@ export class SuiWallet {
 	}
 
 	async simulateCall(tx: Transaction): Promise<any> {
-		tx.setSenderIfNotSet('0x7cb678cc0446b986bab45d612a25946b2a63763d2252b1e554d1763eb788f660');
+		tx.setSenderIfNotSet(this.keypair.toSuiAddress());
 		const rawTransaction = await tx.build({ client: this.suiClient });
 		const result = await this.suiClient.dryRunTransactionBlock({
 			transactionBlock: rawTransaction,