@tradeport/sui-trading-sdk 0.3.8 → 0.4.0

package/dist/index.js

@@ -90,6 +90,7 @@ var fetchCollectionBidsById = import_graphql_request3.gql`
 			status
 			type
 			collection_id
+			multi_bid_id
 			contract {
 				properties
 			}
@@ -119,6 +120,7 @@ var fetchCollectionBidsAtSamePrice = import_graphql_request4.gql`
 			status
 			type
 			collection_id
+			multi_bid_id
 			contract {
 				properties
 			}
@@ -146,6 +148,8 @@ var TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK = "0x151fbe627d3f8de855f424c879ea2176d8
 var TRADEPORT_KIOSK_BID_NONCE_TYPE = "0xec175e537be9e48f75fa6929291de6454d2502f1091feb22c0d26a22821bbf28::kiosk_biddings::Bid";
 var TRADEPORT_PRICE_LOCK_PACKAGE = "0x3cb532a2548290780a3d70ad6f4f06abc5bebb75ec6f8dd0197d4d2b2860c5d8";
 var TRADEPORT_PRICE_LOCK_STORE = "0x4b705de46a79b29276baf45009bc7d6f70cc0f1407f0c9e03cac5729c0c47946";
+var TRADEPORT_MULTI_BID_PACKAGE = "0xb32c899d9fb0d79a7e384bfbf2830a19ee26ccf51d6cadaaf1a14c4a2817886a";
+var TRADEPORT_MULTI_BID_STORE = "0x2617658a6b03dcf6df2df4d256341bc4690d3a3d299c9552ca6ac9799ceb0ed7";
 var COLLECTION_IDS_WITH_ZERO_COMMISSION = [
   ""
 ];
@@ -1095,6 +1099,18 @@ var DELOREAN_TOKEN_IDS_TO_DISABLE = [
   "0x8045e771ecd3c409c4245a003887b90964e31b63717252cfe4cd13d86ceaa2c3",
   "0xbd494f677ec2361dda0fefe2ec9689f8d4c8ab585e5a39884290850e5a4e28df"
 ];
+var DYNAMIC_COLLECTION_IDS = [
+  "67aca668-31b0-4713-91cf-079d392b041a",
+  // Kumo
+  "b5d64823-54b5-43ff-b58f-8b8abf08d27b",
+  // Hunting Snake Legends
+  "5ea655c3-b8f9-4882-9090-3c59d1635d00",
+  // Fever Maniac
+  "f7ccba9d-04f8-49c4-8e1f-d264b122584d",
+  // SuiFrens: Capys
+  "a8c93237-922f-4d6c-825f-bdcbc4bf10fc"
+  // Anima Genesis Avatars
+];
 
 // src/graphql/queries/fetchNftsById.ts
 var import_graphql_request5 = require("graphql-request");
@@ -1303,6 +1319,12 @@ var getKioskTransferPolicies = async (nftType) => {
   }
   return transferPolicies;
 };
