@tradeport/sui-trading-sdk 0.0.0

package/dist/index.mjs

@@ -0,0 +1,3733 @@
+// src/apiClients/graphqlClient.ts
+import { GraphQLClient } from "graphql-request";
+var graphqlClient = new GraphQLClient("https://api.indexer.xyz/graphql");
+var graphqlClient_default = graphqlClient;
+
+// src/apiClients/suiClient.ts
+import { SuiClient } from "@mysten/sui.js/client";
+var suiClient = new SuiClient({ url: "https://rpc-mainnet.suiscan.xyz/" });
+var suiClient_default = suiClient;
+
+// src/graphql/createChainGQLQuery.ts
+import { gql } from "graphql-request";
+function createChainGQLQuery({ chain, query }) {
+  const regex = /query\s+(\w+)\s*\((.*?)\)\s*{([\s\S]*)}/;
+  const matches = regex.exec(query);
+  if (!matches || matches.length !== 4) {
+    throw new Error("Invalid query string format");
+  }
+  const [, queryName, argsString, bodyString] = matches;
+  if (!argsString || !bodyString)
+    return "";
+  const args = argsString.trim().length ? `(${argsString.trim()})` : "";
+  const body = bodyString.trim();
+  const wrappedBody = `${chain} {
+${body}
+}`;
+  return gql`query ${queryName}${args} {\n${wrappedBody}\n}`;
+}
+
+// src/graphql/gqlChainRequest.ts
+var gqlChainRequest = async ({ chain, query, variables }) => {
+  if (!chain || !query) {
+    throw new Error("Missing required arguments");
+  }
+  const response = await graphqlClient_default.request(
+    createChainGQLQuery({ chain, query }),
+    variables
+  );
+  return response?.[chain];
+};
+
+// src/graphql/queries/fetchCollectionBidById.ts
+import { gql as gql2 } from "graphql-request";
+var fetchCollectionBidById = gql2`
+	query fetchCollectionBidById($bidId: uuid!) {
+		bids(where: { id: { _eq: $bidId } }) {
+			nonce
+			price
+			bidder
+			status
+			type
+			collection_id
+			contract {
+				properties
+			}
+			market_contract {
+				name
+			}
+		}
+	}
+`;
+
+// src/graphql/queries/fetchCollectionBidsAtSamePrice.ts
+import { gql as gql3 } from "graphql-request";
+var fetchCollectionBidsAtSamePrice = gql3`
+	query fetchCollectionBidsAtSamePrice($collectionId: uuid!, $price: numeric) {
+		bids(
+			where: {
+				collection_id: { _eq: $collectionId }
+				price: { _eq: $price }
+				status: { _eq: "active" }
+				type: { _eq: "collection" }
+			}
+			order_by: { price: desc }
+		) {
+			nonce
+			price
+			bidder
+			status
+			type
+			collection_id
+			contract {
+				properties
+			}
+			market_contract {
+				name
+			}
+		}
+	}
+`;
+
+// src/methods/acceptCollectionBid/acceptCollectionBid.ts
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+
+// src/graphql/queries/fetchNftsById.ts
+import { gql as gql4 } from "graphql-request";
+var fetchNftById = gql4`
+	query fetchNftById($nftId: uuid!) {
+		nfts(where: { id: { _eq: $nftId } }) {
+			id
+			token_id
+			collection_id
+			properties
+			chain_state
+			listed
+			owner
+			contract {
+				properties
+			}
+			listings(where: { listed: { _eq: true } }) {
+				price
+				nonce
+				market_name
+			}
+		}
+	}
+`;
+var fetchNftsById = gql4`
+	query fetchNftsById($nftIds: [uuid!]) {
+		nfts(where: { id: { _in: $nftIds } }) {
+			id
+			token_id
+			collection_id
+			properties
+			chain_state
+			listed
+			contract {
+				properties
+			}
+		}
+	}
+`;
+var fetchNftsWithListingsById = gql4`
+	query fetchNftsWithListingsById($nftIds: [uuid!]) {
+		nfts(where: { id: { _in: $nftIds } }) {
+			id
+			token_id
+			collection_id
+			properties
+			chain_state
+			listed
+			contract {
+				properties
+			}
+			listings(where: { listed: { _eq: true } }) {
+				listed
+				market_name
+				price
+				nonce
+			}
+		}
+	}
+`;
+
+// src/helpers/getNftTypeFromNft.ts
+var getNftTypeFromNft = (nft) => {
+  let nftType = nft?.properties?.nft_type;
+  if (!nftType || nftType?.split("::")?.length <= 1) {
+    nftType = nft?.contract?.properties?.nft_type;
+  }
+  return nftType;
+};
+
+// src/constants.ts
+var TRADEPORT_BENEFICIARY_ADDRESS = "0xbca3b5c01c8d1a93aed3a036feff45145518292dd3c1db1d67cc99a699a7b517";
+var TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT = 0.03;
+var TRADEPORT_THIRD_PARTY_FEE_DECIMAL_PERCENT = 5e-3;
+var TRADEPORT_LISTING_STORE = "0x47cba0b6309a12ce39f9306e28b899ed4b3698bce4f4911fd0c58ff2329a2ff6";
+var TRADEPORT_BIDDING_STORE = "0x3d3b0c6e616fdc1a45b2b73d022bc085448e78bd729d28081c7a340abb33cba1";
+var TRADEPORT_KIOSK_LISTING_STORE = "0xbff3161b047fb8b727883838c09b08afa9e0dd0f5488bde9e99e80643da9b9e0";
+var TRADEPORT_KIOSK_TRANSFERS_STORE = "0xe0f61b6915d3fd4ec8bbe4618514e2152a82841605bfa00cde22ace434153a1b";
+var TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK = "0xa677dab85a93bd8d6845b6cc7914f3bbb334fef7fbcbe0e997b5f75b5922d106";
+var TRADEPORT_KIOSK_BIDDING_STORE = "0x1e5e7f38e3a61d1d189506d0fc6b7e47e935a292d9e1b23c0f3f1c0f94227772";
+var TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK = "0x151fbe627d3f8de855f424c879ea2176d89282185a4b9226a7157172dd2919cc";
+var TRADEPORT_KIOSK_BID_NONCE_TYPE = "0xec175e537be9e48f75fa6929291de6454d2502f1091feb22c0d26a22821bbf28::kiosk_biddings::Bid";
+var COLLECTION_IDS_WITH_ZERO_COMMISSION = [
+  ""
+];
+var ORIGIN_BYTE_ALLOW_LIST_OBJECT = "0xb9353bccfb7ad87b9195c6956b2ac81551350b104d5bfec9cf0ea6f5c467c6d1";
+var STORKS_ORIGIN_BYTE_ALLOW_LIST = "0x2566a35b1703ea3a67dda8a4cd25a77382543a9faad15a1028eaa7592fbcd0ca";
+var SUISHI_ORIGIN_BYTE_ALLOW_LIST_OBJECT = "0xa9afd6ac0b5a68710992ebc145b9be4e764628dfffebbccb065ed891948f7d7c";
+var FUDDIES_ORIGIN_BYTE_ALLOW_LIST_OBJECT = "0x1ae174e8e2f238648d5fbef41e2b435b7285e678aa5e2e7db27f1be006ab242c";
+var CRYPTOPEDIA_ORIGIN_BYTE_ALLOW_LIST_OBJECT = "0x3bbe09ea50c49f58e2c4915bed1b19ffdce43e6a3763be44a4fdd8c5d8cb3f32";
+var GNOMES_ORIGIN_BYTE_ALLOW_LIST_OBJECT = "0xa830cf84682a597cdf3337bf1917492a0eea78a0135384060d675d4808daa318";
+var SACABAM_ORIGIN_BYTE_ALLOW_LIST_OBJECT = "0x6ec53faee01f3e193501b84e98a43915228faa2df3f070ef069f57d0ed7601ca";
+var SUI_ECOSYSTEM_ORIGIN_BYTE_ALLOW_LIST_OBJECT = "0x86f62b145974165fa53a8ac167de61a0fd0f9f7206dc67ac118fb3ac63b80476";
+var BLUEMOVE_MARKET_CONFIG_OBJECT = "0x09e24b156b08e7bc5272f9b731e93b80b458f0b79a5195eb81a471d514f1b1b8";
+var BLUEMOVE_ROYALTY_COLLECTION_OBJECT = "0xbf471e4f38f76ed88f18e44f3dce2c27e03c1857d51ea17cd9b230b6d69b4bc1";
+var BLUEMOVE_CREATOR_CONFIG_OBJECT = "0x6bdeb62b036f5f9c3f0587a0480e6dd75cb4e758660cf30b542c031fa394bb83";
+var BLUEMOVE_OFFER_DATA_OBJECT = "0x4a8e6a4634e3dedae00ffe9f065351664ba32d7e9c2d26221a666ca380ea68b9";
+var BLUEMOVE_OFFER_COLLECTION_DATA_OBJECT = "0xd1def3ba244a0cb3d248cd3e72078cae869c05b4f03ccc9289998188b1d7b768";
+var BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT = "0x7ffb33136bcf4a69fefd9b962c5e47f9213c79cf4f443dd2a39ab17a1424ba6f";
+var BLUEMOVE_KIOSK_OFFER_COLLECTION_DATA_OBJECT = "0xd29edb24787f6b128018de0a2a513cdf63a48f7c256ecad1186cba3c6a45cb55";
+var BLUEMOVE_KIOSK_OFFER_COLLECTION_BIDDER_BAG = "0x15708d74504203a9620779583f8e63f2b5a599b28dd3a7d9063ab41e6fb75942";
+var SOUFFL3_MARKETPLACE_OBJECT = "0x0ad62c9d9c5b06b60c1f2e7da6659f7408636c11392651444dfdc5f5930d5dce";
+var SOUFFL3_VERSION_OBJECT = "0x2c012a80a7fab8fe025d3d5be531227ccebbaa86d85cb56d09d235b1f3209cef";
+var SOUFFL3_EXTENSION_OBJECT = "0xa3e5b249961bae7270af1484687b7d924d6364476119f687564dba0530055e6f";
+var SOUFFL3_GENERIC_BUY_METHOD_COLLECTIONS = [
+  "f7ccba9d-04f8-49c4-8e1f-d264b122584d",
+  "86a437d7-e073-4365-8455-a4f2d983f840",
+  "d8863069-7281-4809-b66c-30bb80d47967",
+  "f447de12-64f1-490a-b8e5-636d4e778a61",
+  "f6cf1905-8378-44c5-98aa-ef6b20d0a527",
+  "19569440-6dfb-42af-8189-59fff6fa9905"
+];
+var KEEPSAKE_MARKETPLACE_OBJECT = "0x08f446892306164934c0622388d8220961a9d08bc143888b6c923bb97a179ea8";
+var KEEPSAKE_MARKETPLACE_KIOSK = "0xfaf1b99c273737e914da13324ee1191f42346643083892d3f6f09a2d246967e5";
+var TOCEN_MARKETPLACE_OBJECT = "0xb2b140b2841329320b66f92373a2683af7f9066472233effab03755270bcf65f";
+var HYPERSPACE_TRANSFER_POLICY_TYPE = "0x9a84b6a7914aedd6741e73cc2ca23cbc77e22ed3c5f884c072a51868fedde45b::hyperspace::Hyperspace";
+var HYPERSPACE_MP_TRANSFER_POLICY_TYPE = "0x9a84b6a7914aedd6741e73cc2ca23cbc77e22ed3c5f884c072a51868fedde45b::hyperspace_mp::Hyperspace_mp";
+var NON_KIOSK_LISTING_NONCE_TYPE = "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::Listing";
+var ORIGIN_BYTE_BID_NONCE_TYPE = "0x4e0629fa51a62b0c1d7c7b9fc89237ec5b6f630d7798ad3f06d820afb93a995a::bidding::Bid<0x2::sui::SUI>";
+var MASC_ROYALTY_DECIMAL_PERCENT = 0.085;
+var BASC_ROYALTY_DECIMAL_PERCENT = 0.055;
+var DSL_LEGACY_ROYALTY_DECIMAL_PERCENT = 0.05;
+
+// src/graphql/queries/fetchSharedObjectsByType.ts
+import { gql as gql5 } from "graphql-request";
+var fetchSharedObjectsByType = gql5`
+	query fetchSharedObjectsByType($type: String!) {
+		sharedObjects: shared_objects_by_type(type: $type) {
+			id
+			module
+			pkg
+			type
+		}
+	}
+`;
+
+// src/utils/addLeadingZerosAfter0x.ts
+var addLeadingZerosAfter0x = (str) => `0x${str?.replace("0x", "").padStart(64, "0")}`;
+
+// src/helpers/getSharedObjects.ts
+var getSharedObjects = async (nftType) => {
+  const nftTypeSplit = nftType?.split("::");
+  if (nftTypeSplit?.[0])
+    nftTypeSplit[0] = addLeadingZerosAfter0x(nftTypeSplit[0]);
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchSharedObjectsByType,
+    variables: { type: nftTypeSplit?.join("::") }
+  });
+  let allowList = res?.sharedObjects?.filter((object) => object?.module === "allowlist")?.[0]?.id;
+  if (!allowList)
+    allowList = ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+  if (nftType === "0x5f1fa51a6d5c52df7dfe0ff7efaab7cc769d81e51cf208a424e455575aa1ed7a::stork::Stork") {
+    allowList = STORKS_ORIGIN_BYTE_ALLOW_LIST;
+  }
+  if (nftType === "0xf1681f601a1c021a0b4c8c8859d50917308fcbebfd19364c4e856ac670bb8496::suishi::Suishi") {
+    allowList = SUISHI_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+  }
+  if (nftType?.includes(
+    "ac176715abe5bcdaae627c5048958bbe320a8474f524674f3278e31af3c8b86b::fuddies::Fuddies"
+  )) {
+    allowList = FUDDIES_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+  }
+  if (nftType === "0x71bd3651e47a7590e607b976a332338e2230e995fa96de430703af537086b643::cryptopedia::Cryptopedia") {
+    allowList = CRYPTOPEDIA_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+  }
+  if (nftType === "0xe81341eba87d19f8d53ee237b3666cff6a74c9fd7a960cf5753af69bc7c6a221::gnomes::Gnome") {
+    allowList = GNOMES_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+  }
+  if (nftType === "0x7f481ffff2b72f3f1d9b70d5ad999d8b514a6281aa29aedbb6c537bd4b0d04ad::sacabam::Sacabam") {
+    allowList = SACABAM_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+  }
+  if (nftType === "0x5fe8e884960f6977f813d871a3d43049d72d19d4ad07819b979c06434f60af4d::mint::SuiEcosystemNFT") {
+    allowList = SUI_ECOSYSTEM_ORIGIN_BYTE_ALLOW_LIST_OBJECT;
+  }
+  let transferPolicy = res?.sharedObjects?.filter(
+    (object) => object?.module === "transfer_policy"
+  )?.[0]?.id;
+  if (nftTypeSplit?.join("::")?.includes("keepsake_nft::KEEPSAKE")) {
+    transferPolicy = res?.sharedObjects?.filter(
+      (object) => object?.type?.includes(
+        "0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::transfer_policy::TransferPolicy"
+      )
+    )?.[0]?.id;
+  }
+  return {
+    orderbook: res?.sharedObjects?.filter((object) => object?.module === "orderbook")?.[0]?.id,
+    collection: res?.sharedObjects?.filter((object) => object?.module === "collection")?.[0]?.id,
+    marketplace: res?.sharedObjects?.filter((object) => object?.module === "marketplace")?.[0]?.id,
+    royaltyStrategy: res?.sharedObjects?.filter(
+      (object) => object?.module === "royalty_strategy_bps"
+    )?.[0]?.id,
+    keepsakeRoyaltyStrategy: res?.sharedObjects?.filter(
+      (object) => object?.module === "keepsake_royalties"
+    )?.[0]?.id,
+    transferPolicy,
+    allowList
+  };
+};
+
+// src/apiClients/kioskClient.ts
+import { KioskClient, Network } from "@mysten/kiosk";
+var kioskClient = new KioskClient({
+  // @ts-ignore
+  client: suiClient_default,
+  network: Network.MAINNET
+});
+var kioskClient_default = kioskClient;
+
+// src/helpers/hasTransferPolicyRules.ts
+var hasTransferPolicyRules = async (nftType) => {
+  const nftTypeSplit = nftType?.split("::");
+  if (nftTypeSplit?.[0])
+    nftTypeSplit[0] = addLeadingZerosAfter0x(nftTypeSplit[0]);
+  const res = await kioskClient_default.getTransferPolicies({ type: nftTypeSplit?.join("::") });
+  return res?.some((policy) => policy?.rules?.length > 0);
+};
+
+// src/helpers/kiosk/getRulePackageId.ts
+import { getNormalizedRuleType } from "@mysten/kiosk";
+
+// src/utils/addHexPrefix.ts
+function addHexPrefix(input) {
+  if (input.startsWith("0x")) {
+    return input;
+  }
+  return "0x" + input;
+}
+
+// src/helpers/kiosk/getRulePackageId.ts
+var getRulePackageId = async (nftType, ruleType) => {
+  const transferPolicies = await kioskClient_default.getTransferPolicies({
+    type: nftType
+  });
+  const rule = transferPolicies.flatMap((policy) => policy.rules).filter((rule2) => rule2?.split("::")?.[1] === ruleType)?.[0];
+  const ruleDefinition = kioskClient_default.rules.find(
+    (x) => getNormalizedRuleType(x.rule) === getNormalizedRuleType(rule)
+  );
+  let rulePackageId = ruleDefinition?.packageId;
+  if (!rulePackageId) {
+    rulePackageId = rule?.split("::")?.[0];
+  }
+  return addHexPrefix(rulePackageId);
+};
+
+// src/helpers/kiosk/isBluemoveKioskBid.ts
+var isBluemoveKioskBid = (bidNonce) => bidNonce?.startsWith("10000");
+
+// src/helpers/kiosk/isTradePortKioskBid.ts
+var isTradePortKioskBid = (bidType) => bidType === TRADEPORT_KIOSK_BID_NONCE_TYPE;
+
+// src/helpers/kiosk/kioskTxWrapper.ts
+import { KioskTransaction } from "@mysten/kiosk";
+
+// src/graphql/queries/fetchKiosksByOwner.ts
+import { gql as gql6 } from "graphql-request";
+var fetchKiosksByOwner = gql6`
+	query fetchKiosksByOwner($ownerAddress: String!) {
+		kiosks: kiosks_by_owner_address(owner_address: $ownerAddress) {
+			id
+			is_origin_byte
+			is_personal
+			owner_address
+			profits
+		}
+	}
+`;
+
+// src/graphql/queries/fetchOwnerCapByKiosk.ts
+import { gql as gql7 } from "graphql-request";
+var fetchOwnerCapByKiosk = gql7`
+	query fetchOwnerCapByKiosk($kioskId: String!) {
+		ownerCap: kiosk_owner_cap_by_kiosk(kiosk_id: $kioskId) {
+			id
+			kiosk_id
+		}
+	}
+`;
+
+// src/graphql/queries/fetchPersonalCapByKiosk.ts
+import { gql as gql8 } from "graphql-request";
+var fetchPersonalCapByKiosk = gql8`
+	query fetchPersonalCapByKiosk($kioskId: String!) {
+		personalCap: personal_kiosk_cap_by_kiosk(kiosk_id: $kioskId) {
+			id
+			kiosk_id
+		}
+	}
+`;
+
+// src/helpers/kiosk/kioskTxWrapper.ts
+var kioskTxWrapper = async ({
+  txBlock,
+  kioskOwner,
+  kiosk,
+  tx,
+  shouldConvertToPersonalKiosk
+}) => {
+  let kioskTx;
+  let kiosks = (await gqlChainRequest({
+    chain: "sui",
+    query: fetchKiosksByOwner,
+    variables: { ownerAddress: addLeadingZerosAfter0x(kioskOwner) }
+  })).kiosks ?? [];
+  kiosks = kiosks?.filter((k) => !k.is_origin_byte);
+  if (kiosk) {
+    const filteredKiosks = kiosks.filter((k) => k?.id === kiosk);
+    if (filteredKiosks.length > 0) {
+      kiosks = filteredKiosks;
+    }
+  }
+  const personalKiosk = kiosks.find((k) => k.is_personal);
+  if (personalKiosk) {
+    const personalKioskCapId = (await gqlChainRequest({
+      chain: "sui",
+      query: fetchPersonalCapByKiosk,
+      variables: { kioskId: personalKiosk.id }
+    })).personalCap.id;
+    kioskTx = new KioskTransaction({
+      transactionBlock: txBlock,
+      kioskClient: kioskClient_default,
+      cap: {
+        isPersonal: true,
+        objectId: personalKioskCapId,
+        kioskId: personalKiosk.id,
+        digest: "",
+        version: ""
+      }
+    });
+  } else if (kiosks.length > 0) {
+    const kioskCapId = (await gqlChainRequest({
+      chain: "sui",
+      query: fetchOwnerCapByKiosk,
+      variables: { kioskId: kiosks[0].id }
+    })).ownerCap?.id;
+    kioskTx = new KioskTransaction({
+      transactionBlock: txBlock,
+      kioskClient: kioskClient_default,
+      cap: {
+        isPersonal: false,
+        objectId: kioskCapId,
+        kioskId: kiosks[0].id,
+        digest: "",
+        version: ""
+      }
+    });
+    if (shouldConvertToPersonalKiosk) {
+      kioskTx.convertToPersonal(true);
+    }
+  } else {
+    kioskTx = new KioskTransaction({ transactionBlock: txBlock, kioskClient: kioskClient_default });
+    kioskTx.createPersonal(true);
+  }
+  await tx(kioskTx);
+  kioskTx.finalize();
+};
+
+// src/helpers/originByte/confirmOBTranfer.ts
+var confirmOBTranfer = ({ txBlock, sharedObjects, transferRequest, nftType }) => {
+  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"]
+  });
+};
+
+// src/helpers/originByte/depositNftIntoOBKiosk.ts
+var depositItemIntoOBKiosk = ({ txBlock, kiosk, nftTokenId, nftType }) => {
+  txBlock.moveCall({
+    target: "0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::deposit",
+    arguments: [txBlock.object(kiosk), txBlock.pure(nftTokenId)],
+    typeArguments: [nftType]
+  });
+};
+
+// src/helpers/originByte/createOBKiosk.ts
+var createOBKiosk = async ({ txBlock, createMethod = "new" }) => {
+  const [kiosk] = txBlock.moveCall({
+    target: `0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::${createMethod}`,
+    arguments: [],
+    typeArguments: []
+  });
+  return [kiosk];
+};
+
+// src/helpers/originByte/getOBKiosk.ts
+import { gql as gql9 } from "graphql-request";
+var fetchAccountKiosks = gql9`
+	query fetchAccountKiosks($accountAddress: String!) {
+		kiosks: kiosks_by_owner_address(owner_address: $accountAddress) {
+			id
+			is_origin_byte
+			owner_address
+			profits
+		}
+	}
+`;
+var getOBKiosk = async (accountAddress) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchAccountKiosks,
+    variables: { accountAddress: addLeadingZerosAfter0x(accountAddress) }
+  });
+  return res?.kiosks?.filter((kiosk) => kiosk?.is_origin_byte)?.[0]?.id;
+};
+
+// src/helpers/originByte/getOrCreateOBKiosk.ts
+var getOrCreateOBKiosk = async ({
+  txBlock,
+  address,
+  kioskToUseIfExists,
+  createMethod
+}) => {
+  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
+  };
+};
+
+// src/helpers/originByte/isOriginByteBid.ts
+var isOriginByteBid = (bidType) => bidType === ORIGIN_BYTE_BID_NONCE_TYPE || bidType === "0x2::Kiosk::Kiosk" || bidType === "0x2::kiosk::Kiosk";
+
+// src/helpers/originByte/isOriginByteTx.ts
+var isOriginByteTx = (sharedObjects) => Boolean(sharedObjects?.orderbook && sharedObjects?.collection);
+
+// src/helpers/originByte/shareOriginByteKiosk.ts
+var shareOriginByteKiosk = async ({ txBlock, kiosk }) => {
+  txBlock.moveCall({
+    target: "0x2::transfer::public_share_object",
+    arguments: [txBlock.object(kiosk)],
+    typeArguments: ["0x2::kiosk::Kiosk"]
+  });
+};
+
+// src/helpers/rpc/getObjectType.ts
+var getObjectType = async (objectId) => {
+  try {
+    const res = await suiClient_default.getObject({ id: objectId, options: { showType: true } });
+    return res?.data?.type;
+  } catch (err) {
+    return "";
+  }
+};
+
+// src/helpers/kiosk/resolveTransferPolicies.ts
+import { getNormalizedRuleType as getNormalizedRuleType2 } from "@mysten/kiosk";
+
+// src/helpers/kiosk/resolveFloorPriceRule.ts
+function resolveFloorPriceRule({
+  txBlock,
+  packageId,
+  nftType,
+  policyId,
+  transferRequest
+}) {
+  txBlock.moveCall({
+    target: `${packageId}::floor_price_rule::prove`,
+    typeArguments: [nftType],
+    arguments: [txBlock.object(policyId), transferRequest]
+  });
+}
+
+// src/helpers/kiosk/resolveKioskLockRule.ts
+function resolveKioskLockRule({
+  txBlock,
+  packageId,
+  policyId,
+  transferRequest,
+  nftType,
+  kiosk,
+  kioskCap,
+  kioskItem,
+  shouldSkipLocking
+}) {
+  if (!kiosk || !kioskCap)
+    throw new Error("Missing Owned Kiosk or Owned Kiosk Cap");
+  if (!shouldSkipLocking) {
+    if (!kioskItem)
+      throw new Error("Missing Kiosk Item");
+    txBlock.moveCall({
+      target: "0x2::kiosk::lock",
+      typeArguments: [nftType],
+      arguments: [
+        txBlock.object(kiosk),
+        txBlock.object(kioskCap),
+        txBlock.object(policyId),
+        txBlock.object(kioskItem)
+      ]
+    });
+  }
+  txBlock.moveCall({
+    target: `${packageId}::kiosk_lock_rule::prove`,
+    typeArguments: [nftType],
+    arguments: [transferRequest, txBlock.object(kiosk)]
+  });
+}
+
+// src/helpers/kiosk/resolvePersonalKioskRule.ts
+function resolvePersonalKioskRule({
+  txBlock,
+  packageId,
+  nftType,
+  kiosk,
+  transferRequest
+}) {
+  if (!kiosk)
+    throw new Error("Missing owned Kiosk.");
+  txBlock.moveCall({
+    target: `${packageId}::personal_kiosk_rule::prove`,
+    typeArguments: [nftType],
+    arguments: [txBlock.object(kiosk), transferRequest]
+  });
+}
+
+// src/helpers/kiosk/resolveRoyaltyRule.ts
+function resolveRoyaltyRule({
+  txBlock,
+  packageId,
+  moduleName,
+  policyId,
+  transferRequest,
+  nftType,
+  price,
+  priceObjectArgument
+}) {
+  const [amount] = txBlock.moveCall({
+    target: `${packageId}::${moduleName}::fee_amount`,
+    typeArguments: [nftType],
+    arguments: [
+      txBlock.object(policyId),
+      priceObjectArgument ? txBlock.object(priceObjectArgument) : txBlock.pure(price || "0")
+    ]
+  });
+  const feeCoin = txBlock.splitCoins(txBlock.gas, [amount]);
+  txBlock.moveCall({
+    target: `${packageId}::${moduleName}::pay`,
+    typeArguments: [nftType],
+    arguments: [txBlock.object(policyId), transferRequest, feeCoin]
+  });
+}
+
+// src/helpers/kiosk/resolveTransferPolicies.ts
+var resolveTransferPolicies = async ({
+  txBlock,
+  kioskTx,
+  nftType,
+  kioskToLockRuleProve,
+  kioskItem,
+  transferRequest,
+  customTransferPolicies,
+  price,
+  priceObjectArgument,
+  shouldSkipKioskLocking,
+  shouldSkipResolvingRoyaltyRule
+}) => {
+  const transferPolicies = await kioskClient_default.getTransferPolicies({
+    type: nftType
+  });
+  let policies = transferPolicies.length > 0 ? [
+    {
+      data: transferPolicies[0],
+      transferRequest,
+      isCustom: false
+    }
+  ] : [];
+  if (customTransferPolicies) {
+    for (const customTransferPolicy of customTransferPolicies) {
+      const customPolicy = await kioskClient_default.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_default.rules.find(
+        (x) => getNormalizedRuleType2(x.rule) === getNormalizedRuleType2(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 });
+  }
+};
+
+// src/helpers/originByte/getOBBidderKiosk.ts
+var getOBBidderKiosk = async (bidNonce) => {
+  const bidObject = await suiClient_default.call("sui_getObject", [
+    bidNonce,
+    { showContent: true }
+  ]);
+  return bidObject.data?.content?.fields?.kiosk;
+};
+
+// src/methods/acceptNftBids/addAcceptNftBidTxs.ts
+function addTradeportAcceptNftBidTx({
+  txBlock,
+  sharedObjects,
+  bidNonce,
+  nftTokenId,
+  nftType
+}) {
+  const { collection, royaltyStrategy } = sharedObjects;
+  if (collection && royaltyStrategy) {
+    txBlock.moveCall({
+      target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::ob_accept_bid",
+      arguments: [
+        txBlock.object(TRADEPORT_BIDDING_STORE),
+        txBlock.pure(bidNonce),
+        txBlock.pure(nftTokenId),
+        txBlock.object(collection),
+        txBlock.object(royaltyStrategy)
+      ],
+      typeArguments: [nftType]
+    });
+  } else {
+    txBlock.moveCall({
+      target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::accept_bid",
+      arguments: [
+        txBlock.object(TRADEPORT_BIDDING_STORE),
+        txBlock.pure(bidNonce),
+        txBlock.pure(nftTokenId)
+      ],
+      typeArguments: [nftType]
+    });
+  }
+}
+async function addTradeportKioskAcceptNftBidTx({
+  txBlock,
+  sharedObjects,
+  kioskTx,
+  bidNonce,
+  nftTokenId,
+  nftType,
+  royaltyRulePackageId
+}) {
+  const { transferPolicy } = sharedObjects;
+  const [feeCoin, transferRequest] = txBlock.moveCall({
+    target: "0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_biddings::accept_bid",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_BIDDING_STORE),
+      txBlock.pure(bidNonce),
+      txBlock.object(TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      txBlock.pure(nftTokenId),
+      txBlock.object(transferPolicy)
+    ],
+    typeArguments: [nftType]
+  });
+  txBlock.moveCall({
+    target: `${royaltyRulePackageId}::royalty_rule::pay`,
+    typeArguments: [nftType],
+    arguments: [txBlock.object(transferPolicy), transferRequest, feeCoin]
+  });
+  await resolveTransferPolicies({
+    txBlock,
+    kioskTx,
+    nftType,
+    price: "0",
+    transferRequest,
+    kioskToLockRuleProve: TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK,
+    shouldSkipKioskLocking: true,
+    shouldSkipResolvingRoyaltyRule: true
+  });
+}
+async function addOriginByteAcceptNftBidTx({
+  txBlock,
+  sharedObjects,
+  sellerKiosk,
+  bidNonce,
+  nftTokenId,
+  nftType
+}) {
+  const receiverKiosk = await getOBBidderKiosk(bidNonce);
+  let transferRequest;
+  if (sellerKiosk) {
+    transferRequest = txBlock.moveCall({
+      target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::sell_nft_from_kiosk",
+      arguments: [
+        txBlock.object(bidNonce),
+        txBlock.object(sellerKiosk),
+        txBlock.object(receiverKiosk),
+        txBlock.pure(nftTokenId)
+      ],
+      typeArguments: [nftType, "0x2::sui::SUI"]
+    });
+  } else {
+    transferRequest = txBlock.moveCall({
+      target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::sell_nft",
+      arguments: [
+        txBlock.object(bidNonce),
+        txBlock.object(receiverKiosk),
+        txBlock.pure(nftTokenId)
+      ],
+      typeArguments: [nftType, "0x2::sui::SUI"]
+    });
+  }
+  confirmOBTranfer({ txBlock, sharedObjects, transferRequest, nftType });
+}
+function addBluemoveAcceptNftBidTx({
+  txBlock,
+  nftTokenId,
+  nftType,
+  bidNonce,
+  isListedOnBluemove
+}) {
+  if (isListedOnBluemove) {
+    txBlock.moveCall({
+      target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist",
+      arguments: [txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT), txBlock.pure(nftTokenId)],
+      typeArguments: [nftType, nftType]
+    });
+  }
+  txBlock.moveCall({
+    target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_item::accept_offer_nft",
+    arguments: [
+      txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+      txBlock.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+      txBlock.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+      txBlock.object(BLUEMOVE_OFFER_DATA_OBJECT),
+      txBlock.pure(bidNonce),
+      isListedOnBluemove ? {
+        kind: "Result",
+        index: 0
+      } : txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType]
+  });
+}
+async function addTradePortAcceptNftBidTxHandler(txData) {
+  const bidType = await getObjectType(txData?.bidNonce);
+  if (isOriginByteBid(bidType)) {
+    if (isOriginByteTx(txData?.sharedObjects)) {
+      await addOriginByteAcceptNftBidTx(txData);
+      return;
+    }
+    throw new Error(
+      `You cannot accept an Origin Byte bid with a NFT outside of an Origin Byte kiosk. Nft Token Id: ${txData?.nftTokenId}`
+    );
+  }
+  if (isTradePortKioskBid(bidType)) {
+    if (txData?.sellerKiosk) {
+      const royaltyRulePackageId = await getRulePackageId(txData.nftType, "royalty_rule");
+      return kioskTxWrapper({
+        txBlock: txData?.txBlock,
+        kioskOwner: txData?.itemOwner,
+        kiosk: txData?.sellerKiosk,
+        async tx(kioskTx) {
+          await addTradeportKioskAcceptNftBidTx({
+            ...txData,
+            kioskTx,
+            royaltyRulePackageId
+          });
+        }
+      });
+    }
+    throw new Error(
+      `You cannot accept an Native Kiosk Bid with a NFT outside of a native kiosk. Nft Token Id: ${txData?.nftTokenId}`
+    );
+  }
+  addTradeportAcceptNftBidTx(txData);
+}
+
+// src/helpers/isNonKioskListing.ts
+var isNonKioskListing = async (listingNonce) => {
+  const listingType = await getObjectType(listingNonce);
+  return listingType === NON_KIOSK_LISTING_NONCE_TYPE;
+};
+
+// src/helpers/splitCoins.ts
+var splitCoins = ({ txBlock, amounts }) => {
+  const res = txBlock.splitCoins(txBlock.gas, amounts);
+  return res;
+};
+
+// src/methods/unlistListings/addUnlistListingTxs.ts
+function addTradePortUnlistTx({ txBlock, listingNonce, nftType }) {
+  txBlock.moveCall({
+    target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::unlist",
+    arguments: [txBlock.object(TRADEPORT_LISTING_STORE), txBlock.pure(listingNonce)],
+    typeArguments: [nftType]
+  });
+}
+async function addTradePortKioskUnlistTx({
+  txBlock,
+  kioskTx,
+  nftTokenId,
+  nftType
+}) {
+  txBlock.moveCall({
+    target: "0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_listings::unlist",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_LISTING_STORE),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType]
+  });
+}
+function addOriginByteUnlistTx({
+  txBlock,
+  sharedObjects,
+  listingNonce,
+  price,
+  nftTokenId,
+  nftType
+}) {
+  const { orderbook } = sharedObjects;
+  txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::cancel_ask",
+    arguments: [
+      txBlock.object(orderbook),
+      txBlock.object(listingNonce),
+      txBlock.pure(price),
+      txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+}
+function addSouffl3UnlistTx({ txBlock, listingNonce, nftType }) {
+  txBlock.moveCall({
+    target: "0x30d90b5b67be77e6e06f02dae9f0f2fcdad16e38854316ae8a7b4f5b4971f5e0::Market::delist_generic",
+    arguments: [txBlock.object(SOUFFL3_VERSION_OBJECT), txBlock.pure(listingNonce)],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+}
+function addBluemoveUnlistTx({ txBlock, nftTokenId, nftType }) {
+  txBlock.moveCall({
+    target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist_and_take",
+    arguments: [txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT), txBlock.pure(nftTokenId)],
+    typeArguments: [nftType, nftType]
+  });
+}
+async function addBluemoveKioskUnlistTx({
+  txBlock,
+  kioskTx,
+  nftTokenId,
+  nftType
+}) {
+  txBlock.moveCall({
+    target: "0x2949e130ca4dabfe6448173758468a3e45ea3f070e3264f112b51c023f3ecf9f::kiosk_trade::kiosk_delist",
+    arguments: [
+      txBlock.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType]
+  });
+}
+function addKeepsakeUnlistTx({ txBlock, nftTokenId, nftType }) {
+  txBlock.moveCall({
+    target: "0x2be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::keepsake_marketplace::delist_and_take",
+    arguments: [
+      txBlock.object(KEEPSAKE_MARKETPLACE_OBJECT),
+      txBlock.object(KEEPSAKE_MARKETPLACE_KIOSK),
+      txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType]
+  });
+}
+async function addHyperspaceKioskUnlistTx({
+  txBlock,
+  kioskTx,
+  nftTokenId,
+  nftType
+}) {
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(1)] });
+  txBlock.moveCall({
+    target: "0x6ea97b03c441edd54ae89224bf9560e583ee66c37e6c246f5db35258e580ba94::hyperspace::delist",
+    arguments: [
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType, HYPERSPACE_MP_TRANSFER_POLICY_TYPE]
+  });
+  txBlock.transferObjects([txBlock.object(coin)], txBlock.pure(nftTokenId));
+}
+function addTocenUnlistTx({ txBlock, nftTokenId, nftType }) {
+  txBlock.moveCall({
+    target: "0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::delist_and_take",
+    arguments: [txBlock.pure(TOCEN_MARKETPLACE_OBJECT), txBlock.pure(nftTokenId)],
+    typeArguments: [nftType]
+  });
+}
+function addSomisUnlistTx({
+  txBlock,
+  sharedObjects,
+  nftTokenId,
+  nftType,
+  price
+}) {
+  const { marketplace } = sharedObjects;
+  txBlock.moveCall({
+    target: "0xf0b0beb956e26bde50dbd6ac393026c4525aee3b194a9478f09748f7211b5a02::marketplace::cancel_ask",
+    arguments: [txBlock.pure(marketplace), txBlock.pure(nftTokenId), txBlock.pure(price)],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+}
+async function addTradePortUnlistTxHandler(txData) {
+  if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+    addOriginByteUnlistTx(txData);
+    return;
+  }
+  if (txData?.listingNonce && await isNonKioskListing(txData?.listingNonce)) {
+    addTradePortUnlistTx(txData);
+    return;
+  }
+  if (txData?.sellerKiosk) {
+    return kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.seller,
+      kiosk: txData?.sellerKiosk,
+      async tx(kioskTx) {
+        await addTradePortKioskUnlistTx({
+          ...txData,
+          kioskTx
+        });
+      }
+    });
+  }
+  addTradePortUnlistTx(txData);
+}
+async function addHyperspaceUnlistTxHandler(txData) {
+  if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+    addOriginByteUnlistTx(txData);
+    return;
+  }
+  return kioskTxWrapper({
+    txBlock: txData?.txBlock,
+    kioskOwner: txData?.seller,
+    kiosk: txData?.sellerKiosk,
+    async tx(kioskTx) {
+      await addHyperspaceKioskUnlistTx({
+        ...txData,
+        kioskTx
+      });
+    }
+  });
+}
+async function addBluemoveUnlistTxHandler(txData) {
+  if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+    addOriginByteUnlistTx(txData);
+    return;
+  }
+  if (txData?.sellerKiosk) {
+    return kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.seller,
+      kiosk: txData?.sellerKiosk,
+      async tx(kioskTx) {
+        await addBluemoveKioskUnlistTx({
+          ...txData,
+          kioskTx
+        });
+      }
+    });
+  }
+  addBluemoveUnlistTx(txData);
+}
+async function addClutchyUnlistTxHandler(txData) {
+  addOriginByteUnlistTx(txData);
+}
+async function addSouffl3UnlistTxHandler(txData) {
+  addSouffl3UnlistTx(txData);
+}
+async function addSomisUnlistTxHandler(txData) {
+  if (txData?.sharedObjects?.marketplace) {
+    addSomisUnlistTx(txData);
+    return;
+  }
+  addOriginByteUnlistTx(txData);
+}
+async function addKeepsakeUnlistTxHandler(txData) {
+  addKeepsakeUnlistTx(txData);
+}
+function addTocenUnlistTxHandler(txData) {
+  addTocenUnlistTx(txData);
+}
+
+// src/methods/acceptCollectionBid/addAcceptCollectionBIdTxs.ts
+function addTradeportAcceptCollectionBidTx({
+  txBlock,
+  sharedObjects,
+  nftTokenId,
+  nftType,
+  itemTakenOutOfNativeKiosk,
+  bidNonce
+}) {
+  const { collection, royaltyStrategy } = sharedObjects;
+  if (collection && royaltyStrategy) {
+    txBlock.moveCall({
+      target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::ob_accept_bid",
+      arguments: [
+        txBlock.object(TRADEPORT_BIDDING_STORE),
+        txBlock.pure(bidNonce),
+        itemTakenOutOfNativeKiosk ? txBlock.object(itemTakenOutOfNativeKiosk) : txBlock.pure(nftTokenId),
+        txBlock.object(collection),
+        txBlock.object(royaltyStrategy)
+      ],
+      typeArguments: [nftType]
+    });
+  } else {
+    txBlock.moveCall({
+      target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::accept_bid",
+      arguments: [
+        txBlock.object(TRADEPORT_BIDDING_STORE),
+        txBlock.pure(bidNonce),
+        itemTakenOutOfNativeKiosk ? txBlock.object(itemTakenOutOfNativeKiosk) : txBlock.pure(nftTokenId)
+      ],
+      typeArguments: [nftType]
+    });
+  }
+}
+var addTradeportKioskAcceptCollectionBidTx = async (txData) => {
+  await addTradeportKioskAcceptNftBidTx(txData);
+};
+async function addOriginByteAcceptCollectionBidTx(txData) {
+  const {
+    txBlock,
+    sharedObjects,
+    sellerKiosk,
+    itemOwner,
+    nftTokenId,
+    nftType,
+    bidAmount,
+    bidNonce,
+    listingPrice
+  } = txData;
+  if (listingPrice && listingPrice > 0) {
+    addOriginByteUnlistTx({
+      ...txData,
+      price: txData?.listingPrice
+    });
+  }
+  const { kiosk, isNewKiosk } = await getOrCreateOBKiosk({
+    txBlock,
+    address: itemOwner,
+    kioskToUseIfExists: sellerKiosk
+  });
+  if (isNewKiosk) {
+    depositItemIntoOBKiosk({
+      txBlock,
+      kiosk: sellerKiosk,
+      nftTokenId,
+      nftType
+    });
+  }
+  const { orderbook } = sharedObjects;
+  const [tradeInfo] = txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::market_sell",
+    arguments: [
+      txBlock.object(orderbook),
+      txBlock.object(kiosk),
+      txBlock.pure(bidAmount),
+      txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+  const [id] = txBlock.moveCall({
+    target: "0xa0bab69d913e5a0ce8b448235a08bcf4c42da45c50622743dc9cab2dc0dff30f::orderbook::trade_id",
+    arguments: [txBlock.object(tradeInfo)],
+    typeArguments: []
+  });
+  const transferRequest = txBlock.moveCall({
+    target: "0xa0bab69d913e5a0ce8b448235a08bcf4c42da45c50622743dc9cab2dc0dff30f::orderbook::finish_trade",
+    arguments: [
+      txBlock.object(orderbook),
+      txBlock.object(id),
+      txBlock.object(kiosk),
+      txBlock.object(bidNonce)
+    ],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+  confirmOBTranfer({ txBlock, sharedObjects, transferRequest, nftType });
+  if (isNewKiosk) {
+    await shareOriginByteKiosk({ txBlock, kiosk });
+  }
+}
+function addBluemoveAcceptCollectionBidTx({
+  txBlock,
+  nftTokenId,
+  nftType,
+  bidNonce,
+  listingPrice,
+  itemTakenOutOfNativeKiosk
+}) {
+  let unlistedItem;
+  if (listingPrice && listingPrice > 0) {
+    unlistedItem = txBlock.moveCall({
+      target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist",
+      arguments: [txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT), txBlock.pure(nftTokenId)],
+      typeArguments: [nftType, nftType]
+    });
+  }
+  txBlock.moveCall({
+    target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_collection::accept_offer_collection",
+    arguments: [
+      txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+      txBlock.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+      txBlock.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+      txBlock.object(BLUEMOVE_OFFER_COLLECTION_DATA_OBJECT),
+      txBlock.pure(bidNonce),
+      itemTakenOutOfNativeKiosk ? txBlock.object(itemTakenOutOfNativeKiosk) : unlistedItem ? txBlock.object(unlistedItem) : txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType]
+  });
+}
+async function addBluemoveKioskAcceptCollectionBidTx({
+  txBlock,
+  kioskTx,
+  nftTokenId,
+  nftType,
+  bidNonce
+}) {
+  txBlock.moveCall({
+    target: "0x2949e130ca4dabfe6448173758468a3e45ea3f070e3264f112b51c023f3ecf9f::kiosk_offer_collection_v2::accept_offer_collection_v2",
+    arguments: [
+      txBlock.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
+      txBlock.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_DATA_OBJECT),
+      txBlock.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_BIDDER_BAG),
+      txBlock.pure(bidNonce),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      txBlock.pure(nftTokenId)
+    ],
+    typeArguments: [nftType]
+  });
+}
+function addTocenAcceptCollectionBidTx({
+  txBlock,
+  nftTokenId,
+  nftType,
+  bidAmount,
+  bidder
+}) {
+  txBlock.moveCall({
+    target: "0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::accept_offer_list",
+    arguments: [
+      txBlock.object(TOCEN_MARKETPLACE_OBJECT),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(bidder),
+      txBlock.pure(bidAmount)
+    ],
+    typeArguments: [nftType]
+  });
+}
+async function addTradePortAcceptCollectionBidTxHandler(txData) {
+  const bidType = await getObjectType(txData?.bidNonce);
+  if (isOriginByteBid(bidType)) {
+    if (isOriginByteTx(txData?.sharedObjects)) {
+      await addOriginByteAcceptCollectionBidTx(txData);
+      return;
+    }
+    throw new Error(
+      `You cannot accept an Origin Byte bid with a NFT outside of an Origin Byte kiosk. Nft Token Id: ${txData?.nftTokenId}`
+    );
+  }
+  if (!await hasTransferPolicyRules(txData?.nftType) && txData?.sellerKiosk) {
+    return kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.seller,
+      kiosk: txData?.sellerKiosk,
+      async tx(kioskTx) {
+        const item = kioskTx.take({
+          itemId: txData?.nftTokenId,
+          itemType: txData?.nftType
+        });
+        addTradeportAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: item });
+      }
+    });
+  }
+  if (isTradePortKioskBid(bidType)) {
+    if (txData?.sellerKiosk) {
+      const royaltyRulePackageId = await getRulePackageId(txData.nftType, "royalty_rule");
+      return kioskTxWrapper({
+        txBlock: txData?.txBlock,
+        kioskOwner: txData?.itemOwner,
+        kiosk: txData?.sellerKiosk,
+        async tx(kioskTx) {
+          await addTradeportKioskAcceptCollectionBidTx({
+            ...txData,
+            kioskTx,
+            royaltyRulePackageId
+          });
+        }
+      });
+    }
+    if (await hasTransferPolicyRules(txData?.nftType) && !txData?.sellerKiosk) {
+      const royaltyRulePackageId = await getRulePackageId(txData.nftType, "royalty_rule");
+      return kioskTxWrapper({
+        txBlock: txData?.txBlock,
+        kioskOwner: txData?.seller,
+        kiosk: txData?.sellerKiosk,
+        async tx(kioskTx) {
+          kioskTx.place({
+            item: txData?.nftTokenId,
+            itemType: txData?.nftType
+          });
+          await addTradeportKioskAcceptCollectionBidTx({
+            ...txData,
+            kioskTx,
+            royaltyRulePackageId
+          });
+        }
+      });
+    }
+  }
+  addTradeportAcceptCollectionBidTx(txData);
+}
+async function addBluemoveAcceptCollectionBidTxHandler(txData) {
+  const bidType = await getObjectType(txData?.bidNonce);
+  if (isOriginByteBid(bidType)) {
+    if (isOriginByteTx(txData?.sharedObjects)) {
+      await addOriginByteAcceptCollectionBidTx(txData);
+      return;
+    }
+    throw new Error(
+      `You cannot accept an Origin Byte bid with a NFT outside of an Origin Byte kiosk. Nft Token Id: ${txData?.nftTokenId}`
+    );
+  }
+  if (isBluemoveKioskBid(txData?.bidNonce)) {
+    if (txData?.sellerKiosk) {
+      return kioskTxWrapper({
+        txBlock: txData?.txBlock,
+        kioskOwner: txData?.itemOwner,
+        kiosk: txData?.sellerKiosk,
+        async tx(kioskTx) {
+          await addBluemoveKioskAcceptCollectionBidTx({
+            ...txData,
+            kioskTx
+          });
+        }
+      });
+    }
+    throw new Error(
+      `You cannot accept an Native Kiosk Bid with a NFT outside of a native kiosk. Nft Token Id: ${txData?.nftTokenId}`
+    );
+  }
+  if (!isBluemoveKioskBid(txData?.bidNonce)) {
+    if (txData?.sellerKiosk) {
+      return kioskTxWrapper({
+        txBlock: txData?.txBlock,
+        kioskOwner: txData?.itemOwner,
+        kiosk: txData?.sellerKiosk,
+        async tx(kioskTx) {
+          const item = kioskTx.take({
+            itemId: txData?.nftTokenId,
+            itemType: txData?.nftType
+          });
+          addBluemoveAcceptCollectionBidTx({ ...txData, itemTakenOutOfNativeKiosk: item });
+        }
+      });
+    }
+    addBluemoveAcceptCollectionBidTx(txData);
+  }
+}
+function addTocenAcceptCollectionBidTxHandler(txData) {
+  addTocenAcceptCollectionBidTx(txData);
+}
+
+// src/methods/acceptCollectionBid/acceptCollectionBid.ts
+var ERROR_UNLIST_FIRST = "Item must be unlisted first before you can accept a collection bid with it";
+var acceptCollectionBid = async ({
+  bid,
+  nftId,
+  walletAddress
+}) => {
+  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 = {
+    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);
+};
+
+// src/methods/acceptNftBids/acceptNftBids.ts
+import { TransactionBlock as TransactionBlock2 } from "@mysten/sui.js/transactions";
+
+// src/graphql/queries/fetchBidsById.ts
+import { gql as gql10 } from "graphql-request";
+var fetchBidsById = gql10`
+	query fetchBidsById($bidIds: [uuid!]) {
+		bids(where: { id: { _in: $bidIds } }) {
+			nonce
+			price
+			status
+			type
+			nft {
+				token_id
+				properties
+				chain_state
+				owner
+				contract {
+					properties
+				}
+				listings(where: { listed: { _eq: true } }) {
+					price
+					market_name
+				}
+			}
+			market_contract {
+				name
+			}
+		}
+	}
+`;
+
+// src/methods/acceptNftBids/acceptNftBids.ts
+var ERROR_UNLIST_FIRST2 = "Item must be unlisted first before you can accept a solo bid on it";
+var acceptNftBids = async ({ bidIds }) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchBidsById,
+    variables: { bidIds }
+  });
+  if (res?.bids?.length === 0) {
+    throw new Error("No bids found");
+  }
+  const txBlock = new TransactionBlock2();
+  for (const bid of res.bids) {
+    if (bid?.status !== "active") {
+      throw new Error("Bid not active");
+    }
+    if (bid?.type !== "solo") {
+      throw new Error("Bid is not an individual item bid. Use acceptCollectionBid() instead.");
+    }
+    const sharedObjects = await getSharedObjects(
+      bid?.nft?.properties?.nft_type || bid?.nft?.contract?.properties?.nft_type
+    );
+    const txData = {
+      txBlock,
+      sharedObjects,
+      bidNonce: bid?.nonce,
+      nftType: getNftTypeFromNft(bid?.nft),
+      listingPrice: bid?.nft?.listings?.[0]?.price,
+      nftTokenId: bid?.nft?.token_id,
+      itemOwner: bid?.nft?.owner,
+      bidAmount: bid?.price,
+      sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
+      isListedOnBluemove: bid?.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_FIRST2);
+        }
+        await addTradePortAcceptNftBidTxHandler(txData);
+        break;
+      case "clutchy":
+      case "hyperspace":
+      case "somis":
+        await addOriginByteAcceptNftBidTx(txData);
+        break;
+      case "bluemove":
+        addBluemoveAcceptNftBidTx(txData);
+        break;
+      default:
+        throw new Error("Marketplace not supported");
+    }
+  }
+  return new TransactionBlock2(txBlock);
+};
+
+// src/methods/buyListings/buyListings.ts
+import { TransactionBlock as TransactionBlock3 } from "@mysten/sui.js/transactions";
+
+// src/graphql/queries/fetchListingsById.ts
+import { gql as gql11 } from "graphql-request";
+var fetchListingsById = gql11`
+	query fetchListingsById($listingIds: [uuid!]) {
+		listings(where: { id: { _in: $listingIds } }) {
+			seller
+			listed
+			market_name
+			price
+			nonce
+			nft {
+				id
+				token_id
+				collection_id
+				contract_id
+				properties
+				chain_state
+				contract {
+					properties
+				}
+			}
+		}
+	}
+`;
+
+// src/helpers/addThirdPartyTxFee.ts
+var addThirdPartyTxFee = async (txBlock, price) => {
+  const [microTxFee] = txBlock.splitCoins(txBlock.gas, [
+    txBlock.pure(price * TRADEPORT_THIRD_PARTY_FEE_DECIMAL_PERCENT)
+  ]);
+  txBlock.transferObjects(
+    [txBlock.object(microTxFee)],
+    txBlock.pure(addLeadingZerosAfter0x(TRADEPORT_BENEFICIARY_ADDRESS))
+  );
+};
+
+// src/graphql/queries/fetchCommissionByListingId.ts
+import { gql as gql12 } from "graphql-request";
+var fetchCommissionByNftContractId = gql12`
+	query fetchCommissionByNftContractId($nftContractId: uuid!) {
+		commissions(where: { contract_id: { _eq: $nftContractId } }) {
+			is_custodial
+			key
+			market_fee
+			market_name
+			royalty
+		}
+	}
+`;
+
+// src/graphql/queries/getCommissionByListingId.ts
+var getCommissionByNftContractId = async (nftContractId) => {
+  try {
+    const res = await gqlChainRequest({
+      chain: "sui",
+      query: fetchCommissionByNftContractId,
+      variables: { nftContractId }
+    });
+    return res?.commissions?.[0];
+  } catch (err) {
+    throw new Error(`Failed to fetch commission for listing ${nftContractId}`);
+  }
+};
+
+// src/helpers/destroyZeroCoin.ts
+var destroyZeroCoin = ({ txBlock, coin }) => {
+  txBlock.moveCall({
+    target: "0x2::coin::destroy_zero",
+    arguments: [txBlock.object(coin)],
+    typeArguments: ["0x2::sui::SUI"]
+  });
+};
+
+// src/methods/buyListings/addBuyListingTxs.ts
+function addTradePortBuyTx({ txBlock, nftType, listingNonce, price, sharedObjects }) {
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+  if (!coin)
+    throw new Error("Coin could not be split");
+  const { collection, royaltyStrategy } = sharedObjects;
+  if (collection && royaltyStrategy) {
+    txBlock.moveCall({
+      target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::ob_buy",
+      arguments: [
+        txBlock.object(TRADEPORT_LISTING_STORE),
+        txBlock.pure(listingNonce),
+        txBlock.object(coin),
+        txBlock.object(collection),
+        txBlock.object(royaltyStrategy)
+      ],
+      typeArguments: [nftType]
+    });
+  } else {
+    txBlock.moveCall({
+      target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::buy",
+      arguments: [
+        txBlock.object(TRADEPORT_LISTING_STORE),
+        txBlock.pure(listingNonce),
+        txBlock.object(coin)
+      ],
+      typeArguments: [nftType]
+    });
+  }
+  destroyZeroCoin({ txBlock, coin });
+}
+var addTradeportKioskBuyTx = async ({
+  txBlock,
+  kioskTx,
+  nftType,
+  nftTokenId,
+  price,
+  sellerKiosk
+}) => {
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+  if (!coin)
+    throw new Error("Coin could not be split");
+  const [kioskItem, transferRequest, kioskPrice] = txBlock.moveCall({
+    target: "0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_listings::buy",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_LISTING_STORE),
+      txBlock.object(sellerKiosk),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.pure(nftTokenId),
+      txBlock.object(coin)
+    ],
+    typeArguments: [nftType]
+  });
+  await resolveTransferPolicies({
+    txBlock,
+    kioskTx,
+    nftType,
+    priceObjectArgument: kioskPrice,
+    kioskItem,
+    transferRequest
+  });
+  destroyZeroCoin({ txBlock, coin });
+};
+async function addOriginByteBuyTx({
+  txBlock,
+  sharedObjects,
+  buyer,
+  nftTokenId,
+  nftType,
+  listingNonce,
+  price
+}) {
+  const { orderbook } = sharedObjects;
+  const { kiosk: buyerKiosk, isNewKiosk: isNewBuyerKiosk } = await getOrCreateOBKiosk({
+    txBlock,
+    address: buyer
+  });
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+  if (!coin)
+    throw new Error("Coin could not be split");
+  const transferRequest = txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::buy_nft",
+    arguments: [
+      txBlock.object(orderbook),
+      txBlock.object(listingNonce),
+      txBlock.object(buyerKiosk),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(price),
+      txBlock.object(coin)
+    ],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+  confirmOBTranfer({ txBlock, sharedObjects, transferRequest, nftType });
+  destroyZeroCoin({ txBlock, coin });
+  if (isNewBuyerKiosk) {
+    await shareOriginByteKiosk({ txBlock, kiosk: buyerKiosk });
+  }
+}
+var addHyperspaceKioskBuyTx = async ({
+  txBlock,
+  kioskTx,
+  nftType,
+  nftTokenId,
+  price,
+  sellerKiosk
+}) => {
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+  if (!coin)
+    throw new Error("Coin could not be split");
+  const [kioskItem, transferRequest, hyperspaceTransferRequest, hyperspaceMpTransferRequest] = txBlock.moveCall({
+    target: "0x6ea97b03c441edd54ae89224bf9560e583ee66c37e6c246f5db35258e580ba94::hyperspace::purchase",
+    arguments: [txBlock.object(sellerKiosk), txBlock.pure(nftTokenId), txBlock.object(coin)],
+    typeArguments: [nftType, HYPERSPACE_MP_TRANSFER_POLICY_TYPE]
+  });
+  const customTransferPolicies = [
+    {
+      type: HYPERSPACE_TRANSFER_POLICY_TYPE,
+      transferRequest: hyperspaceTransferRequest
+    },
+    {
+      type: HYPERSPACE_MP_TRANSFER_POLICY_TYPE,
+      transferRequest: hyperspaceMpTransferRequest
+    }
+  ];
+  await resolveTransferPolicies({
+    txBlock,
+    kioskTx,
+    nftType,
+    price: price?.toString(),
+    kioskItem,
+    transferRequest,
+    customTransferPolicies
+  });
+};
+function addBluemoveBuyTx({ txBlock, nftTokenId, nftType, price }) {
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+  if (!coin)
+    throw new Error("Coin could not be split");
+  txBlock.moveCall({
+    target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::buy_and_take",
+    arguments: [
+      txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT),
+      txBlock.object(BLUEMOVE_ROYALTY_COLLECTION_OBJECT),
+      txBlock.object(BLUEMOVE_CREATOR_CONFIG_OBJECT),
+      txBlock.pure(nftTokenId),
+      txBlock.object(coin),
+      txBlock.pure(price)
+    ],
+    typeArguments: [nftType, nftType]
+  });
+}
+async function addBluemoveKioskBuyTx({
+  txBlock,
+  kioskTx,
+  sharedObjects,
+  nftTokenId,
+  nftType,
+  price,
+  sellerKiosk
+}) {
+  const { transferPolicy } = sharedObjects;
+  const [coin1, coin2] = splitCoins({
+    txBlock,
+    amounts: [txBlock.pure(price), txBlock.pure(price * 0.025)]
+  });
+  if (!coin1 || !coin2)
+    throw new Error("Coin could not be split");
+  txBlock.mergeCoins(txBlock.object(coin1), [txBlock.object(coin2)]);
+  const [kioskItem, transferRequest] = txBlock.moveCall({
+    target: "0xcc97b74ed95c8e8a3ed88050a898727dee37896da579fc400d482b64db6149ff::kiosk_trade::kiosk_buy_v2",
+    arguments: [
+      txBlock.object(BLUEMOVE_KIOSK_MARKETPLACE_KIOSK_OBJECT),
+      txBlock.object(sellerKiosk),
+      txBlock.object(transferPolicy),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(price),
+      txBlock.object(coin1)
+    ],
+    typeArguments: [nftType]
+  });
+  await resolveTransferPolicies({
+    txBlock,
+    kioskTx,
+    nftType,
+    price: price?.toString(),
+    kioskItem,
+    transferRequest
+  });
+}
+function addSouffl3BuyTx({
+  txBlock,
+  sharedObjects,
+  nftType,
+  price,
+  listingNonce,
+  collectionId,
+  buyer
+}) {
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+  const { transferPolicy } = sharedObjects;
+  if (transferPolicy && !SOUFFL3_GENERIC_BUY_METHOD_COLLECTIONS?.includes(collectionId)) {
+    const [coinToDestroy] = txBlock.moveCall({
+      target: "0x30d90b5b67be77e6e06f02dae9f0f2fcdad16e38854316ae8a7b4f5b4971f5e0::Market::buy_with_sui_with_ext",
+      arguments: [
+        txBlock.object(SOUFFL3_VERSION_OBJECT),
+        txBlock.object(SOUFFL3_EXTENSION_OBJECT),
+        txBlock.object(transferPolicy),
+        txBlock.object(listingNonce),
+        txBlock.pure(price),
+        txBlock.object(SOUFFL3_MARKETPLACE_OBJECT),
+        txBlock.object(coin)
+      ],
+      typeArguments: [nftType]
+    });
+    destroyZeroCoin({ txBlock, coin: coinToDestroy });
+  } else {
+    const [coinToDestroy] = txBlock.moveCall({
+      target: "0x30d90b5b67be77e6e06f02dae9f0f2fcdad16e38854316ae8a7b4f5b4971f5e0::Market::buy_generic_with_ext",
+      arguments: [
+        txBlock.object(SOUFFL3_VERSION_OBJECT),
+        txBlock.object(SOUFFL3_EXTENSION_OBJECT),
+        txBlock.object(listingNonce),
+        txBlock.pure(price),
+        txBlock.object(SOUFFL3_MARKETPLACE_OBJECT),
+        txBlock.object(coin)
+      ],
+      typeArguments: [nftType, "0x2::sui::SUI"]
+    });
+    destroyZeroCoin({ txBlock, coin: coinToDestroy });
+  }
+}
+function addSomisBuyTx({ txBlock, sharedObjects, nftTokenId, nftType, price }) {
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+  if (!coin)
+    throw new Error("Coin could not be split");
+  txBlock.moveCall({
+    target: "0xf0b0beb956e26bde50dbd6ac393026c4525aee3b194a9478f09748f7211b5a02::marketplace::buy_nft",
+    arguments: [
+      txBlock.object(sharedObjects?.marketplace),
+      txBlock.pure(nftTokenId),
+      txBlock.object(coin)
+    ],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+}
+function addKeepsakeBuyTx({
+  txBlock,
+  sharedObjects,
+  buyer,
+  nftTokenId,
+  nftType,
+  price,
+  royalty
+}) {
+  const { keepsakeRoyaltyStrategy, transferPolicy } = sharedObjects;
+  const [coin1, coin2] = splitCoins({
+    txBlock,
+    amounts: [
+      txBlock.pure(price),
+      txBlock.pure(price * Number(royalty) / 100 + price * Number(royalty) * 5e-5)
+    ]
+  });
+  if (!coin1 || !coin2)
+    throw new Error("Coin could not be split");
+  const [balance] = txBlock.moveCall({
+    target: "0x2::coin::into_balance",
+    arguments: [txBlock.object(coin2)],
+    typeArguments: ["0x2::sui::SUI"]
+  });
+  if (!balance)
+    throw new Error("Coin into_balance failed");
+  const [transferRequest] = txBlock.moveCall({
+    target: "0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::keepsake_marketplace::buy",
+    arguments: [
+      txBlock.object(KEEPSAKE_MARKETPLACE_OBJECT),
+      txBlock.object(KEEPSAKE_MARKETPLACE_KIOSK),
+      txBlock.pure(nftTokenId),
+      txBlock.object(coin1)
+    ],
+    typeArguments: [nftType]
+  });
+  if (!transferRequest)
+    throw new Error("Transfer request could not be created");
+  txBlock.moveCall({
+    target: "0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::keepsake_royalties::confirm_transfer_with_balance",
+    arguments: [
+      txBlock.object(keepsakeRoyaltyStrategy),
+      txBlock.object(transferRequest),
+      txBlock.object(balance)
+    ],
+    typeArguments: [nftType]
+  });
+  txBlock.moveCall({
+    target: "0x02be8c4a1a3cea4d3255d870d367c87838a8cc2bfe4f216a6b67b153027087a7::transfer_policy::confirm_request",
+    arguments: [txBlock.object(transferPolicy), txBlock.object(transferRequest)],
+    typeArguments: [nftType]
+  });
+  const [balanceToTransfer] = txBlock.moveCall({
+    target: "0x2::coin::from_balance",
+    arguments: [txBlock.object(balance)],
+    typeArguments: ["0x2::sui::SUI"]
+  });
+  if (!balanceToTransfer)
+    throw new Error("Coin from_balance failed");
+  txBlock.transferObjects(
+    [txBlock.object(balanceToTransfer)],
+    txBlock.pure(addLeadingZerosAfter0x(buyer))
+  );
+}
+var addTocenBuyTx = ({ txBlock, nftTokenIds, nftType, price }) => {
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(price)] });
+  if (!coin)
+    throw new Error("Coin could not be split");
+  txBlock.moveCall({
+    target: "0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::buy_cart",
+    arguments: [
+      txBlock.pure(TOCEN_MARKETPLACE_OBJECT),
+      txBlock.pure(nftTokenIds),
+      txBlock.object(coin)
+    ],
+    typeArguments: [nftType]
+  });
+};
+async function addTradePortBuyTxHandler(txData) {
+  if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+    await addOriginByteBuyTx(txData);
+    return;
+  }
+  if (txData?.sellerKiosk) {
+    return kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.buyer,
+      kiosk: txData?.sellerKiosk,
+      shouldConvertToPersonalKiosk: true,
+      async tx(kioskTx) {
+        await addTradeportKioskBuyTx({
+          ...txData,
+          kioskTx
+        });
+      }
+    });
+  }
+  addTradePortBuyTx(txData);
+}
+async function addHyperspaceBuyTxHandler(txData) {
+  if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+    await addOriginByteBuyTx(txData);
+    return;
+  }
+  return kioskTxWrapper({
+    txBlock: txData?.txBlock,
+    kioskOwner: txData?.buyer,
+    kiosk: txData?.sellerKiosk,
+    shouldConvertToPersonalKiosk: true,
+    async tx(kioskTx) {
+      await addHyperspaceKioskBuyTx({
+        ...txData,
+        kioskTx
+      });
+    }
+  });
+}
+async function addBluemoveBuyTxHandler(txData) {
+  if (txData?.listingNonce && isOriginByteTx(txData?.sharedObjects)) {
+    await addOriginByteBuyTx(txData);
+    return;
+  }
+  if (txData?.sellerKiosk) {
+    return kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.buyer,
+      kiosk: txData?.sellerKiosk,
+      shouldConvertToPersonalKiosk: true,
+      async tx(kioskTx) {
+        await addBluemoveKioskBuyTx({
+          ...txData,
+          kioskTx
+        });
+      }
+    });
+  }
+  addBluemoveBuyTx(txData);
+}
+async function addClutchyBuyTxHandler(txData) {
+  await addOriginByteBuyTx(txData);
+}
+async function addSouffl3BuyTxHandler(txData) {
+  addSouffl3BuyTx(txData);
+}
+async function addSomisBuyTxHandler(txData) {
+  if (txData?.sharedObjects?.marketplace) {
+    addSomisBuyTx(txData);
+    return;
+  }
+  return addOriginByteBuyTx(txData);
+}
+async function addKeepsakeBuyTxHandler(txData) {
+  const commission = await getCommissionByNftContractId(txData?.nftContractId);
+  addKeepsakeBuyTx({
+    ...txData,
+    royalty: commission?.royalty
+  });
+}
+function addTocenBuyTxHandler(txData) {
+  addTocenBuyTx(txData);
+}
+
+// src/methods/buyListings/buyListings.ts
+var buyListings = async ({
+  listingIds,
+  walletAddress
+}) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchListingsById,
+    variables: { listingIds }
+  });
+  if (res?.listings?.length === 0) {
+    throw new Error("No listings found");
+  }
+  const txBlock = new TransactionBlock3();
+  const tocenTokenIds = [];
+  let tocenNftType = "";
+  let tocenTotalPrice = 0;
+  for (const listing of res.listings) {
+    if (!listing?.listed) {
+      throw new Error(`Listing ${listing?.id} is not listed`);
+    }
+    const sharedObjects = await getSharedObjects(
+      listing?.nft?.properties?.nft_type || listing?.nft?.contract?.properties?.nft_type
+    );
+    const buyTxData = {
+      txBlock,
+      sharedObjects,
+      buyer: walletAddress,
+      nftTokenId: listing.nft?.token_id,
+      nftType: getNftTypeFromNft(listing?.nft),
+      listingId: listing?.id,
+      listingNonce: listing?.nonce,
+      price: listing?.price,
+      sellerKiosk: listing.nft?.chain_state?.kiosk_id,
+      collectionId: listing?.nft?.collection_id,
+      nftContractId: listing?.nft?.contract_id
+    };
+    switch (listing?.market_name) {
+      case "tradeport":
+        await addTradePortBuyTxHandler(buyTxData);
+        break;
+      case "hyperspace":
+        await addHyperspaceBuyTxHandler(buyTxData);
+        break;
+      case "bluemove":
+        await addBluemoveBuyTxHandler(buyTxData);
+        break;
+      case "clutchy":
+        await addClutchyBuyTxHandler(buyTxData);
+        break;
+      case "souffl3":
+        await addSouffl3BuyTxHandler(buyTxData);
+        break;
+      case "somis":
+        await addSomisBuyTxHandler(buyTxData);
+        break;
+      case "keepsake":
+        await addKeepsakeBuyTxHandler(buyTxData);
+        break;
+      case "tocen":
+        tocenTokenIds.push(buyTxData?.nftTokenId);
+        tocenNftType = buyTxData?.nftType;
+        tocenTotalPrice += Number(listing.price);
+        break;
+      default:
+        throw new Error("Marketplace not supported");
+    }
+    if (listing?.market_name !== "tradeport") {
+      await addThirdPartyTxFee(txBlock, listing?.price);
+    }
+  }
+  if (tocenTokenIds?.length > 0) {
+    addTocenBuyTxHandler({
+      txBlock,
+      nftType: tocenNftType,
+      nftTokenIds: tocenTokenIds,
+      price: tocenTotalPrice
+    });
+  }
+  return new TransactionBlock3(txBlock);
+};
+
+// src/methods/claimNfts/claimNfts.ts
+import { TransactionBlock as TransactionBlock4 } from "@mysten/sui.js/transactions";
+
+// src/methods/claimNfts/addClaimNftsTxs.ts
+var addClaimTradeHoldTx = ({
+  txBlock,
+  sharedObjects,
+  nftType,
+  claimableTradeId,
+  claimableSellerKiosk,
+  claimableBuyerKiosk
+}) => {
+  const { orderbook } = sharedObjects;
+  const transferRequest = txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::finish_trade",
+    arguments: [
+      txBlock.object(orderbook),
+      txBlock.pure(claimableTradeId),
+      txBlock.object(claimableSellerKiosk),
+      txBlock.object(claimableBuyerKiosk)
+    ],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+  confirmOBTranfer({ txBlock, sharedObjects, transferRequest, nftType });
+};
+var addClaimAcceptedBidNftTx = async ({
+  txBlock,
+  kioskTx,
+  sharedObjects,
+  nftTokenId,
+  nftType
+}) => {
+  const { transferPolicy } = sharedObjects;
+  const [transferRequest] = txBlock.moveCall({
+    target: "0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_biddings::claim_bid",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_BIDDING_STORE),
+      txBlock.object(TRADEPORT_KIOSK_BIDDING_ESCROW_KIOSK),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      txBlock.pure(nftTokenId),
+      txBlock.object(transferPolicy)
+    ],
+    typeArguments: [nftType]
+  });
+  await resolveTransferPolicies({
+    txBlock,
+    kioskTx,
+    nftType,
+    price: "0",
+    transferRequest,
+    shouldSkipKioskLocking: true
+  });
+};
+var addClaimTransferredNftTx = async ({
+  txBlock,
+  sharedObjects,
+  kioskTx,
+  nftTokenId,
+  nftType
+}) => {
+  const { transferPolicy } = sharedObjects;
+  const [transferRequest] = txBlock.moveCall({
+    target: "0x78eae99d1a7edae714b5de107f4b44ccbdf5f9ca6919498d9b024ef378dc13f7::kiosk_transfers::claim",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_TRANSFERS_STORE),
+      txBlock.object(TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      txBlock.pure(nftTokenId),
+      txBlock.object(transferPolicy)
+    ],
+    typeArguments: [nftType]
+  });
+  await resolveTransferPolicies({
+    txBlock,
+    kioskTx,
+    nftType,
+    price: "0",
+    transferRequest,
+    shouldSkipKioskLocking: true
+  });
+};
+
+// src/methods/claimNfts/claimNfts.ts
+var claimNfts = async ({
+  nftIds,
+  walletAddress
+}) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchNftsById,
+    variables: { nftIds }
+  });
+  if (res?.nfts?.length === 0) {
+    throw new Error("No nfts found");
+  }
+  const txBlock = new TransactionBlock4();
+  for (const nft of res.nfts) {
+    if (!nft) {
+      throw new Error("No nft found");
+    }
+    if (!nft?.chain_state?.claimable) {
+      throw new Error(`Nft ID: ${nft?.id} is not claimable`);
+    }
+    const sharedObjects = await getSharedObjects(
+      nft?.properties?.nft_type || nft?.contract?.properties?.nft_type
+    );
+    if (nft?.chain_state?.claimable_trade_id) {
+      const txData = {
+        txBlock,
+        sharedObjects,
+        nftType: getNftTypeFromNft(nft),
+        claimableTradeId: nft?.chain_state?.claimable_trade_id,
+        claimableSellerKiosk: nft?.chain_state?.claimable_seller_kiosk,
+        claimableBuyerKiosk: nft?.chain_state?.claimable_buyer_kiosk
+      };
+      addClaimTradeHoldTx(txData);
+      continue;
+    }
+    if (["accept-token-offer", "accept-collection-offer"]?.includes(
+      nft?.chain_state?.claimable_reason
+    )) {
+      const txData = {
+        txBlock,
+        sharedObjects,
+        claimer: walletAddress,
+        nftType: getNftTypeFromNft(nft),
+        nftTokenId: nft?.token_id,
+        sellerKiosk: nft?.chain_state?.kiosk_id
+      };
+      await kioskTxWrapper({
+        txBlock,
+        kioskOwner: txData?.claimer,
+        kiosk: txData?.sellerKiosk,
+        async tx(kioskTx) {
+          await addClaimAcceptedBidNftTx({ ...txData, kioskTx });
+        }
+      });
+      continue;
+    }
+    if (nft?.chain_state?.claimable_reason === "offer-transfer") {
+      const txData = {
+        txBlock,
+        sharedObjects,
+        claimer: walletAddress,
+        nftType: getNftTypeFromNft(nft),
+        nftTokenId: nft?.token_id,
+        sellerKiosk: nft?.chain_state?.kiosk_id
+      };
+      await kioskTxWrapper({
+        txBlock,
+        kioskOwner: txData?.claimer,
+        kiosk: txData?.sellerKiosk,
+        async tx(kioskTx) {
+          await addClaimTransferredNftTx({ ...txData, kioskTx });
+        }
+      });
+    }
+  }
+  return new TransactionBlock4(txBlock);
+};
+
+// src/methods/listNfts/listNfts.ts
+import { TransactionBlock as TransactionBlock5 } from "@mysten/sui.js/transactions";
+
+// src/helpers/getMarketFeePrice.ts
+var getMASCMarketFeePrice = (price) => {
+  if (price * (MASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT) < 1) {
+    return price * (MASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT);
+  }
+  return parseInt(
+    (price * (MASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT))?.toFixed(0),
+    10
+  );
+};
+var getBASCMarketFeePrice = (price) => {
+  if (price * (BASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT) < 1) {
+    return price * (BASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT);
+  }
+  return parseInt(
+    (price * (BASC_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT))?.toFixed(0),
+    10
+  );
+};
+var getDSLLegacyMarketFeePrice = (price) => {
+  if (price * (DSL_LEGACY_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT) < 1) {
+    return price * (DSL_LEGACY_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT);
+  }
+  return parseInt(
+    (price * (DSL_LEGACY_ROYALTY_DECIMAL_PERCENT + TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT))?.toFixed(
+      0
+    ),
+    10
+  );
+};
+var getMarketFeePrice = ({ price, collectionId, walletId }) => {
+  if (collectionId === "6824e1ff-477e-4810-9ba7-8d6387b68c7d") {
+    return getBASCMarketFeePrice(price);
+  }
+  if (collectionId === "8568521c-73a3-4beb-b830-d1ff27a3f1ca") {
+    return getMASCMarketFeePrice(price);
+  }
+  if (collectionId === "307c7e7a-be3a-43a5-ae44-37f3a37d01f9") {
+    return getDSLLegacyMarketFeePrice(price);
+  }
+  let marketFeePrice = 0;
+  if (!COLLECTION_IDS_WITH_ZERO_COMMISSION?.includes(collectionId)) {
+    marketFeePrice = price * TRADEPORT_DEFAULT_FEE_DECIMAL_PERCENT;
+  }
+  if (marketFeePrice < 1) {
+    return marketFeePrice;
+  }
+  return parseInt(marketFeePrice?.toFixed(0), 10);
+};
+
+// src/utils/parseSUI.ts
+var parseSUI = (num) => parseInt((1e9 * num).toFixed(0), 10);
+
+// src/methods/listNfts/addListTxs.ts
+async function addOriginByteListTx({
+  txBlock,
+  sharedObjects,
+  nftTokenId,
+  nftType,
+  seller,
+  listPrice,
+  collectionId,
+  sellerKiosk
+}) {
+  const { orderbook } = sharedObjects;
+  const { kiosk, isNewKiosk } = await getOrCreateOBKiosk({
+    txBlock,
+    address: seller,
+    kioskToUseIfExists: sellerKiosk
+  });
+  if (isNewKiosk) {
+    depositItemIntoOBKiosk({
+      txBlock,
+      kiosk: sellerKiosk,
+      nftTokenId,
+      nftType
+    });
+  }
+  const parsedListPrice = parseSUI(listPrice);
+  const marketFeePrice = getMarketFeePrice({
+    price: parsedListPrice,
+    collectionId,
+    walletId: seller
+  });
+  txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::create_ask_with_commission",
+    arguments: [
+      txBlock.object(orderbook),
+      txBlock.object(kiosk),
+      txBlock.pure(parsedListPrice),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS),
+      txBlock.pure(marketFeePrice)
+    ],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+  if (isNewKiosk) {
+    await shareOriginByteKiosk({ txBlock, kiosk });
+  }
+}
+function addTradePortListTx({
+  txBlock,
+  nftTokenId,
+  borrowedItem,
+  nftType,
+  collectionId,
+  listPrice,
+  seller
+}) {
+  const parsedListPrice = parseSUI(listPrice);
+  const marketFeePrice = getMarketFeePrice({
+    price: parsedListPrice,
+    collectionId,
+    walletId: seller
+  });
+  txBlock.moveCall({
+    target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::list",
+    arguments: [
+      txBlock.object(TRADEPORT_LISTING_STORE),
+      borrowedItem ? txBlock.object(borrowedItem) : txBlock.pure(nftTokenId),
+      txBlock.pure(parsedListPrice),
+      txBlock.pure(marketFeePrice),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS)
+    ],
+    typeArguments: [nftType]
+  });
+}
+async function addTradePortKioskListTx({
+  txBlock,
+  kioskTx,
+  nftTokenId,
+  nftType,
+  collectionId,
+  listPrice,
+  seller
+}) {
+  const parsedListPrice = parseSUI(listPrice);
+  const marketFeePrice = getMarketFeePrice({
+    price: parsedListPrice,
+    collectionId,
+    walletId: seller
+  });
+  txBlock.moveCall({
+    target: "0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_listings::list",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_LISTING_STORE),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(Number(parsedListPrice) + marketFeePrice),
+      txBlock.pure(marketFeePrice),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS)
+    ],
+    typeArguments: [nftType]
+  });
+}
+async function addTradePortListTxHandler(txData) {
+  if (isOriginByteTx(txData?.sharedObjects)) {
+    await addOriginByteListTx(txData);
+    return;
+  }
+  if (!await hasTransferPolicyRules(txData?.nftType) && txData?.sellerKiosk) {
+    return kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.seller,
+      kiosk: txData?.sellerKiosk,
+      async tx(kioskTx) {
+        const borrowedItem = kioskTx.take({
+          itemId: txData?.nftTokenId,
+          itemType: txData?.nftType
+        });
+        addTradePortListTx({ ...txData, borrowedItem });
+      }
+    });
+  }
+  if (txData?.sellerKiosk) {
+    return kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.seller,
+      kiosk: txData?.sellerKiosk,
+      async tx(kioskTx) {
+        await addTradePortKioskListTx({
+          ...txData,
+          kioskTx
+        });
+      }
+    });
+  }
+  if (!txData?.sellerKiosk && await hasTransferPolicyRules(txData?.nftType)) {
+    return kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.seller,
+      kiosk: txData?.sellerKiosk,
+      async tx(kioskTx) {
+        kioskTx.place({
+          item: txData?.nftTokenId,
+          itemType: txData?.nftType
+        });
+        await addTradePortKioskListTx({
+          ...txData,
+          kioskTx
+        });
+      }
+    });
+  }
+  addTradePortListTx(txData);
+}
+
+// src/methods/listNfts/addRelistTxs.ts
+function addTradePortRelistTx({
+  txBlock,
+  nftType,
+  collectionId,
+  listingNonce,
+  listPrice,
+  seller
+}) {
+  const parsedListPrice = parseSUI(listPrice);
+  const marketFeePrice = getMarketFeePrice({
+    price: parsedListPrice,
+    collectionId,
+    walletId: seller
+  });
+  txBlock.moveCall({
+    target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::listings::relist",
+    arguments: [
+      txBlock.object(TRADEPORT_LISTING_STORE),
+      txBlock.pure(listingNonce),
+      txBlock.pure(parsedListPrice),
+      txBlock.pure(marketFeePrice),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS)
+    ],
+    typeArguments: [nftType]
+  });
+}
+function addBlueMoveRelistTx(txData) {
+  const { txBlock, nftTokenId, nftType, listPrice } = txData;
+  const borrowedItem = txBlock.moveCall({
+    target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::marketplace::delist",
+    arguments: [txBlock.object(BLUEMOVE_MARKET_CONFIG_OBJECT), txBlock.pure(nftTokenId)],
+    typeArguments: [nftType, nftType]
+  });
+  addTradePortListTx({ ...txData, listPrice, borrowedItem });
+}
+function addTocenRelistTx(txData) {
+  const { txBlock, nftTokenId, nftType, listPrice } = txData;
+  const borrowedItem = txBlock.moveCall({
+    target: "0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::delist",
+    arguments: [txBlock.pure(TOCEN_MARKETPLACE_OBJECT), txBlock.pure(nftTokenId)],
+    typeArguments: [nftType]
+  });
+  addTradePortListTx({ ...txData, listPrice, borrowedItem });
+}
+
+// src/methods/relistNft/relistNft.ts
+async function relistNft({ txBlock, nft, listPrice, sharedObjects, walletAddress }) {
+  const txData = {
+    txBlock,
+    sharedObjects,
+    nftTokenId: nft?.token_id,
+    nftType: getNftTypeFromNft(nft),
+    listingNonce: nft?.listings?.[0]?.nonce,
+    price: nft?.listings?.[0]?.price,
+    sellerKiosk: nft?.chain_state?.kiosk_id,
+    collectionId: nft?.collection_id,
+    seller: walletAddress
+  };
+  switch (nft?.listings?.[0]?.market_name) {
+    case "tradeport":
+      if (!isOriginByteTx(txData?.sharedObjects) && txData?.listingNonce && await isNonKioskListing(txData?.listingNonce)) {
+        addTradePortRelistTx({ ...txData, listPrice });
+      } else {
+        return kioskTxWrapper({
+          txBlock: txData?.txBlock,
+          kioskOwner: txData?.seller,
+          kiosk: txData?.sellerKiosk,
+          async tx(kioskTx) {
+            await addTradePortKioskUnlistTx({
+              ...txData,
+              kioskTx
+            });
+            await addTradePortKioskListTx({
+              ...txData,
+              kioskTx,
+              listPrice
+            });
+          }
+        });
+      }
+      break;
+    case "hyperspace":
+      await addHyperspaceUnlistTxHandler(txData);
+      await addTradePortListTxHandler({ ...txData, listPrice });
+      break;
+    case "bluemove":
+      if (!isOriginByteTx(txData?.sharedObjects) && !txData?.sellerKiosk) {
+        addBlueMoveRelistTx({ ...txData, listPrice });
+      } else {
+        await addBluemoveUnlistTxHandler(txData);
+        await addTradePortListTxHandler({ ...txData, listPrice });
+      }
+      break;
+    case "clutchy":
+      await addClutchyUnlistTxHandler(txData);
+      await addTradePortListTxHandler({ ...txData, listPrice });
+      break;
+    case "souffl3":
+      break;
+    case "somis":
+      break;
+    case "keepsake":
+      break;
+    case "tocen":
+      addTocenRelistTx({ ...txData, listPrice });
+      break;
+    default:
+      throw new Error("Marketplace not supported");
+  }
+}
+
+// src/methods/listNfts/listNfts.ts
+var listNfts = async ({ nfts, walletAddress }) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchNftsWithListingsById,
+    variables: { nftIds: nfts.map((nft) => nft.id) }
+  });
+  if (res?.nfts?.length === 0) {
+    throw new Error("No nfts found");
+  }
+  const txBlock = new TransactionBlock5();
+  for (const nft of res.nfts) {
+    const sharedObjects = await getSharedObjects(
+      nft?.properties?.nft_type || nft?.contract?.properties?.nft_type
+    );
+    if (nft?.listed) {
+      await relistNft({
+        txBlock,
+        sharedObjects,
+        nft,
+        listPrice: nfts?.find((n) => n.id === nft?.id)?.listPrice,
+        walletAddress
+      });
+    } else {
+      const listTxData = {
+        txBlock,
+        sharedObjects,
+        seller: walletAddress,
+        collectionId: nft?.collection_id,
+        nftTokenId: nft?.token_id,
+        nftType: getNftTypeFromNft(nft),
+        listPrice: nfts?.find((n) => n.id === nft?.id)?.listPrice,
+        sellerKiosk: nft?.chain_state?.kiosk_id
+      };
+      await addTradePortListTxHandler(listTxData);
+    }
+  }
+  return new TransactionBlock5(txBlock);
+};
+
+// src/methods/placeCollectionBids/placeCollectionBids.ts
+import { TransactionBlock as TransactionBlock6 } from "@mysten/sui.js/transactions";
+
+// src/graphql/queries/fetchCollectionsById.ts
+import { gql as gql13 } from "graphql-request";
+var fetchCollectionsById = gql13`
+	query fetchCollectionsById($collectionIds: [uuid!]) {
+		collections(where: { id: { _in: $collectionIds } }) {
+			id
+			contract {
+				properties
+			}
+		}
+	}
+`;
+var fetchCollectionsByIdWithOneNft = gql13`
+	query fetchCollectionsByIdWithOneNft($collectionIds: [uuid!]) {
+		collections(where: { id: { _in: $collectionIds } }) {
+			id
+			contract {
+				properties
+			}
+			nfts(limit: 1) {
+				id
+				properties
+				contract {
+					properties
+				}
+			}
+		}
+	}
+`;
+
+// src/helpers/getTradeportBiddingContractParsedBidAmount.ts
+var getTradeportBiddingContractParsedBidAmount = ({ 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 Number(parseSUI(amount));
+};
+
+// src/helpers/hasRoyaltyRule.ts
+var hasRoyaltyRule = async (nftType) => {
+  const nftTypeSplit = nftType?.split("::");
+  if (nftTypeSplit?.[0])
+    nftTypeSplit[0] = addLeadingZerosAfter0x(nftTypeSplit[0]);
+  const res = await kioskClient_default.getTransferPolicies({ type: nftTypeSplit?.join("::") });
+  return res?.some(
+    (policy) => policy?.rules?.filter((rule) => rule?.includes("royalty_rule"))?.length > 0
+  );
+};
+
+// src/methods/placeCollectionBids/addPlaceCollectionBidTxs.ts
+function addTradePortCollectionBidTx({
+  txBlock,
+  collectionId,
+  nftType,
+  bidAmount,
+  bidder
+}) {
+  const parsedBidAmount = getTradeportBiddingContractParsedBidAmount({ bidAmount, collectionId });
+  const marketFeePrice = getMarketFeePrice({
+    price: Number(parseSUI(bidAmount)),
+    collectionId,
+    walletId: bidder
+  });
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(parsedBidAmount + marketFeePrice)] });
+  txBlock.moveCall({
+    target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::collection_bid",
+    arguments: [
+      txBlock.object(TRADEPORT_BIDDING_STORE),
+      txBlock.pure(parsedBidAmount),
+      txBlock.object(coin),
+      txBlock.pure(marketFeePrice),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS)
+    ],
+    typeArguments: [nftType]
+  });
+  destroyZeroCoin({ txBlock, coin });
+}
+function addTradePortKioskCollectionBidTx({
+  txBlock,
+  collectionId,
+  nftType,
+  bidAmount,
+  sharedObjects,
+  bidder,
+  royaltyRulePackageId,
+  royaltyRuleModule
+}) {
+  const { transferPolicy } = sharedObjects;
+  const parsedBidAmount = Number(parseSUI(bidAmount));
+  const marketFeePrice = getMarketFeePrice({
+    price: parsedBidAmount,
+    collectionId,
+    walletId: bidder
+  });
+  const fee = txBlock.moveCall({
+    target: `${royaltyRulePackageId}::${royaltyRuleModule}::fee_amount`,
+    arguments: [txBlock.object(transferPolicy), txBlock.pure(parsedBidAmount)],
+    typeArguments: [nftType]
+  });
+  const [coin1, coin2] = splitCoins({
+    txBlock,
+    amounts: [txBlock.pure(parsedBidAmount + marketFeePrice), txBlock.object(fee)]
+  });
+  if (!coin1 || !coin2)
+    throw new Error("Coin could not be split");
+  txBlock.mergeCoins(txBlock.object(coin1), [txBlock.object(coin2)]);
+  txBlock.moveCall({
+    target: "0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_biddings::collection_bid",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_BIDDING_STORE),
+      txBlock.pure(parsedBidAmount),
+      txBlock.object(coin1),
+      txBlock.pure(marketFeePrice),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS)
+    ],
+    typeArguments: [nftType]
+  });
+  destroyZeroCoin({ txBlock, coin: coin1 });
+}
+async function addOriginByteCollectionBidTx({
+  txBlock,
+  collectionId,
+  nftType,
+  bidAmount,
+  bidder,
+  sharedObjects,
+  bidderKiosk
+}) {
+  const { orderbook } = sharedObjects;
+  const parsedBidAmount = Number(parseSUI(bidAmount));
+  const marketFeePrice = getMarketFeePrice({
+    price: parsedBidAmount,
+    collectionId,
+    walletId: bidder
+  });
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(parsedBidAmount + marketFeePrice)] });
+  txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::create_bid_with_commission",
+    arguments: [
+      txBlock.object(orderbook),
+      txBlock.object(bidderKiosk),
+      txBlock.pure(parsedBidAmount),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS),
+      txBlock.pure(marketFeePrice),
+      txBlock.object(coin)
+    ],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+  destroyZeroCoin({ txBlock, coin });
+}
+async function addTradePortPlaceCollectionBidTxHandler(txData) {
+  if (await hasRoyaltyRule(txData?.nftType)) {
+    const royaltyRuleModule = txData?.collectionId === "fa58ae52-b18d-4179-a2d4-c2471ede5f14" ? "kiosk_royalty_rule" : "royalty_rule";
+    const royaltyRulePackageId = await getRulePackageId(txData.nftType, royaltyRuleModule);
+    addTradePortKioskCollectionBidTx({ ...txData, royaltyRulePackageId, royaltyRuleModule });
+    return;
+  }
+  addTradePortCollectionBidTx(txData);
+}
+
+// src/methods/placeCollectionBids/placeCollectionBids.ts
+var placeCollectionBids = async ({
+  collections,
+  walletAddress
+}) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: collections?.some(
+      (collection) => collection.id === "fa58ae52-b18d-4179-a2d4-c2471ede5f14" || // S-Card
+      collection.id === "ca37bbb2-4398-46cb-b467-8a834d2d2612" || // S-Card mint ticket
+      collection.id === "c8e19183-3a9e-4312-939f-c63a1416e344" || // Panzerdogs
+      collection.id === "819eabe2-1565-4c3a-a9f6-1b5fca48e09a"
+      // Panzerdog Tanks
+    ) ? fetchCollectionsByIdWithOneNft : fetchCollectionsById,
+    variables: { collectionIds: collections.map((collection) => collection.id) }
+  });
+  if (res?.collections?.length === 0) {
+    throw new Error("No collection found");
+  }
+  if (res?.collections?.length === 0) {
+    throw new Error("No collection found");
+  }
+  const txBlock = new TransactionBlock6();
+  for (const collection of res.collections) {
+    const nftType = collections?.some(
+      (collection2) => collection2.id === "fa58ae52-b18d-4179-a2d4-c2471ede5f14" || // S-Card
+      collection2.id === "ca37bbb2-4398-46cb-b467-8a834d2d2612" || // S-Card mint ticket
+      collection2.id === "c8e19183-3a9e-4312-939f-c63a1416e344" || // Panzerdogs
+      collection2.id === "819eabe2-1565-4c3a-a9f6-1b5fca48e09a"
+      // Panzerdog Tanks
+    ) ? getNftTypeFromNft(collection?.nfts?.[0]) : collection.id === "07231735-96de-4710-8e11-52c61a482578" ? "0x034c162f6b594cb5a1805264dd01ca5d80ce3eca6522e6ee37fd9ebfb9d3ddca::factory::PrimeMachin" : collection?.contract?.properties?.nft_type;
+    const sharedObjects = await getSharedObjects(nftType);
+    const txData = {
+      txBlock,
+      sharedObjects,
+      bidder: walletAddress,
+      collectionId: collection?.id,
+      nftType,
+      bidAmount: collections?.find((c) => c.id === collection?.id)?.bidAmount
+    };
+    const numOfBids = collections?.find((c) => c.id === collection?.id)?.numOfBids;
+    if (isOriginByteTx(txData?.sharedObjects)) {
+      const { kiosk: bidderKiosk, isNewKiosk: isNewBidderKiosk } = await getOrCreateOBKiosk({
+        txBlock,
+        address: txData.bidder
+      });
+      for (let i = 0; i < numOfBids; i++) {
+        await addOriginByteCollectionBidTx({ ...txData, bidderKiosk });
+      }
+      if (isNewBidderKiosk) {
+        await shareOriginByteKiosk({ txBlock, kiosk: bidderKiosk });
+      }
+    } else {
+      for (let i = 0; i < numOfBids; i++) {
+        await addTradePortPlaceCollectionBidTxHandler(txData);
+      }
+    }
+  }
+  return new TransactionBlock6(txBlock);
+};
+
+// src/methods/placeNftBids/placeNftBids.ts
+import { TransactionBlock as TransactionBlock7 } from "@mysten/sui.js/transactions";
+
+// src/methods/placeNftBids/addPlaceNftBidTxs.ts
+function addTradePortPlaceNftBidTx({
+  txBlock,
+  collectionId,
+  nftTokenId,
+  nftType,
+  bidAmount,
+  bidder
+}) {
+  const parsedBidAmount = getTradeportBiddingContractParsedBidAmount({ bidAmount, collectionId });
+  const marketFeePrice = getMarketFeePrice({
+    price: Number(parseSUI(bidAmount)),
+    collectionId,
+    walletId: bidder
+  });
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(parsedBidAmount + marketFeePrice)] });
+  txBlock.moveCall({
+    target: "0x398aae1ad267d989dcc99ba449b0a30101a6b851ec1284ccddab5937df66bfcf::biddings::bid",
+    arguments: [
+      txBlock.object(TRADEPORT_BIDDING_STORE),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(parsedBidAmount),
+      txBlock.object(coin),
+      txBlock.pure(marketFeePrice),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS)
+    ],
+    typeArguments: [nftType]
+  });
+  destroyZeroCoin({ txBlock, coin });
+}
+function addTradePortKioskPlaceNftBidTx({
+  txBlock,
+  sharedObjects,
+  collectionId,
+  nftTokenId,
+  nftType,
+  bidAmount,
+  bidder,
+  royaltyRulePackageId
+}) {
+  const { transferPolicy } = sharedObjects;
+  const bidPrice = Number(parseSUI(bidAmount));
+  const marketFeePrice = getMarketFeePrice({ price: bidPrice, collectionId, walletId: bidder });
+  const royaltyCoin = txBlock.moveCall({
+    target: `${royaltyRulePackageId}::royalty_rule::fee_amount`,
+    arguments: [txBlock.object(transferPolicy), txBlock.pure(bidPrice?.toString())],
+    typeArguments: [nftType]
+  });
+  const [coin1, coin2] = splitCoins({
+    txBlock,
+    amounts: [txBlock.pure(bidPrice + marketFeePrice), txBlock.object(royaltyCoin)]
+  });
+  txBlock.mergeCoins(txBlock.object(coin1), [txBlock.object(coin2)]);
+  txBlock.moveCall({
+    target: "0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_biddings::bid",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_BIDDING_STORE),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(bidPrice),
+      txBlock.object(coin1),
+      txBlock.pure(marketFeePrice),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS)
+    ],
+    typeArguments: [nftType]
+  });
+  destroyZeroCoin({ txBlock, coin: coin1 });
+}
+async function addOriginBytePlaceNftBidTx({
+  txBlock,
+  nftTokenId,
+  collectionId,
+  bidAmount,
+  bidder
+}) {
+  const { kiosk: bidderKiosk, isNewKiosk: isNewBidderKiosk } = await getOrCreateOBKiosk({
+    txBlock,
+    address: bidder,
+    createMethod: "create_for_sender"
+  });
+  const parsedBidAmount = Number(parseSUI(bidAmount));
+  const marketFeePrice = getMarketFeePrice({
+    price: parsedBidAmount,
+    collectionId,
+    walletId: bidder
+  });
+  const [coin] = splitCoins({ txBlock, amounts: [txBlock.pure(parsedBidAmount + marketFeePrice)] });
+  txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::create_bid_with_commission",
+    arguments: [
+      isNewBidderKiosk ? txBlock.object(bidderKiosk) : txBlock.pure(bidderKiosk),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(parsedBidAmount),
+      txBlock.pure(TRADEPORT_BENEFICIARY_ADDRESS),
+      txBlock.pure(marketFeePrice),
+      txBlock.object(coin)
+    ],
+    typeArguments: ["0x2::sui::SUI"]
+  });
+  destroyZeroCoin({ txBlock, coin });
+}
+async function addTradePortPlaceNftBidTxHandler(txData) {
+  if (isOriginByteTx(txData?.sharedObjects)) {
+    await addOriginBytePlaceNftBidTx(txData);
+    return;
+  }
+  if (await hasTransferPolicyRules(txData?.nftType) && txData?.sellerKiosk) {
+    const royaltyRulePackageId = await getRulePackageId(txData.nftType, "royalty_rule");
+    addTradePortKioskPlaceNftBidTx({ ...txData, royaltyRulePackageId });
+    return;
+  }
+  addTradePortPlaceNftBidTx(txData);
+}
+
+// src/methods/placeNftBids/placeNftBids.ts
+var placeNftBids = async ({
+  nfts,
+  walletAddress
+}) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchNftsById,
+    variables: { nftIds: nfts.map((nft) => nft.id) }
+  });
+  if (res?.nfts?.length === 0) {
+    throw new Error("No nfts found");
+  }
+  const txBlock = new TransactionBlock7();
+  for (const nft of res.nfts) {
+    const sharedObjects = await getSharedObjects(
+      nft?.properties?.nft_type || nft?.contract?.properties?.nft_type
+    );
+    const txData = {
+      txBlock,
+      sharedObjects,
+      bidder: walletAddress,
+      collectionId: nft?.collection_id,
+      nftTokenId: nft?.token_id,
+      nftType: nft?.properties?.nft_type || nft?.contract?.properties?.nft_type,
+      bidAmount: nfts?.find((n) => n.id === nft?.id)?.bidAmount,
+      sellerKiosk: nft?.chain_state?.kiosk_id
+    };
+    await addTradePortPlaceNftBidTxHandler(txData);
+  }
+  return new TransactionBlock7(txBlock);
+};
+
+// src/methods/removeCollectionBid/removeCollectionBid.ts
+import { TransactionBlock as TransactionBlock8 } from "@mysten/sui.js/transactions";
+
+// src/methods/removeNftBids/addRemoveNftBidTxs.ts
+function addTradeportRemoveNftBidTx({ txBlock, bidNonce, nftType }) {
+  txBlock.moveCall({
+    target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::cancel_bid",
+    arguments: [txBlock.object(TRADEPORT_BIDDING_STORE), txBlock.pure(bidNonce)],
+    typeArguments: [nftType]
+  });
+}
+function addTradeportKioskRemoveNftBidTx({ txBlock, bidNonce, nftType }) {
+  txBlock.moveCall({
+    target: "0x33a9e4a3089d911c2a2bf16157a1d6a4a8cbd9a2106a98ecbaefe6ed370d7a25::kiosk_biddings::cancel_bid",
+    arguments: [txBlock.object(TRADEPORT_KIOSK_BIDDING_STORE), txBlock.pure(bidNonce)],
+    typeArguments: [nftType]
+  });
+}
+function addOriginByteRemoveNftBidTx({ txBlock, bidNonce }) {
+  txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::bidding::close_bid",
+    arguments: [txBlock.pure(bidNonce)],
+    typeArguments: ["0x2::sui::SUI"]
+  });
+}
+function addBluemoveRemoveNftBidTx({
+  txBlock,
+  bidNonce,
+  nftTokenId,
+  nftType
+}) {
+  txBlock.moveCall({
+    target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_item::cancel_offer_nft",
+    arguments: [
+      txBlock.object(BLUEMOVE_OFFER_DATA_OBJECT),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(bidNonce)
+    ],
+    typeArguments: [nftType]
+  });
+}
+function addTocenRemoveNftBidTx({ txBlock, nftTokenId, bidAmount }) {
+  txBlock.moveCall({
+    target: "0x3605d91c559e80cf8fdeabae9abaccb0bc38f96eac0b32bf47e95a9159a5277f::tocen_marketplace::cancel_offer",
+    arguments: [
+      txBlock.pure(TOCEN_MARKETPLACE_OBJECT),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(bidAmount)
+    ],
+    typeArguments: []
+  });
+}
+async function addTradePortRemoveNftBidTxHandler(txData) {
+  const bidType = await getObjectType(txData?.bidNonce);
+  if (isOriginByteBid(bidType)) {
+    addOriginByteRemoveNftBidTx(txData);
+    return;
+  }
+  if (isTradePortKioskBid(bidType)) {
+    addTradeportKioskRemoveNftBidTx(txData);
+    return;
+  }
+  addTradeportRemoveNftBidTx(txData);
+}
+
+// src/methods/removeCollectionBid/addRemoveCollectionBidTxs.ts
+function addTradeportRemoveCollectionBidTx({
+  txBlock,
+  nftType,
+  bidNonce
+}) {
+  txBlock.moveCall({
+    target: "0xb42dbb7413b79394e1a0175af6ae22b69a5c7cc5df259cd78072b6818217c027::biddings::cancel_bid",
+    arguments: [txBlock.object(TRADEPORT_BIDDING_STORE), txBlock.pure(bidNonce)],
+    typeArguments: [nftType]
+  });
+}
+function addTradePortKioskRemoveCollectionBidTx(txData) {
+  addTradeportKioskRemoveNftBidTx(txData);
+}
+function addOriginByteRemoveCollectionBidTx({
+  txBlock,
+  nftType,
+  bidAmount,
+  bidder,
+  sharedObjects
+}) {
+  const { orderbook } = sharedObjects;
+  const [coin] = txBlock.moveCall({
+    target: "0x2::coin::zero",
+    arguments: [],
+    typeArguments: ["0x2::sui::SUI"]
+  });
+  txBlock.moveCall({
+    target: "0x8534e4cdfd28709c94330a9783c3d5fe6f5daba0bffb69102ce303c5b38aed5a::orderbook::cancel_bid",
+    arguments: [txBlock.object(orderbook), txBlock.pure(bidAmount), txBlock.object(coin)],
+    typeArguments: [nftType, "0x2::sui::SUI"]
+  });
+  txBlock.transferObjects([txBlock.object(coin)], txBlock.pure(addLeadingZerosAfter0x(bidder)));
+}
+function addBluemoveRemoveCollectionBidTx({
+  txBlock,
+  nftType,
+  bidNonce
+}) {
+  txBlock.moveCall({
+    target: "0xd5dd28cc24009752905689b2ba2bf90bfc8de4549b9123f93519bb8ba9bf9981::offer_collection::cancel_offer_collection",
+    arguments: [txBlock.object(BLUEMOVE_OFFER_COLLECTION_DATA_OBJECT), txBlock.pure(bidNonce)],
+    typeArguments: [nftType]
+  });
+}
+function addBluemoveKioskRemoveCollectionBidTx({
+  txBlock,
+  nftType,
+  bidNonce
+}) {
+  txBlock.moveCall({
+    target: "0xcc97b74ed95c8e8a3ed88050a898727dee37896da579fc400d482b64db6149ff::kiosk_offer_collection_v2::cancel_offer_collection_v2",
+    arguments: [
+      txBlock.object(BLUEMOVE_KIOSK_OFFER_COLLECTION_DATA_OBJECT),
+      txBlock.pure(bidNonce)
+    ],
+    typeArguments: [nftType]
+  });
+}
+async function addTradePortRemoveCollectionBidTxHandler(txData) {
+  const bidType = await getObjectType(txData?.bidNonce);
+  if (isOriginByteBid(bidType)) {
+    addOriginByteRemoveCollectionBidTx(txData);
+    return;
+  }
+  if (isTradePortKioskBid(bidType)) {
+    addTradePortKioskRemoveCollectionBidTx(txData);
+    return;
+  }
+  addTradeportRemoveCollectionBidTx(txData);
+}
+async function addBluemoveRemoveCollectionBidTxHandler(txData) {
+  const bidType = await getObjectType(txData?.bidNonce);
+  if (isOriginByteBid(bidType)) {
+    addOriginByteRemoveCollectionBidTx(txData);
+    return;
+  }
+  if (isBluemoveKioskBid(txData?.bidNonce)) {
+    addBluemoveKioskRemoveCollectionBidTx(txData);
+    return;
+  }
+  addBluemoveRemoveCollectionBidTx(txData);
+}
+async function addClutchyRemoveCollectionBidTxHandler(txData) {
+  addOriginByteRemoveCollectionBidTx(txData);
+}
+
+// src/methods/removeCollectionBid/removeCollectionBid.ts
+var removeCollectionBid = async ({
+  bidId
+}) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchCollectionBidById,
+    variables: { bidId }
+  });
+  if (res?.bids?.length === 0) {
+    throw new Error("No bids found");
+  }
+  const txBlock = new TransactionBlock8();
+  for (const bid of res.bids) {
+    let nftType;
+    if ([
+      "fa58ae52-b18d-4179-a2d4-c2471ede5f14",
+      // S-Card
+      "ca37bbb2-4398-46cb-b467-8a834d2d2612",
+      // S-Card mint ticket
+      "c8e19183-3a9e-4312-939f-c63a1416e344",
+      // Panzerdogs
+      "819eabe2-1565-4c3a-a9f6-1b5fca48e09a"
+      // Panzerdog Tanks
+    ]?.includes(bid?.collection_id)) {
+      const collectionWithOneNftRes = await gqlChainRequest({
+        chain: "sui",
+        query: fetchCollectionsByIdWithOneNft,
+        variables: { collectionIds: [bid?.collection_id] }
+      });
+      nftType = getNftTypeFromNft(collectionWithOneNftRes?.collections?.[0]?.nfts?.[0]);
+    } else if (bid?.collection_id === "07231735-96de-4710-8e11-52c61a482578") {
+      nftType = "0x034c162f6b594cb5a1805264dd01ca5d80ce3eca6522e6ee37fd9ebfb9d3ddca::factory::PrimeMachin";
+    } else {
+      nftType = bid?.contract?.properties?.nft_type;
+    }
+    const sharedObjects = await getSharedObjects(nftType);
+    const txData = {
+      txBlock,
+      sharedObjects,
+      bidNonce: bid?.nonce,
+      bidder: bid?.bidder,
+      nftType,
+      nftTokenId: bid?.nft?.token_id,
+      bidAmount: bid?.price,
+      sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
+      bidMarketName: bid?.market_contract?.name
+    };
+    switch (txData.bidMarketName) {
+      case "tradeport":
+        await addTradePortRemoveCollectionBidTxHandler(txData);
+        break;
+      case "bluemove":
+        await addBluemoveRemoveCollectionBidTxHandler(txData);
+        break;
+      case "clutchy":
+        await addClutchyRemoveCollectionBidTxHandler(txData);
+        break;
+      default:
+        throw new Error("Marketplace not supported");
+    }
+  }
+  return new TransactionBlock8(txBlock);
+};
+
+// src/methods/removeNftBids/removeNftBids.ts
+import { TransactionBlock as TransactionBlock9 } from "@mysten/sui.js/transactions";
+var removeNftBids = async ({ bidIds }) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchBidsById,
+    variables: { bidIds }
+  });
+  if (res?.bids?.length === 0) {
+    throw new Error("No bids found");
+  }
+  const txBlock = new TransactionBlock9();
+  for (const bid of res.bids) {
+    const sharedObjects = await getSharedObjects(
+      bid?.nft?.properties?.nft_type || bid?.nft?.contract?.properties?.nft_type
+    );
+    const txData = {
+      txBlock,
+      sharedObjects,
+      bidNonce: bid?.nonce,
+      nftType: getNftTypeFromNft(bid?.nft),
+      nftTokenId: bid?.nft?.token_id,
+      bidAmount: bid?.price,
+      sellerKiosk: bid?.nft?.chain_state?.kiosk_id,
+      bidMarketName: bid?.market_contract?.name
+    };
+    switch (txData.bidMarketName) {
+      case "tradeport":
+        await addTradePortRemoveNftBidTxHandler(txData);
+        break;
+      case "clutchy":
+        addOriginByteRemoveNftBidTx(txData);
+        break;
+      case "bluemove":
+        addBluemoveRemoveNftBidTx(txData);
+        break;
+      case "tocen":
+        addTocenRemoveNftBidTx(txData);
+        break;
+      default:
+        throw new Error("Marketplace not supported");
+    }
+  }
+  return new TransactionBlock9(txBlock);
+};
+
+// src/methods/transferNfts/transferNfts.ts
+import { TransactionBlock as TransactionBlock10 } from "@mysten/sui.js/transactions";
+
+// src/graphql/queries/fetchCryptoToUsdRate.ts
+import { gql as gql14 } from "graphql-request";
+var fetchCryptoToUsdRate = gql14`
+	query fetchCryptoToUsdRate($crypto: String!) {
+		crypto_rates(where: { crypto: { _eq: $crypto }, fiat: { _eq: "USD" } }) {
+			crypto
+			fiat
+			id
+			rate
+			timestamp
+		}
+	}
+`;
+
+// src/helpers/getSuiToUsdRate.ts
+var getSuiToUsdRate = async () => {
+  try {
+    const res = await gqlChainRequest({
+      chain: "sui",
+      query: fetchCryptoToUsdRate,
+      variables: { crypto: "sui" }
+    });
+    return res?.crypto_rates?.[0]?.rate;
+  } catch (e) {
+    console.log(e);
+  }
+};
+
+// src/helpers/addOneDollarFee.ts
+var addOneDollarFee = async (txBlock) => {
+  const rate = await getSuiToUsdRate();
+  const companyFee = BigInt(Math.ceil(1e9 / rate));
+  const [microTxFee] = txBlock.splitCoins(txBlock.gas, [txBlock.pure(Number(companyFee))]);
+  txBlock.transferObjects(
+    [txBlock.object(microTxFee)],
+    txBlock.pure(addLeadingZerosAfter0x(TRADEPORT_BENEFICIARY_ADDRESS))
+  );
+};
+
+// src/graphql/queries/fetchAccountKiosks.ts
+import { gql as gql15 } from "graphql-request";
+var fetchAccountKiosks2 = gql15`
+	query fetchAccountKiosks($accountAddress: String!) {
+		kiosks: kiosks_by_owner_address(owner_address: $accountAddress) {
+			id
+			is_origin_byte
+			owner_address
+			profits
+		}
+	}
+`;
+
+// src/helpers/originByte/isOBKiosk.ts
+var isOBKiosk = async (accountAddress, kiosk) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchAccountKiosks2,
+    variables: { accountAddress: addLeadingZerosAfter0x(accountAddress) }
+  });
+  return res?.kiosks?.filter((k) => k?.id === kiosk)?.[0]?.is_origin_byte;
+};
+
+// src/helpers/rpc/getAcountBalance.ts
+var getAccountBalance = async ({ owner }) => {
+  try {
+    const res = await suiClient_default.getBalance({
+      owner: addLeadingZerosAfter0x(owner)
+    });
+    return res?.totalBalance;
+  } catch (err) {
+    return "";
+  }
+};
+
+// src/methods/transferNfts/addTransferNftTx.ts
+async function addOriginByteTransferNftTx({
+  txBlock,
+  nftTokenId,
+  nftType,
+  recipientAddress,
+  senderKiosk
+}) {
+  const recipientOBKiosk = await getOBKiosk(recipientAddress);
+  if (recipientOBKiosk) {
+    txBlock.moveCall({
+      target: "0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer",
+      arguments: [
+        txBlock.object(senderKiosk),
+        txBlock.object(recipientOBKiosk),
+        txBlock.pure(nftTokenId)
+      ],
+      typeArguments: [nftType]
+    });
+  } else {
+    txBlock.moveCall({
+      target: "0x2678c98fe23173eebea384509464eb81b1f3035a57419cb46d025000c337451a::ob_kiosk::p2p_transfer_and_create_target_kiosk",
+      arguments: [
+        txBlock.object(senderKiosk),
+        txBlock.pure(addLeadingZerosAfter0x(recipientAddress)),
+        txBlock.pure(nftTokenId)
+      ],
+      typeArguments: [nftType]
+    });
+  }
+}
+async function addTradeportKioskTransferTx({
+  txBlock,
+  sharedObjects,
+  kioskTx,
+  nftTokenId,
+  nftType,
+  recipientAddress
+}) {
+  const { transferPolicy } = sharedObjects;
+  const [transferRequest] = txBlock.moveCall({
+    target: "0x78eae99d1a7edae714b5de107f4b44ccbdf5f9ca6919498d9b024ef378dc13f7::kiosk_transfers::transfer",
+    arguments: [
+      txBlock.object(TRADEPORT_KIOSK_TRANSFERS_STORE),
+      txBlock.object(TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK),
+      txBlock.object(kioskTx.kiosk.value ?? kioskTx.kiosk),
+      txBlock.object(kioskTx.kioskCap.value ?? kioskTx.kioskCap),
+      txBlock.pure(nftTokenId),
+      txBlock.pure(addLeadingZerosAfter0x(recipientAddress)),
+      txBlock.object(transferPolicy)
+    ],
+    typeArguments: [nftType]
+  });
+  await resolveTransferPolicies({
+    txBlock,
+    kioskTx,
+    nftType,
+    price: "0",
+    transferRequest,
+    kioskToLockRuleProve: TRADEPORT_KIOSK_TRANSFERS_ESCROW_KIOSK,
+    shouldSkipKioskLocking: true
+  });
+}
+
+// src/methods/transferNfts/transferNfts.ts
+var transferNfts = async ({
+  nftIds,
+  recipientAddress,
+  walletAddress
+}) => {
+  if (addLeadingZerosAfter0x(recipientAddress) === addLeadingZerosAfter0x(walletAddress)) {
+    throw new Error("Cannot transfer to self");
+  }
+  const recipientAddressBalance = await getAccountBalance({ owner: recipientAddress });
+  if (!recipientAddressBalance || !recipientAddress?.includes("0x")) {
+    throw new Error("Invalid recipient address");
+  }
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchNftsById,
+    variables: { nftIds }
+  });
+  if (res?.nfts?.length === 0) {
+    throw new Error("No nfts found");
+  }
+  const txBlock = new TransactionBlock10();
+  for (const nft of res.nfts) {
+    if (nft?.listed) {
+      throw new Error("Cannot transfer a listed NFT");
+    }
+    const sharedObjects = await getSharedObjects(getNftTypeFromNft(nft));
+    const txData = {
+      txBlock,
+      nftType: getNftTypeFromNft(nft),
+      nftTokenId: nft?.token_id,
+      senderKiosk: nft?.chain_state?.kiosk_id,
+      senderAddress: walletAddress,
+      recipientAddress,
+      sharedObjects
+    };
+    if (!txData.senderKiosk) {
+      txBlock.transferObjects(
+        [txBlock.object(txData.nftTokenId)],
+        txBlock.pure(addLeadingZerosAfter0x(recipientAddress))
+      );
+      continue;
+    }
+    const isSenderKioskOriginByte = await isOBKiosk(txData.senderAddress, txData.senderKiosk);
+    if (isSenderKioskOriginByte) {
+      await addOriginByteTransferNftTx(txData);
+      continue;
+    }
+    await kioskTxWrapper({
+      txBlock: txData?.txBlock,
+      kioskOwner: txData?.senderAddress,
+      kiosk: txData?.senderKiosk,
+      async tx(kioskTx) {
+        await addTradeportKioskTransferTx({ ...txData, kioskTx });
+      }
+    });
+  }
+  if (res?.nfts?.length > 1) {
+    await addOneDollarFee(txBlock);
+  }
+  return new TransactionBlock10(txBlock);
+};
+
+// src/methods/unlistListings/unlistListings.ts
+import { TransactionBlock as TransactionBlock11 } from "@mysten/sui.js/transactions";
+var unlistListings = async ({
+  listingIds,
+  walletAddress
+}) => {
+  const res = await gqlChainRequest({
+    chain: "sui",
+    query: fetchListingsById,
+    variables: { listingIds }
+  });
+  if (res?.listings?.length === 0) {
+    throw new Error("No listings found");
+  }
+  const txBlock = new TransactionBlock11();
+  for (const listing of res.listings) {
+    if (!listing?.listed) {
+      throw new Error(`Listing ${listing?.id} is not listed`);
+    }
+    const sharedObjects = await getSharedObjects(
+      listing?.nft?.properties?.nft_type || listing?.nft?.contract?.properties?.nft_type
+    );
+    const txData = {
+      txBlock,
+      sharedObjects,
+      nftTokenId: listing.nft?.token_id,
+      nftType: getNftTypeFromNft(listing?.nft),
+      listingNonce: listing?.nonce,
+      price: listing?.price,
+      sellerKiosk: listing.nft?.chain_state?.kiosk_id,
+      collectionId: listing?.nft?.collection_id,
+      seller: walletAddress
+    };
+    switch (listing?.market_name) {
+      case "tradeport":
+        await addTradePortUnlistTxHandler(txData);
+        break;
+      case "hyperspace":
+        await addHyperspaceUnlistTxHandler(txData);
+        break;
+      case "bluemove":
+        await addBluemoveUnlistTxHandler(txData);
+        break;
+      case "clutchy":
+        await addClutchyUnlistTxHandler(txData);
+        break;
+      case "souffl3":
+        await addSouffl3UnlistTxHandler(txData);
+        break;
+      case "somis":
+        await addSomisUnlistTxHandler(txData);
+        break;
+      case "keepsake":
+        await addKeepsakeUnlistTxHandler(txData);
+        break;
+      case "tocen":
+        addTocenUnlistTxHandler(txData);
+        break;
+      default:
+        throw new Error("Marketplace not supported");
+    }
+  }
+  return new TransactionBlock11(txBlock);
+};
+
+// src/methods/withdrawKioskProfits/withdrawKioskProfits.ts
+import { TransactionBlock as TransactionBlock12 } from "@mysten/sui.js/transactions";
+var withdrawKioskProfits = async ({
+  amount,
+  walletAddress
+}) => {
+  const txBlock = new TransactionBlock12();
+  await kioskTxWrapper({
+    txBlock,
+    kioskOwner: walletAddress,
+    async tx(kioskTx) {
+      kioskTx.withdraw(addLeadingZerosAfter0x(walletAddress), amount);
+    }
+  });
+  return new TransactionBlock12(txBlock);
+};
+
+// src/SuiTradingClient.ts
+var SuiTradingClient = class {
+  constructor({ apiUser, apiKey }) {
+    graphqlClient_default.setHeaders({
+      "x-api-user": apiUser,
+      "x-api-key": apiKey
+    });
+  }
+  async buyListings({ listingIds, walletAddress }) {
+    return buyListings({ listingIds, walletAddress });
+  }
+  async listNfts({ nfts, walletAddress }) {
+    return listNfts({ nfts, walletAddress });
+  }
+  async unlistListings({ listingIds, walletAddress }) {
+    return unlistListings({ listingIds, walletAddress });
+  }
+  async placeNftBids({ nfts, walletAddress }) {
+    return placeNftBids({ nfts, walletAddress });
+  }
+  async removeNftBids({ bidIds }) {
+    return removeNftBids({ bidIds });
+  }
+  async acceptNftBids({ bidIds }) {
+    return acceptNftBids({ bidIds });
+  }
+  async placeCollectionBid({
+    collectionId,
+    bidAmount,
+    numOfBids,
+    walletAddress
+  }) {
+    return placeCollectionBids({
+      collections: [
+        {
+          id: collectionId,
+          bidAmount,
+          numOfBids
+        }
+      ],
+      walletAddress
+    });
+  }
+  async acceptCollectionBid({ bidId, nftId, walletAddress }) {
+    const collectionBidRes = await gqlChainRequest({
+      chain: "sui",
+      query: fetchCollectionBidById,
+      variables: { bidId }
+    });
+    const bid = collectionBidRes?.bids?.[0];
+    if (!bid) {
+      throw new Error("No bid found");
+    }
+    if (bid?.status !== "active") {
+      throw new Error("Bid not active");
+    }
+    if (bid?.type !== "collection") {
+      throw new Error("Bid is not a collection bid. Use acceptNftBid() instead.");
+    }
+    const allBidsWithSameHighestPriceRes = await gqlChainRequest({
+      chain: "sui",
+      query: fetchCollectionBidsAtSamePrice,
+      variables: {
+        collectionId: bid?.collection_id,
+        price: bid?.price
+      }
+    });
+    const allBidsWithSameHighestPrice = allBidsWithSameHighestPriceRes?.bids;
+    for (let i = 0; i < allBidsWithSameHighestPrice?.length; i++) {
+      try {
+        const txBlock = await acceptCollectionBid({
+          bid: allBidsWithSameHighestPrice?.[i],
+          nftId,
+          walletAddress
+        });
+        txBlock.setSenderIfNotSet(walletAddress);
+        const rawTransaction = await txBlock.build({ client: suiClient_default });
+        await suiClient_default.dryRunTransactionBlock({
+          transactionBlock: rawTransaction
+        });
+        return txBlock;
+      } catch (err) {
+        if (i === allBidsWithSameHighestPrice.length - 1) {
+          throw err;
+        }
+      }
+    }
+  }
+  async removeCollectionBid({ bidId }) {
+    return removeCollectionBid({ bidId });
+  }
+  async transferNfts({ nftIds, recipientAddress, walletAddress }) {
+    return transferNfts({ nftIds, recipientAddress, walletAddress });
+  }
+  async claimNfts({ nftIds, walletAddress }) {
+    return claimNfts({ nftIds, walletAddress });
+  }
+  async withdrawKioskProfits({ amount, walletAddress }) {
+    return withdrawKioskProfits({ amount, walletAddress });
+  }
+};
+var SuiTradingClient_default = SuiTradingClient;
+export {
+  SuiTradingClient_default as SuiTradingClient
+};
+//# sourceMappingURL=index.mjs.map