+var knownTransferPolicyRules = [
+  "royalty_rule",
+  "kiosk_lock_rule",
+  "personal_kiosk_rule",
+  "floor_price_rule"
+];
 
 // src/helpers/hasPersonalKioskRule.ts
 var hasPersonalKioskRule = async (nftType) => {
@@ -1435,6 +1457,9 @@ var kioskTxWrapper = async ({
     await runCommands(kioskTx);
     return;
   }
+  if (!kioskOwner) {
+    throw new Error("No kiosk owner provided");
+  }
   let kiosks = kioskOwnerKiosks ?? ((await gqlChainRequest({
     chain: "sui",
     query: fetchKiosksByOwner,
@@ -1480,7 +1505,10 @@ var kioskTxWrapper = async ({
         version: ""
       }
     });
-  } else if (kiosks.length > 0) {
+  } else if (shouldConvertToPersonalKiosk || kiosks.length === 0) {
+    kioskTx = new import_kiosk3.KioskTransaction({ transactionBlock: tx, kioskClient });
+    kioskTx.createPersonal(true);
+  } else {
     const kioskCapId = (await gqlChainRequest({
       chain: "sui",
       query: fetchOwnerCapByKiosk,
@@ -1497,9 +1525,6 @@ var kioskTxWrapper = async ({
         version: ""
       }
     });
-  } else {
-    kioskTx = new import_kiosk3.KioskTransaction({ transactionBlock: tx, kioskClient });
-    kioskTx.createPersonal(true);
   }
   await runCommands(kioskTx);
   kioskTx.finalize();
@@ -1989,6 +2014,31 @@ var getOBBidderKiosk = async ({
   return bidObject.data?.content?.fields?.kiosk;
 };
 
+// src/helpers/isSIngleBid.ts
+var isSingleBid = (bidType) => {
+  if (!bidType) {
+    return false;
+  }
+  if (!bidType.startsWith("0x")) {
+    bidType = `0x${bidType}`;
+  }
+  return bidType === `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::SingleBid`;
+};
+
+// src/methods/acceptNftBids/addAcceptNftBidTxs.ts
+var import_utils2 = require("@mysten/sui/utils");
+
+// src/graphql/queries/fetchMultibidById.ts
+var import_graphql_request12 = require("graphql-request");
+var fetchMultibidChainIdById = import_graphql_request12.gql`
+	query fetchMultibidById($multiBidId: uuid!) {
+		multi_bids(where: { id: { _eq: $multiBidId } }) {
+			chain_id
+			cancelled_at
+		}
+	}
+`;
+
 // src/methods/acceptNftBids/addAcceptNftBidTxs.ts
 function addTradeportAcceptNftBidTx({
   tx,
@@ -2174,8 +2224,80 @@ function addBluemoveAcceptNftBidTx({
     typeArguments: [nftType]
   });
 }
+async function addSingleBidAcceptNftBidTx(txData) {
+  const { nftType, tx, bidNonce, multiBidId, kioskClient, nftTokenId } = txData;
+  const transferPolicies = await getKioskTransferPolicies(nftType);
+  const transferPolicy = transferPolicies?.find(
+    (policy) => policy?.rules?.length > 0
+  );
+  const { chain_id: multiBidChainId, cancelled_at } = multiBidId ? (await gqlChainRequest({
+    chain: "sui",
+    query: fetchMultibidChainIdById,
+    variables: { multiBidId }
+  }))?.multi_bids?.[0] ?? {} : {};
+  if (multiBidChainId && cancelled_at) {
+    throw new Error(`MultiBid ${multiBidId} already cancelled`);
+  }
+  if (transferPolicy) {
+    const transferPolicies2 = await kioskClient.getTransferPolicies({
+      type: (0, import_utils2.normalizeStructTag)(nftType)
+    });
+    const { rules: allRules } = transferPolicies2.find((p) => p.id === transferPolicy.id);
+    const unsupportedRule = allRules.find(
+      (r) => !knownTransferPolicyRules.includes(r.split("::").at(1))
+    );
+    if (unsupportedRule) {
+      throw new Error(
+        `Found unsupported transfer policy rule ${unsupportedRule} for ${transferPolicy.id} of ${nftType}`
+      );
+    }
+    return kioskTxWrapper({
+      tx: txData?.tx,
+      kioskClient: txData?.kioskClient,
+      kioskTx: txData?.kioskTx,
+      kioskOwner: txData?.seller,
+      kiosk: txData?.sellerKiosk,
+      async runCommands(kioskTx) {
+        const [transferRequest] = tx.moveCall({
+          target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::accept_bid_with_transfer_policy`,
+          typeArguments: [nftType],
+          arguments: [
+            tx.object(import_utils2.SUI_CLOCK_OBJECT_ID),
+            tx.object(TRADEPORT_MULTI_BID_STORE),
+            tx.pure.id(bidNonce),
+            tx.pure.option("id", multiBidChainId),
+            tx.object(kioskTx.getKiosk()),
+            tx.object(kioskTx.getKioskCap()),
+            tx.pure.id(nftTokenId),
+            tx.object(transferPolicy.id)
+          ]
+        });
+        tx.moveCall({
+          target: "0x2::transfer_policy::confirm_request",
+          arguments: [tx.object(transferPolicy.id), transferRequest],
+          typeArguments: [nftType]
+        });
+      }
+    });
+  }
+  tx.moveCall({
+    target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::accept_bid_without_transfer_policy`,
+    typeArguments: [nftType],
+    arguments: [
+      tx.object(import_utils2.SUI_CLOCK_OBJECT_ID),
+      tx.object(TRADEPORT_MULTI_BID_STORE),
+      tx.pure.id(bidNonce),
+      tx.pure.option("id", multiBidChainId),
+      tx.object(nftTokenId)
+    ]
+  });
+}
 async function addTradePortAcceptNftBidTxHandler(txData) {
   const bidType = await getObjectType({ suiClient: txData?.suiClient, objectId: txData?.bidNonce });
+  if (isSingleBid(bidType)) {
+    await addSingleBidAcceptNftBidTx(txData);
+    return;
+  }
   if (isOriginByteBid(bidType)) {
     if (isOriginByteTx(txData?.sharedObjects)) {
       await addOriginByteAcceptNftBidTx(txData);
@@ -2606,6 +2728,10 @@ function addTocenAcceptCollectionBidTx({
 }
 async function addTradePortAcceptCollectionBidTxHandler(txData) {
   const bidType = await getObjectType({ suiClient: txData?.suiClient, objectId: txData?.bidNonce });
+  if (isSingleBid(bidType)) {
+    await addSingleBidAcceptNftBidTx(txData);
+    return;
+  }
   if (isOriginByteBid(bidType)) {
     if (isOriginByteTx(txData?.sharedObjects)) {
       await addOriginByteAcceptCollectionBidTx(txData);
@@ -2767,6 +2893,7 @@ var acceptCollectionBid = async ({
     collectionId: nft?.collection_id,
     isListedOnBluemove: nft?.listings?.[0]?.market_name === "bluemove",
     bidMarketName: bid?.market_contract?.name,
+    multiBidId: bid.multi_bid_id,
     shouldSplitRoyaltyFromUserGasCoins,
     beforeResolveKioskTransferRequest
   };
@@ -2810,8 +2937,8 @@ var acceptCollectionBid = async ({
 var import_transactions3 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchBidsById.ts
-var import_graphql_request12 = require("graphql-request");
-var fetchBidsById = import_graphql_request12.gql`
+var import_graphql_request13 = require("graphql-request");
+var fetchBidsById = import_graphql_request13.gql`
 	query fetchBidsById($bidIds: [uuid!]) {
 		bids(where: { id: { _in: $bidIds } }) {
 			nonce
@@ -2820,6 +2947,7 @@ var fetchBidsById = import_graphql_request12.gql`
 			type
 			receiver
 			bidder
+			multi_bid_id
 			nft {
 				token_id
 				properties
@@ -2896,8 +3024,10 @@ var acceptNftBids = async ({
       itemOwner: bid?.nft?.owner,
       bidAmount: bid?.price,
       sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
+      seller: bid?.nft?.owner,
       isListedOnBluemove: bid?.nft?.listings?.[0]?.market_name === "bluemove",
       bidMarketName: bid?.market_contract?.name,
+      multiBidId: bid?.multi_bid_id,
       beforeResolveKioskTransferRequest
     };
     switch (txData.bidMarketName) {
@@ -2934,7 +3064,7 @@ var acceptNftBids = async ({
 var import_transactions6 = require("@mysten/sui/transactions");
 
 // src/methods/buyLocks/buyLocks.ts
-var import_utils2 = require("@mysten/sui.js/utils");
+var import_utils3 = require("@mysten/sui.js/utils");
 var import_transactions4 = require("@mysten/sui/transactions");
 
 // src/helpers/calculatePremium.ts
@@ -2958,8 +3088,8 @@ function calculateRoyaltyFee(transferPolicyRules, price) {
 }
 
 // src/graphql/queries/fetchLockById.ts
-var import_graphql_request13 = require("graphql-request");
-var fetchLockById = import_graphql_request13.gql`
+var import_graphql_request14 = require("graphql-request");
+var fetchLockById = import_graphql_request14.gql`
 	query fetchLockById($lockId: uuid!) {
 		locks(where: { id: { _eq: $lockId } }) {
 			id
@@ -3077,7 +3207,7 @@ async function buyLocks({ lockIds, transaction }, context) {
       typeArguments: [lock.nft_type],
       arguments: [
         tx.object(TRADEPORT_PRICE_LOCK_STORE),
-        tx.object(import_utils2.SUI_CLOCK_OBJECT_ID),
+        tx.object(import_utils3.SUI_CLOCK_OBJECT_ID),
         tx.pure.id(lock.lock_id),
         tx.pure.u64(lock.maker_price),
         tx.pure.u64(marketplaceFee),
@@ -3091,7 +3221,7 @@ async function buyLocks({ lockIds, transaction }, context) {
 }
 
 // src/methods/exerciseLongLocks/exerciseLongLocks.ts
-var import_utils3 = require("@mysten/sui.js/utils");
+var import_utils4 = require("@mysten/sui.js/utils");
 var import_transactions5 = require("@mysten/sui/transactions");
 async function exerciseLongLocks({ walletAddress, transaction, locks }, context) {
   const tx = transaction ?? new import_transactions5.Transaction();
@@ -3149,7 +3279,7 @@ async function exerciseLongLocks({ walletAddress, transaction, locks }, context)
           typeArguments: [lock.nft_type],
           arguments: [
             tx.object(TRADEPORT_PRICE_LOCK_STORE),
-            tx.object(import_utils3.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils4.SUI_CLOCK_OBJECT_ID),
             tx.pure.id(lock.lock_id),
             tx.object(lock.chain_state.makerKioskId),
             tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
@@ -3254,12 +3384,12 @@ async function buyAndExerciseLongLocks({ walletAddress, locks, tx: existingTx },
 var import_transactions9 = require("@mysten/sui/transactions");
 
 // src/methods/exerciseShortLocks/exerciseShortLocks.ts
-var import_utils4 = require("@mysten/sui.js/utils");
+var import_utils5 = require("@mysten/sui.js/utils");
 var import_transactions8 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchListingsById.ts
-var import_graphql_request14 = require("graphql-request");
-var fetchListingsById = import_graphql_request14.gql`
+var import_graphql_request15 = require("graphql-request");
+var fetchListingsById = import_graphql_request15.gql`
 	query fetchListingsById($listingIds: [uuid!]) {
 		listings(where: { id: { _in: $listingIds } }) {
 			seller
@@ -3304,8 +3434,8 @@ var addThirdPartyTxFee = async (tx, price) => {
 var import_bcs2 = require("@mysten/sui/bcs");
 
 // src/graphql/queries/fetchCommissionByListingId.ts
-var import_graphql_request15 = require("graphql-request");
-var fetchCommissionByNftContractId = import_graphql_request15.gql`
+var import_graphql_request16 = require("graphql-request");
+var fetchCommissionByNftContractId = import_graphql_request16.gql`
 	query fetchCommissionByNftContractId($nftContractId: uuid!) {
 		commissions(where: { contract_id: { _eq: $nftContractId } }) {
 			is_custodial
@@ -3963,7 +4093,7 @@ async function exerciseShortLocks({ walletAddress, transaction, locks }, context
           typeArguments: [lock.nft_type],
           arguments: [
             tx.object(TRADEPORT_PRICE_LOCK_STORE),
-            tx.object(import_utils4.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils5.SUI_CLOCK_OBJECT_ID),
             tx.pure.id(lock.lock_id)
           ]
         });
@@ -4044,7 +4174,7 @@ async function buyAndExerciseShortLocks({ walletAddress, locks, tx: existingTx }
 }
 
 // src/methods/cancelLocks/cancelLocks.ts
-var import_utils5 = require("@mysten/sui.js/utils");
+var import_utils6 = require("@mysten/sui.js/utils");
 var import_transactions10 = require("@mysten/sui/transactions");
 async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, context) {
   const tx = existingTx ?? new import_transactions10.Transaction();
@@ -4067,7 +4197,7 @@ async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, context)
           typeArguments: [lock.nft_type],
           arguments: [
             tx.object(TRADEPORT_PRICE_LOCK_STORE),
-            tx.object(import_utils5.SUI_CLOCK_OBJECT_ID),
+            tx.object(import_utils6.SUI_CLOCK_OBJECT_ID),
             tx.pure.id(lock.lock_id),
             tx.object(kioskTx.kiosk.value ?? kioskTx.kiosk)
           ]
@@ -4082,8 +4212,8 @@ async function cancelLocks({ lockIds, walletAddress, tx: existingTx }, context)
 var import_transactions11 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchAccountKiosks.ts
-var import_graphql_request16 = require("graphql-request");
-var fetchAccountKiosks = import_graphql_request16.gql`
+var import_graphql_request17 = require("graphql-request");
+var fetchAccountKiosks = import_graphql_request17.gql`
 	query fetchAccountKiosks($accountAddress: String!) {
 		kiosks: kiosks_by_owner_address(owner_address: $accountAddress) {
 			id
@@ -4529,8 +4659,8 @@ var claimNfts = async ({ nftIds, walletAddress, tx: existingTx }, context, useOl
 var import_transactions13 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchActiveLockStateByNftId.ts
-var import_graphql_request17 = require("graphql-request");
-var fetchActiveLockStateByNftId = import_graphql_request17.gql`
+var import_graphql_request18 = require("graphql-request");
+var fetchActiveLockStateByNftId = import_graphql_request18.gql`
 	query fetchActiveLockStateByNftId($nftId: uuid!) {
 		locks(
 			where: {
@@ -5014,8 +5144,8 @@ var listNfts = async ({ nfts, walletAddress }, context) => {
 var import_transactions16 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchNftsByKioskId.ts
-var import_graphql_request18 = require("graphql-request");
-var fetchNftsByKioskId = import_graphql_request18.gql`
+var import_graphql_request19 = require("graphql-request");
+var fetchNftsByKioskId = import_graphql_request19.gql`
 	query fetchNftsByKioskId($jsonFilter: jsonb) {
 		nfts(where: { chain_state: { _contains: $jsonFilter } }) {
 			id
@@ -5300,8 +5430,8 @@ async function migrateNftsFromUnsharedToSharedKiosks({ walletAddress, max = 5 },
 var import_transactions17 = require("@mysten/sui/transactions");
 
 // src/graphql/queries/fetchCollectionsById.ts
-var import_graphql_request19 = require("graphql-request");
-var fetchCollectionsById = import_graphql_request19.gql`
+var import_graphql_request20 = require("graphql-request");
+var fetchCollectionsById = import_graphql_request20.gql`
 	query fetchCollectionsById($collectionIds: [uuid!]) {
 		collections(where: { id: { _in: $collectionIds } }) {
 			id
@@ -5311,7 +5441,7 @@ var fetchCollectionsById = import_graphql_request19.gql`
 		}
 	}
 `;
-var fetchCollectionsByIdWithOneNft = import_graphql_request19.gql`
+var fetchCollectionsByIdWithOneNft = import_graphql_request20.gql`
 	query fetchCollectionsByIdWithOneNft($collectionIds: [uuid!]) {
 		collections(where: { id: { _in: $collectionIds } }) {
 			id
@@ -5329,7 +5459,7 @@ var fetchCollectionsByIdWithOneNft = import_graphql_request19.gql`
 		}
 	}
 `;
-var fetchCollectionsBySlug = import_graphql_request19.gql`
+var fetchCollectionsBySlug = import_graphql_request20.gql`
 	query fetchCollectionsBySlug($slug: String!) {
 		collections(where: { slug: { _eq: $slug } }) {
 			id
@@ -5338,8 +5468,8 @@ var fetchCollectionsBySlug = import_graphql_request19.gql`
 `;
 
 // src/graphql/queries/fetchCollectionFloorListings.ts
-var import_graphql_request20 = require("graphql-request");
-var fetchCollectionFloorListings = import_graphql_request20.gql`
+var import_graphql_request21 = require("graphql-request");
+var fetchCollectionFloorListings = import_graphql_request21.gql`
 	query fetchCollectionFloorListings($collectionId: uuid!) {
 		listings(
 			where: { collection_id: { _eq: $collectionId }, listed: { _eq: true }, nft: {} }
@@ -5363,132 +5493,7 @@ var getCollectionFloorPrice = async (collectionId) => {
   return res?.listings?.[0]?.price;
 };
 
-// src/helpers/getTradeportBiddingContractBidAmount.ts
-var getTradeportBiddingContractBidAmount = ({ bidAmount, collectionId }) => {
-  let amount = bidAmount;
-  if (collectionId === "8568521c-73a3-4beb-b830-d1ff27a3f1ca") {
-    amount = bidAmount - bidAmount * MASC_ROYALTY_DECIMAL_PERCENT;
-  }
-  if (collectionId === "6824e1ff-477e-4810-9ba7-8d6387b68c7d") {
-    amount = bidAmount - bidAmount * BASC_ROYALTY_DECIMAL_PERCENT;
-  }
-  if (collectionId === "307c7e7a-be3a-43a5-ae44-37f3a37d01f9") {
-    amount = bidAmount - bidAmount * DSL_LEGACY_ROYALTY_DECIMAL_PERCENT;
-  }
-  return amount;
-};
-
-// src/helpers/hasRoyaltyRule.ts
-var hasRoyaltyRule = async (nftType) => {
-  const transferPolicies = await getKioskTransferPolicies(nftType);
-  return transferPolicies?.some(
-    (policy) => policy?.rules?.filter((rule) => rule?.type?.includes("royalty_rule"))?.length > 0
-  );
-};
-
-// src/helpers/kiosk/getKioskPlaceBidCoin.ts
-async function getKioskPlaceBidCoin({
-  tx,
-  suiClient,
-  bidder,
-  nftType,
-  bidAmount,
-  marketFeePrice,
-  royaltyRulePackageId,
-  royaltyRuleModule,
-  transferPolicyId
-}) {
-  let coin;
-  if (royaltyRulePackageId && royaltyRuleModule) {
-    const royaltyFeeAmount = await getKioskCollectionRoyaltyFeeAmount({
-      tx,
-      suiClient,
-      walletAddress: bidder,
-      royaltyRulePackageId,
-      royaltyRuleModule,
-      transferPolicyId,
-      price: bidAmount,
-      nftType
-    });
-    const [coin1, coin2] = splitCoins({
-      tx,
-      amounts: [tx.pure.u64(bidAmount + marketFeePrice), royaltyFeeAmount]
-    });
-    coin = coin1;
-    if (!coin1 || !coin2) throw new Error("Coin could not be split");
-    tx.mergeCoins(tx.object(coin1), [tx.object(coin2)]);
-  } else {
-    const [coin1] = splitCoins({
-      tx,
-      amounts: [tx.pure.u64(bidAmount + marketFeePrice)]
-    });
-    coin = coin1;
-  }
-  return coin;
-}
-
 // src/methods/placeCollectionBids/addPlaceCollectionBidTxs.ts
-function addTradePortCollectionBidTx({
-  tx,
-  collectionId,
-  nftType,
-  bidAmount
-}) {
-  const amountToBid = getTradeportBiddingContractBidAmount({ bidAmount, collectionId });
-  const marketFeePrice = getMarketFeePrice({ price: bidAmount, collectionId });
-  const [coin] = splitCoins({ tx, amounts: [tx.pure.u64(amountToBid + marketFeePrice)] });
-  tx.moveCall({
-    target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::collection_bid",
-    arguments: [
-      tx.object(TRADEPORT_BIDDING_STORE),
-      tx.pure.u64(amountToBid),
-      tx.object(coin),
-      tx.pure.u64(marketFeePrice),
-      tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS)
-    ],
-    typeArguments: [nftType]
-  });
-  destroyZeroCoin({ tx, coin });
-}
-async function addTradePortKioskCollectionBidTx({
-  tx,
-  suiClient,
-  bidder,
-  collectionId,
-  nftType,
-  bidAmount,
-  royaltyRulePackageId,
-  royaltyRuleModule
-}) {
-  const transferPolicyId = (await getKioskTransferPolicies(nftType))?.at(0)?.id;
-  const marketFeePrice = getMarketFeePrice({
-    price: bidAmount,
-    collectionId
-  });
-  const coin = await getKioskPlaceBidCoin({
-    tx,
-    suiClient,
-    bidder,
-    nftType,
-    bidAmount,
-    marketFeePrice,
-    royaltyRulePackageId,
-    royaltyRuleModule,
-    transferPolicyId
-  });
-  tx.moveCall({
-    target: "0x475e98e9c436ec118909f3b9e241d86bcbbc2cf9fba05e99a934823fefb375b7::kiosk_biddings::collection_bid",
-    arguments: [
-      tx.object(TRADEPORT_KIOSK_BIDDING_STORE),
-      tx.pure.u64(bidAmount),
-      tx.object(coin),
-      tx.pure.u64(marketFeePrice),
-      tx.pure.address(TRADEPORT_BENEFICIARY_ADDRESS)
-    ],
-    typeArguments: [nftType]
-  });
-  destroyZeroCoin({ tx, coin });
-}
 async function addOriginByteCollectionBidTx({
   tx,
   collectionId,
@@ -5518,22 +5523,112 @@ async function addOriginByteCollectionBidTx({
   });
   destroyZeroCoin({ tx, coin });
 }
-async function addTradePortPlaceCollectionBidTxHandler(txData) {
-  if (await hasRoyaltyRule(txData?.nftType)) {
-    const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
-    const royaltyRulePackageId = await getRulePackageId({
-      nftType: txData.nftType,
-      ruleType: getRoyaltyRuleModule(txData?.collectionId),
-      kioskClient: txData?.kioskClient
-    });
-    await addTradePortKioskCollectionBidTx({ ...txData, royaltyRulePackageId, royaltyRuleModule });
-    return;
+
+// src/methods/placeNftBids/addPlaceNftBidTxs.ts
+var import_utils7 = require("@mysten/sui/utils");
+async function addTradePortPlaceNftBidTxHandler(txData) {
+  if (isOriginByteTx(txData?.sharedObjects) && !ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) {
+    throw new Error("OriginByte bidding not supported currently");
+  }
+  const {
+    tx,
+    nftType,
+    multiBidId,
+    multiBidChainId: existingMultiBidChainId,
+    nftTokenId,
+    collectionId,
+    bcsHex,
+    expireAt
+  } = txData;
+  let bcs3;
+  if (nftTokenId && isDynamicCollection(collectionId)) {
+    if (!bcsHex) {
+      throw new Error(`No BCS found for token ${nftTokenId}`);
+    }
+    bcs3 = (0, import_utils7.fromHex)(bcsHex);
+  }
+  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`);
+    }
+    multiBidChainId = chainId;
+  }
+  const transferPolicies = await getKioskTransferPolicies(nftType);
+  const transferPolicy = transferPolicies?.find(
+    (policy) => policy?.rules?.length > 0
+  );
+  const price = BigInt(txData?.bidAmount ?? 0n);
+  const fee = BigInt(txData?.bidAmount ?? 0) * await getBidFeeBps(txData?.suiClient) / 10000n;
+  let royalty = 0n;
+  const royaltyRule = (transferPolicy?.rules ?? []).find(
+    (r) => r.type.endsWith("royalty_rule")
+  );
+  if (royaltyRule) {
+    const { amount_bp, min_amount } = royaltyRule;
+    royalty = BigInt(price * BigInt(amount_bp) / 10000n);
+    if (royalty < BigInt(min_amount ?? 0n)) {
+      royalty = BigInt(min_amount ?? 0n);
+    }
   }
-  addTradePortCollectionBidTx(txData);
+  const [coin] = tx.splitCoins(tx.gas, [multiBidChainId ? 0n : price + fee + royalty]);
+  tx.moveCall({
+    target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::create_bid_with${transferPolicy ? "" : "out"}_transfer_policy`,
+    typeArguments: [nftType],
+    arguments: [
+      tx.object(TRADEPORT_MULTI_BID_STORE),
+      tx.pure.u64(nftTokenId ? 1 : 0),
+      multiBidChainId ? typeof multiBidChainId === "string" ? tx.pure.option("id", (0, import_utils7.normalizeSuiObjectId)(multiBidChainId)) : tx.moveCall({
+        target: "0x1::option::some",
+        typeArguments: ["0x2::object::ID"],
+        arguments: [multiBidChainId]
+      }) : void 0,
+      tx.pure.option("id", nftTokenId ? (0, import_utils7.normalizeSuiObjectId)(nftTokenId) : void 0),
+      tx.pure.option("vector<u8>", bcs3 ? [...bcs3] : void 0),
+      tx.pure.option("u64", expireAt?.getTime()),
+      tx.pure.u64(price),
+      ...transferPolicy ? [tx.object(transferPolicy.id)] : [],
+      tx.object(coin)
+    ]
+  });
+}
+var bidFeeBps;
+async function getBidFeeBps(suiClient) {
+  if (bidFeeBps !== void 0) {
+    return bidFeeBps;
+  }
+  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}`);
+  }
+  bidFeeBps = BigInt(
+    res?.data?.content?.fields?.fee_bps ?? 0
+  );
+  return bidFeeBps;
+}
+function isDynamicCollection(collectionId) {
+  return DYNAMIC_COLLECTION_IDS.includes(collectionId);
 }
 
 // src/methods/placeCollectionBids/placeCollectionBids.ts
-var placeCollectionBids = async ({ collections, walletAddress }, context) => {
+var placeCollectionBids = async ({
+  collections,
+  walletAddress,
+  multiBidId,
+  multiBidChainId,
+  expireAt,
+  tx: existingTx
+}, context) => {
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchCollectionsByIdWithOneNft,
@@ -5542,11 +5637,8 @@ var placeCollectionBids = async ({ collections, walletAddress }, context) => {
   if (res?.collections?.length === 0) {
     throw new Error("No collection found");
   }
-  if (res?.collections?.length === 0) {
-    throw new Error("No collection found");
-  }
   const collectionsForTracking = [];
-  const tx = new import_transactions17.Transaction();
+  const tx = existingTx ?? new import_transactions17.Transaction();
   for (const collection of res.collections) {
     const nftType = getNftType({
       collectionId: collection?.id,
@@ -5562,7 +5654,10 @@ var placeCollectionBids = async ({ collections, walletAddress }, context) => {
       bidder: walletAddress,
       collectionId: collection?.id,
       nftType,
-      bidAmount: collections?.find((c) => c.id === collection?.id)?.bidAmountInMist
+      bidAmount: collections?.find((c) => c.id === collection?.id)?.bidAmountInMist,
+      multiBidId,
+      multiBidChainId,
+      expireAt
     };
     const numOfBids = collections?.find((c) => c.id === collection?.id)?.numOfBids;
     if (isOriginByteTx(txData?.sharedObjects) && !ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) {
@@ -5578,7 +5673,7 @@ var placeCollectionBids = async ({ collections, walletAddress }, context) => {
       }
     } else {
       for (let i = 0; i < numOfBids; i++) {
-        await addTradePortPlaceCollectionBidTxHandler(txData);
+        await addTradePortPlaceNftBidTxHandler({ ...txData, bidAmount: BigInt(txData.bidAmount) });
       }
     }
     collectionsForTracking.push({
@@ -5593,172 +5688,8 @@ var placeCollectionBids = async ({ collections, walletAddress }, context) => {
 
 // src/methods/placeNftBids/placeNftBids.ts
 var import_transactions18 = require("@mysten/sui/transactions");
-
-// src/methods/placeNftBids/addPlaceNftBidTxs.ts
-function addTradePortPlaceNftBidTx({
-  tx,
-  collectionId,
-  nftTokenId,
-  nftType,
-  bidAmount
-}) {
-  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 });
-}
-async function addTradePortKioskPlaceNftBidTx({
-  tx,
-  suiClient,
-  bidder,
-  collectionId,
-  nftTokenId,
-  nftType,
-  bidAmount,
-  royaltyRulePackageId,
-  royaltyRuleModule
-}) {
-  const transferPolicyId = await getKioskTransferPolicies(nftType).then(
-    (policies) => policies?.[0]?.id
-  );
-  const marketFeePrice = getMarketFeePrice({ price: bidAmount, collectionId });
-  const coin = await getKioskPlaceBidCoin({
-    tx,
-    suiClient,
-    bidder,
-    nftType,
-    bidAmount,
-    marketFeePrice,
-    royaltyRulePackageId,
-    royaltyRuleModule,
-    transferPolicyId
-  });
-  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]
-  });
-  destroyZeroCoin({ tx, coin });
-}
-async function addKumoTradePortKioskPlaceNftBidTx({
-  tx,
-  suiClient,
-  bidder,
-  collectionId,
-  nftTokenId,
-  nftType,
-  bidAmount,
-  royaltyRulePackageId,
-  royaltyRuleModule
-}) {
-  const transferPolicyId = await getKioskTransferPolicies(nftType).then(
-    (policies) => policies?.[0]?.id
-  );
-  const marketFeePrice = getMarketFeePrice({ price: bidAmount, collectionId });
-  const coin = await getKioskPlaceBidCoin({
-    tx,
-    suiClient,
-    bidder,
-    nftType,
-    bidAmount,
-    marketFeePrice,
-    royaltyRulePackageId,
-    royaltyRuleModule,
-    transferPolicyId
-  });
-  const kumoAttributes = await fetchKumoNftAttributes(suiClient, nftTokenId);
-  const normalizedAttributes = normalizeKumoAttributes(kumoAttributes);
-  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))
-    ],
-    typeArguments: [nftType]
-  });
-  destroyZeroCoin({ tx, coin });
-}
-async function addTradePortPlaceNftBidTxHandler(txData) {
-  if (isOriginByteTx(txData?.sharedObjects) && !ORIGIN_BYTE_NFT_TYPES_MISSING_ORDERBOOK?.includes(normalizedNftType(txData?.nftType))) {
-    throw new Error("OriginByte bidding not supported currently");
-  }
-  if (await hasTransferPolicyRules(txData?.nftType) && txData?.sellerKiosk) {
-    const royaltyRuleModule = getRoyaltyRuleModule(txData?.nftType);
-    const royaltyRulePackageId = await getRulePackageId({
-      nftType: txData?.nftType,
-      ruleType: royaltyRuleModule,
-      kioskClient: txData?.kioskClient
-    });
-    if (txData?.collectionId === "67aca668-31b0-4713-91cf-079d392b041a") {
-      await addKumoTradePortKioskPlaceNftBidTx({
-        ...txData,
-        royaltyRulePackageId,
-        royaltyRuleModule
-      });
-      return;
-    }
-    await addTradePortKioskPlaceNftBidTx({ ...txData, royaltyRulePackageId, royaltyRuleModule });
-    return;
-  }
-  addTradePortPlaceNftBidTx(txData);
-}
-async function fetchKumoNftAttributes(suiClient, nftTokenId) {
-  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 { accessory, background, eyes, fur_colour, mouth, tail, one_of_one } = res.data?.content?.fields || {};
-  return { accessory, background, eyes, fur_colour, mouth, tail, one_of_one };
-}
-function normalizeKumoAttributes(attributes) {
-  const normalizeAttribute = (attr) => !attr || attr === "Default" || attr === "None" ? null : attr;
-  return Object.fromEntries(
-    Object.entries(attributes).map(([key, value]) => [key, normalizeAttribute(value)])
-  );
-}
-
-// src/methods/placeNftBids/placeNftBids.ts
-var placeNftBids = async ({ nfts, walletAddress }, context) => {
+var placeNftBids = async ({ nfts, walletAddress, multiBidId, multiBidChainId, expireAt, tx: existingTx }, context) => {
+  const tx = existingTx ?? new import_transactions18.Transaction();
   const res = await gqlChainRequest({
     chain: "sui",
     query: fetchNftsById,
@@ -5768,7 +5699,6 @@ var placeNftBids = async ({ nfts, walletAddress }, context) => {
     throw new Error("No nfts found");
   }
   const nftsForTracking = [];
-  const tx = new import_transactions18.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);
@@ -5782,14 +5712,16 @@ var placeNftBids = async ({ nfts, walletAddress }, context) => {
     const txData = {
       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);
     nftsForTracking.push({
@@ -5849,8 +5781,27 @@ function addTocenRemoveNftBidTx({ tx, nftTokenId, bidAmount }) {
     typeArguments: []
   });
 }
+async function addSingleBidRemoveNftBidTx({ tx, bidNonce, multiBidId }) {
+  const multiBidChainId = multiBidId ? (await gqlChainRequest({
+    chain: "sui",
+    query: fetchMultibidChainIdById,
+    variables: { multiBidId }
+  }))?.multi_bids?.[0]?.chain_id : void 0;
+  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)
+    ]
+  });
+}
 async function addTradePortRemoveNftBidTxHandler(txData) {
   const bidType = await getObjectType({ suiClient: txData?.suiClient, objectId: txData?.bidNonce });
+  if (isSingleBid(bidType)) {
+    await addSingleBidRemoveNftBidTx(txData);
+    return;
+  }
   if (isOriginByteBid(bidType)) {
     addOriginByteRemoveNftBidTx(txData);
     return;
@@ -5933,6 +5884,10 @@ async function addTradePortRemoveCollectionBidTxHandler(txData) {
 }
 async function addBluemoveRemoveCollectionBidTxHandler(txData) {
   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 });
@@ -6040,7 +5995,8 @@ var removeNftBids = async ({ bidIds, tx: existingTx }, context) => {
       nftTokenId: bid?.nft?.token_id,
       bidAmount: bid?.price,
       sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
-      bidMarketName: bid?.market_contract?.name
+      bidMarketName: bid?.market_contract?.name,
+      multiBidId: bid?.multi_bid_id
     };
     switch (txData.bidMarketName) {
       case "tradeport":
@@ -6316,6 +6272,94 @@ async function withdrawProfitsFromKiosks({ walletAddress }, context) {
   return import_transactions23.Transaction.from(tx);
 }
 
+// src/methods/createMultiBid/createMultiBid.ts
+var import_transactions25 = require("@mysten/sui/transactions");
+
+// src/methods/updateMultiBid/updateMultiBid.ts
+var import_transactions24 = require("@mysten/sui/transactions");
+async function updateMultiBid({
+  multiBidId,
+  name,
+  amount,
+  amountToWithdraw,
+  tx: existingTx,
+  multiBidChainId
+}) {
+  const tx = existingTx ?? new import_transactions24.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;
+}
+
+// src/methods/createMultiBid/createMultiBid.ts
+async function createMultiBid({
+  walletAddress,
+  name,
+  amount,
+  tx: existingTx
+}) {
+  const tx = existingTx ?? new import_transactions25.Transaction();
+  const multiBidChainId = tx.moveCall({
+    target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::create_multi_bid`,
+    arguments: [tx.object(TRADEPORT_MULTI_BID_STORE), tx.pure.option("string", name)]
+  });
+  if (amount > 0n) {
+    await updateMultiBid({
+      walletAddress,
+      multiBidChainId,
+      amount,
+      name,
+      tx
+    });
+  }
+  return { multiBidChainId, tx };
+}
+
+// src/methods/cancelMultiBid/cancelMultiBid.ts
+var import_transactions26 = require("@mysten/sui/transactions");
+async function cancelMultiBid({ multiBidId }) {
+  const { chain_id: multiBidChainId, cancelled_at } = (await gqlChainRequest({
+    chain: "sui",
+    query: fetchMultibidChainIdById,
+    variables: { multiBidId }
+  }))?.multi_bids?.[0] ?? {};
+  if (!multiBidChainId) {
+    throw new Error(`MultiBid ${multiBidId} not found`);
+  }
+  if (cancelled_at) {
+    throw new Error(`MultiBid ${multiBidId} already cancelled`);
+  }
+  const tx = new import_transactions26.Transaction();
+  tx.moveCall({
+    target: `${TRADEPORT_MULTI_BID_PACKAGE}::tradeport_biddings::cancel_multi_bid`,
+    arguments: [tx.object(TRADEPORT_MULTI_BID_STORE), tx.pure.id(multiBidChainId)]
+  });
+  return tx;
+}
+
 // src/SuiTradingClient.ts
 var SuiTradingClient = class {
   constructor({ apiUser, apiKey, suiNodeUrl, graphQLClient }) {
@@ -6359,14 +6403,14 @@ var SuiTradingClient = class {
     };
     return unlistListings({ listingIds, walletAddress }, context);
   }
-  async placeNftBids({ nfts, walletAddress }) {
+  async placeNftBids(data) {
     const context = {
       apiUser: this.apiUser,
       apiKey: this.apiKey,
       suiClient: this.suiClient,
       kioskClient: this.kioskClient
     };
-    return placeNftBids({ nfts, walletAddress }, context);
+    return placeNftBids(data, context);
   }
   async removeNftBids({ bidIds, tx }) {
     const context = {
@@ -6390,7 +6434,10 @@ var SuiTradingClient = class {
     collectionId,
     bidAmountInMist,
     numOfBids,
-    walletAddress
+    walletAddress,
+    multiBidId,
+    multiBidChainId,
+    expireAt
   }) {
     const context = {
       apiUser: this.apiUser,
@@ -6407,7 +6454,10 @@ var SuiTradingClient = class {
             numOfBids
           }
         ],
-        walletAddress
+        walletAddress,
+        multiBidId,
+        multiBidChainId,
+        expireAt
       },
       context
     );
@@ -6632,6 +6682,15 @@ var SuiTradingClient = class {
     };
     return migrateNftsFromUnsharedToSharedKiosks(args, context);
   }
+  async createMultiBid(args) {
+    return createMultiBid(args);
+  }
+  async cancelMultiBid(args) {
+    return cancelMultiBid(args);
+  }
+  async updateMultiBid(args) {
+    return updateMultiBid(args);
+  }
 };
 var SuiTradingClient_default = SuiTradingClient;
 // Annotate the CommonJS export names for ESM import in node: