@mysten/kiosk 0.6.0 → 0.7.0

package/dist/index.mjs

@@ -1,3 +1,29 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/utils.ts
+import { normalizeSuiAddress } from "@mysten/sui.js/utils";
+
 // src/bcs.ts
 import { bcs } from "@mysten/sui.js/bcs";
 
@@ -14,16 +40,17 @@ var KIOSK_PURCHASE_CAP = `${KIOSK_MODULE}::PurchaseCap`;
 var TRANSFER_POLICY_MODULE = "0x2::transfer_policy";
 var TRANSFER_POLICY_CREATED_EVENT = `${TRANSFER_POLICY_MODULE}::TransferPolicyCreated`;
 var TRANSFER_POLICY_TYPE = `${TRANSFER_POLICY_MODULE}::TransferPolicy`;
+var TRANSFER_POLICY_CAP_TYPE = `${TRANSFER_POLICY_MODULE}::TransferPolicyCap`;
 var KIOSK_LOCK_RULE = "kiosk_lock_rule::Rule";
 var ROYALTY_RULE = "royalty_rule::Rule";
 
-// src/types/env.ts
-var testnetEnvironment = { env: "testnet" };
-var mainnetEnvironment = { env: "mainnet" };
-var customEnvironment = (address) => ({
-  env: "custom",
-  address
-});
+// src/types/index.ts
+var Network = /* @__PURE__ */ ((Network2) => {
+  Network2["MAINNET"] = "mainnet";
+  Network2["TESTNET"] = "testnet";
+  Network2["CUSTOM"] = "custom";
+  return Network2;
+})(Network || {});
 
 // src/bcs.ts
 bcs.registerStructType(KIOSK_TYPE, {
@@ -48,26 +75,17 @@ bcs.registerStructType(TRANSFER_POLICY_TYPE, {
   rules: ["vector", "string"]
 });
 
-// src/constants.ts
-var TESTNET_RULES_PACKAGE_ADDRESS = "bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585";
-var MAINNET_RULES_PACKAGE_ADDRESS = "0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879";
-
 // src/utils.ts
-var rulesPackageAddresses = {
-  mainnet: MAINNET_RULES_PACKAGE_ADDRESS,
-  testnet: TESTNET_RULES_PACKAGE_ADDRESS,
-  devnet: "",
-  custom: null
-};
-function objArg(tx, arg) {
+var DEFAULT_QUERY_LIMIT = 50;
+function objArg(txb, arg) {
   if (typeof arg === "string") {
-    return tx.object(arg);
+    return txb.object(arg);
   }
   if ("digest" in arg && "version" in arg && "objectId" in arg) {
-    return tx.objectRef(arg);
+    return txb.objectRef(arg);
   }
   if ("objectId" in arg && "initialSharedVersion" in arg && "mutable" in arg) {
-    return tx.sharedObjectRef(arg);
+    return txb.sharedObjectRef(arg);
   }
   if ("kind" in arg) {
     return arg;
@@ -84,7 +102,7 @@ async function getKioskObject(client, id) {
   }
   return bcs.de(KIOSK_TYPE, queryRes.data.bcs.bcsBytes, "base64");
 }
-function extractKioskData(data, listings, lockedItemIds) {
+function extractKioskData(data, listings, lockedItemIds, kioskId) {
   return data.reduce(
     (acc, val) => {
       const type = getTypeWithoutPackageAddress(val.name.type);
@@ -94,7 +112,8 @@ function extractKioskData(data, listings, lockedItemIds) {
           acc.items.push({
             objectId: val.objectId,
             type: val.objectType,
-            isLocked: false
+            isLocked: false,
+            kioskId
           });
           break;
         case "kiosk::Listing":
@@ -136,6 +155,18 @@ function attachListingsAndPrices(kioskData, listings, listingObjects) {
     item.listing = itemListings[item.objectId] || void 0;
   });
 }
+function attachObjects(kioskData, objects) {
+  const mapping = objects.reduce(
+    (acc, obj) => {
+      acc[obj.objectId] = obj;
+      return acc;
+    },
+    {}
+  );
+  kioskData.items.forEach((item) => {
+    item.data = mapping[item.objectId] || void 0;
+  });
+}
 function attachLockedItems(kioskData, lockedItemIds) {
   const lockedStatuses = lockedItemIds.reduce(
     (acc, item) => {
@@ -148,14 +179,6 @@ function attachLockedItems(kioskData, lockedItemIds) {
     item.isLocked = lockedStatuses[item.objectId] || false;
   });
 }
-function getRulePackageAddress(environment) {
-  if (environment.env === "custom") {
-    if (!environment.address)
-      throw new Error("Please supply the custom package address for rules.");
-    return environment.address;
-  }
-  return rulesPackageAddresses[environment.env];
-}
 async function getAllDynamicFields(client, parentId, pagination) {
   let hasNextPage = true;
   let cursor = void 0;
@@ -172,89 +195,86 @@ async function getAllDynamicFields(client, parentId, pagination) {
   }
   return data;
 }
+async function getAllObjects(client, ids, options, limit = DEFAULT_QUERY_LIMIT) {
+  const chunks = Array.from(
+    { length: Math.ceil(ids.length / limit) },
+    (_, index) => ids.slice(index * limit, index * limit + limit)
+  );
+  const results = await Promise.all(
+    chunks.map((chunk) => {
+      return client.multiGetObjects({
+        ids: chunk,
+        options
+      });
+    })
+  );
+  return results.flat();
+}
+async function getAllOwnedObjects({
+  client,
+  owner,
+  filter,
+  limit = DEFAULT_QUERY_LIMIT,
+  options = { showType: true, showContent: true }
+}) {
+  let hasNextPage = true;
+  let cursor = void 0;
+  const data = [];
+  while (hasNextPage) {
+    const result = await client.getOwnedObjects({
+      owner,
+      filter,
+      limit,
+      cursor,
+      options
+    });
+    data.push(...result.data);
+    hasNextPage = result.hasNextPage;
+    cursor = result.nextCursor;
+  }
+  return data;
+}
 function percentageToBasisPoints(percentage) {
   if (percentage < 0 || percentage > 100)
     throw new Error("Percentage needs to be in the [0,100] range.");
   return Math.ceil(percentage * 100);
 }
-
-// src/tx/transfer-policy.ts
-function createTransferPolicy(tx, itemType, publisher) {
-  let [transferPolicy, transferPolicyCap] = tx.moveCall({
-    target: `${TRANSFER_POLICY_MODULE}::new`,
-    typeArguments: [itemType],
-    arguments: [objArg(tx, publisher)]
-  });
-  tx.moveCall({
-    target: `0x2::transfer::public_share_object`,
-    typeArguments: [`${TRANSFER_POLICY_TYPE}<${itemType}>`],
-    arguments: [transferPolicy]
-  });
-  return transferPolicyCap;
-}
-function withdrawFromPolicy(tx, itemType, policy, policyCap, amount) {
-  let amountArg = amount !== null ? tx.pure({ Some: amount }, "Option<u64>") : tx.pure({ None: true }, "Option<u64>");
-  let [profits] = tx.moveCall({
-    target: `${TRANSFER_POLICY_MODULE}::withdraw`,
-    typeArguments: [itemType],
-    arguments: [objArg(tx, policy), objArg(tx, policyCap), amountArg]
-  });
-  return profits;
-}
-function confirmRequest(tx, itemType, policy, request) {
-  tx.moveCall({
-    target: `${TRANSFER_POLICY_MODULE}::confirm_request`,
-    typeArguments: [itemType],
-    arguments: [objArg(tx, policy), request]
-  });
-}
-function removeTransferPolicyRule(tx, itemType, ruleType, configType, policy, policyCap) {
-  tx.moveCall({
-    target: `${TRANSFER_POLICY_MODULE}::remove_rule`,
-    typeArguments: [itemType, ruleType, configType],
-    arguments: [objArg(tx, policy), policyCap]
-  });
+function parseTransferPolicyCapObject(item) {
+  const type = item?.data?.content?.type;
+  const policy = item?.data?.content?.fields?.policy_id;
+  if (!type.includes(TRANSFER_POLICY_CAP_TYPE))
+    return void 0;
+  const objectType = type.replace(TRANSFER_POLICY_CAP_TYPE + "<", "").slice(0, -1);
+  return {
+    policyId: policy,
+    policyCapId: item.data?.objectId,
+    type: objectType
+  };
 }
-function resolveRoyaltyRule(tx, itemType, price, policyId, transferRequest, environment) {
-  const policyObj = objArg(tx, policyId);
-  const [amount] = tx.moveCall({
-    target: `${getRulePackageAddress(environment)}::royalty_rule::fee_amount`,
-    typeArguments: [itemType],
-    arguments: [policyObj, objArg(tx, price)]
-  });
-  const feeCoin = tx.splitCoins(tx.gas, [amount]);
-  tx.moveCall({
-    target: `${getRulePackageAddress(environment)}::royalty_rule::pay`,
-    typeArguments: [itemType],
-    arguments: [policyObj, transferRequest, feeCoin]
-  });
-}
-function resolveKioskLockRule(tx, itemType, item, kiosk, kioskCap, policyId, transferRequest, environment) {
-  lock(tx, itemType, kiosk, kioskCap, policyId, item);
-  tx.moveCall({
-    target: `${getRulePackageAddress(environment)}::kiosk_lock_rule::prove`,
-    typeArguments: [itemType],
-    arguments: [transferRequest, objArg(tx, kiosk)]
-  });
+function getNormalizedRuleType(rule) {
+  const normalizedRuleAddress = rule.split("::");
+  normalizedRuleAddress[0] = normalizeSuiAddress(normalizedRuleAddress[0]);
+  return normalizedRuleAddress.join("::");
 }
 
 // src/tx/kiosk.ts
 function createKiosk(tx) {
-  let [kiosk, kioskOwnerCap] = tx.moveCall({
+  const [kiosk, kioskOwnerCap] = tx.moveCall({
     target: `${KIOSK_MODULE}::new`
   });
   return [kiosk, kioskOwnerCap];
 }
 function createKioskAndShare(tx) {
-  let [kiosk, kioskOwnerCap] = tx.moveCall({
-    target: `${KIOSK_MODULE}::new`
-  });
+  const [kiosk, kioskOwnerCap] = createKiosk(tx);
+  shareKiosk(tx, kiosk);
+  return kioskOwnerCap;
+}
+function shareKiosk(tx, kiosk) {
   tx.moveCall({
     target: `0x2::transfer::public_share_object`,
     typeArguments: [KIOSK_TYPE],
     arguments: [kiosk]
   });
-  return kioskOwnerCap;
 }
 function place(tx, itemType, kiosk, kioskCap, item) {
   tx.moveCall({
@@ -271,7 +291,7 @@ function lock(tx, itemType, kiosk, kioskCap, policy, item) {
   });
 }
 function take(tx, itemType, kiosk, kioskCap, itemId) {
-  let [item] = tx.moveCall({
+  const [item] = tx.moveCall({
     target: `${KIOSK_MODULE}::take`,
     typeArguments: [itemType],
     arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, "address")]
@@ -305,7 +325,7 @@ function placeAndList(tx, itemType, kiosk, kioskCap, item, price) {
   });
 }
 function purchase(tx, itemType, kiosk, itemId, payment) {
-  let [item, transferRequest] = tx.moveCall({
+  const [item, transferRequest] = tx.moveCall({
     target: `${KIOSK_MODULE}::purchase`,
     typeArguments: [itemType],
     arguments: [objArg(tx, kiosk), tx.pure(itemId, "address"), objArg(tx, payment)]
@@ -313,36 +333,15 @@ function purchase(tx, itemType, kiosk, itemId, payment) {
   return [item, transferRequest];
 }
 function withdrawFromKiosk(tx, kiosk, kioskCap, amount) {
-  let amountArg = amount !== null ? tx.pure(
-    {
-      Some: amount
-    },
-    "Option<u64>"
-  ) : tx.pure({ None: true }, "Option<u64>");
-  let [coin] = tx.moveCall({
+  const amountArg = tx.pure(amount ? { Some: amount } : { None: true }, "Option<u64>");
+  const [coin] = tx.moveCall({
     target: `${KIOSK_MODULE}::withdraw`,
     arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), amountArg]
   });
   return coin;
 }
-function borrow(tx, itemType, kiosk, kioskCap, itemId) {
-  let [item] = tx.moveCall({
-    target: `${KIOSK_MODULE}::borrow`,
-    typeArguments: [itemType],
-    arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, "address")]
-  });
-  return item;
-}
-function borrowMut(tx, itemType, kiosk, kioskCap, itemId) {
-  let [item] = tx.moveCall({
-    target: `${KIOSK_MODULE}::borrow_mut`,
-    typeArguments: [itemType],
-    arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, "address")]
-  });
-  return item;
-}
 function borrowValue(tx, itemType, kiosk, kioskCap, itemId) {
-  let [item, promise] = tx.moveCall({
+  const [item, promise] = tx.moveCall({
     target: `${KIOSK_MODULE}::borrow_val`,
     typeArguments: [itemType],
     arguments: [objArg(tx, kiosk), objArg(tx, kioskCap), tx.pure(itemId, "address")]
@@ -356,68 +355,132 @@ function returnValue(tx, itemType, kiosk, item, promise) {
     arguments: [objArg(tx, kiosk), item, promise]
   });
 }
-function purchaseAndResolvePolicies(tx, itemType, price, kiosk, itemId, policy, environment, extraParams) {
-  if (price === void 0 || typeof price !== "string")
-    throw new Error(`Price of the listing is not supplied.`);
-  const coin = tx.splitCoins(tx.gas, [tx.pure(price, "u64")]);
-  const [purchasedItem, transferRequest] = purchase(tx, itemType, kiosk, itemId, coin);
-  let hasKioskLockRule = false;
-  for (let rule of policy.rules) {
-    const ruleWithoutAddr = getTypeWithoutPackageAddress(rule);
-    switch (ruleWithoutAddr) {
-      case ROYALTY_RULE:
-        resolveRoyaltyRule(tx, itemType, price, policy.id, transferRequest, environment);
-        break;
-      case KIOSK_LOCK_RULE:
-        if (!extraParams?.ownedKiosk || !extraParams?.ownedKioskCap)
-          throw new Error(
-            `This item type ${itemType} has a 'kiosk_lock_rule', but function call is missing user's kiosk and kioskCap params`
-          );
-        hasKioskLockRule = true;
-        resolveKioskLockRule(
-          tx,
-          itemType,
-          purchasedItem,
-          extraParams.ownedKiosk,
-          extraParams.ownedKioskCap,
-          policy.id,
-          transferRequest,
-          environment
-        );
-        break;
-      default:
-        break;
-    }
-  }
-  confirmRequest(tx, itemType, policy.id, transferRequest);
-  return {
-    item: purchasedItem,
-    canTransfer: !hasKioskLockRule
-  };
-}
 
-// src/tx/rules.ts
-function attachRoyaltyRule(tx, type, policy, policyCap, percentageBps, minAmount, environment) {
-  if (Number(percentageBps) < 0 || Number(percentageBps) > 1e4)
-    throw new Error("Invalid basis point percentage. Use a value between [0,10000].");
-  tx.moveCall({
-    target: `${getRulePackageAddress(environment)}::royalty_rule::add`,
-    typeArguments: [type],
-    arguments: [
-      objArg(tx, policy),
-      objArg(tx, policyCap),
-      tx.pure(percentageBps, "u16"),
-      tx.pure(minAmount, "u64")
-    ]
+// src/tx/rules/resolve.ts
+function resolveRoyaltyRule(params) {
+  const { transactionBlock: txb, itemType, price, packageId, transferRequest, policyId } = params;
+  const policyObj = objArg(txb, policyId);
+  const [amount] = txb.moveCall({
+    target: `${packageId}::royalty_rule::fee_amount`,
+    typeArguments: [itemType],
+    arguments: [policyObj, objArg(txb, price ?? "")]
+  });
+  const feeCoin = txb.splitCoins(txb.gas, [amount]);
+  txb.moveCall({
+    target: `${packageId}::royalty_rule::pay`,
+    typeArguments: [itemType],
+    arguments: [policyObj, transferRequest, feeCoin]
   });
 }
-function attachKioskLockRule(tx, type, policy, policyCap, environment) {
-  tx.moveCall({
-    target: `${getRulePackageAddress(environment)}::kiosk_lock_rule::add`,
-    typeArguments: [type],
-    arguments: [objArg(tx, policy), objArg(tx, policyCap)]
+function resolveKioskLockRule(params) {
+  const {
+    transactionBlock: txb,
+    packageId,
+    itemType,
+    kiosk,
+    kioskCap,
+    policyId,
+    purchasedItem,
+    transferRequest
+  } = params;
+  if (!kiosk || !kioskCap)
+    throw new Error("Missing Owned Kiosk or Owned Kiosk Cap");
+  lock(txb, itemType, kiosk, kioskCap, policyId, purchasedItem);
+  txb.moveCall({
+    target: `${packageId}::kiosk_lock_rule::prove`,
+    typeArguments: [itemType],
+    arguments: [transferRequest, objArg(txb, kiosk)]
+  });
+}
+function resolvePersonalKioskRule(params) {
+  const { transactionBlock: txb, packageId, itemType, kiosk, transferRequest } = params;
+  if (!kiosk)
+    throw new Error("Missing owned Kiosk.");
+  txb.moveCall({
+    target: `${packageId}::personal_kiosk_rule::prove`,
+    typeArguments: [itemType],
+    arguments: [objArg(txb, kiosk), transferRequest]
   });
 }
+function resolveFloorPriceRule(params) {
+  const { transactionBlock: txb, packageId, itemType, policyId, transferRequest } = params;
+  txb.moveCall({
+    target: `${packageId}::floor_price_rule::prove`,
+    typeArguments: [itemType],
+    arguments: [objArg(txb, policyId), transferRequest]
+  });
+}
+
+// src/constants.ts
+var ROYALTY_RULE_ADDRESS = {
+  ["testnet" /* TESTNET */]: "bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585",
+  ["mainnet" /* MAINNET */]: "0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879",
+  ["custom" /* CUSTOM */]: ""
+};
+var KIOSK_LOCK_RULE_ADDRESS = {
+  ["testnet" /* TESTNET */]: "bd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585",
+  ["mainnet" /* MAINNET */]: "0x434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879",
+  ["custom" /* CUSTOM */]: ""
+};
+var FLOOR_PRICE_RULE_ADDRESS = {
+  ["testnet" /* TESTNET */]: "0x06f6bdd3f2e2e759d8a4b9c252f379f7a05e72dfe4c0b9311cdac27b8eb791b1",
+  ["mainnet" /* MAINNET */]: "0x34cc6762780f4f6f153c924c0680cfe2a1fb4601e7d33cc28a92297b62de1e0e",
+  ["custom" /* CUSTOM */]: ""
+};
+var PERSONAL_KIOSK_RULE_ADDRESS = {
+  ["testnet" /* TESTNET */]: "0x06f6bdd3f2e2e759d8a4b9c252f379f7a05e72dfe4c0b9311cdac27b8eb791b1",
+  ["mainnet" /* MAINNET */]: "0x0cb4bcc0560340eb1a1b929cabe56b33fc6449820ec8c1980d69bb98b649b802",
+  ["custom" /* CUSTOM */]: ""
+};
+function getBaseRules({
+  royaltyRulePackageId,
+  kioskLockRulePackageId,
+  personalKioskRulePackageId,
+  floorPriceRulePackageId
+}) {
+  const rules2 = [];
+  if (royaltyRulePackageId) {
+    rules2.push({
+      rule: `${royaltyRulePackageId}::royalty_rule::Rule`,
+      packageId: royaltyRulePackageId,
+      resolveRuleFunction: resolveRoyaltyRule
+    });
+  }
+  if (kioskLockRulePackageId) {
+    rules2.push({
+      rule: `${kioskLockRulePackageId}::kiosk_lock_rule::Rule`,
+      packageId: kioskLockRulePackageId,
+      resolveRuleFunction: resolveKioskLockRule,
+      hasLockingRule: true
+    });
+  }
+  if (personalKioskRulePackageId) {
+    rules2.push({
+      rule: `${personalKioskRulePackageId}::personal_kiosk_rule::Rule`,
+      packageId: personalKioskRulePackageId,
+      resolveRuleFunction: resolvePersonalKioskRule
+    });
+  }
+  if (floorPriceRulePackageId) {
+    rules2.push({
+      rule: `${floorPriceRulePackageId}::floor_price_rule::Rule`,
+      packageId: floorPriceRulePackageId,
+      resolveRuleFunction: resolveFloorPriceRule
+    });
+  }
+  return rules2;
+}
+var testnetRules = getBaseRules({
+  royaltyRulePackageId: ROYALTY_RULE_ADDRESS["testnet" /* TESTNET */],
+  kioskLockRulePackageId: KIOSK_LOCK_RULE_ADDRESS["testnet" /* TESTNET */],
+  personalKioskRulePackageId: PERSONAL_KIOSK_RULE_ADDRESS["testnet" /* TESTNET */],
+  floorPriceRulePackageId: FLOOR_PRICE_RULE_ADDRESS["testnet" /* TESTNET */]
+});
+var mainnetRules = getBaseRules({
+  royaltyRulePackageId: ROYALTY_RULE_ADDRESS["mainnet" /* MAINNET */],
+  kioskLockRulePackageId: KIOSK_LOCK_RULE_ADDRESS["mainnet" /* MAINNET */]
+});
+var rules = [...testnetRules, ...mainnetRules];
 
 // src/query/kiosk.ts
 import { isValidSuiAddress } from "@mysten/sui.js/utils";
@@ -425,20 +488,22 @@ async function fetchKiosk(client, kioskId, pagination, options) {
   const data = await getAllDynamicFields(client, kioskId, pagination);
   const listings = [];
   const lockedItemIds = [];
-  const kioskData = extractKioskData(data, listings, lockedItemIds);
-  const [kiosk, listingObjects] = await Promise.all([
+  const kioskData = extractKioskData(data, listings, lockedItemIds, kioskId);
+  const [kiosk, listingObjects, items] = await Promise.all([
     options.withKioskFields ? getKioskObject(client, kioskId) : Promise.resolve(void 0),
-    options.withListingPrices ? client.multiGetObjects({
-      ids: kioskData.listingIds,
-      options: {
-        showContent: true
-      }
-    }) : Promise.resolve([])
+    options.withListingPrices ? getAllObjects(client, kioskData.listingIds, {
+      showContent: true
+    }) : Promise.resolve([]),
+    options.withObjects ? getAllObjects(client, kioskData.itemIds, options.objectOptions || { showDisplay: true }) : Promise.resolve([])
   ]);
   if (options.withKioskFields)
     kioskData.kiosk = kiosk;
   attachListingsAndPrices(kioskData, listings, listingObjects);
   attachLockedItems(kioskData, lockedItemIds);
+  attachObjects(
+    kioskData,
+    items.filter((x) => !!x.data).map((x) => x.data)
+  );
   return {
     data: kioskData,
     nextCursor: null,
@@ -453,23 +518,37 @@ async function getOwnedKiosks(client, address, options) {
       kioskOwnerCaps: [],
       kioskIds: []
     };
+  const filter = {
+    MatchAny: [
+      {
+        StructType: KIOSK_OWNER_CAP
+      }
+    ]
+  };
+  if (options?.personalKioskType) {
+    filter.MatchAny.push({
+      StructType: options.personalKioskType
+    });
+  }
   const { data, hasNextPage, nextCursor } = await client.getOwnedObjects({
     owner: address,
-    filter: { StructType: KIOSK_OWNER_CAP },
+    filter,
     options: {
-      showContent: true
+      showContent: true,
+      showType: true
     },
     ...options?.pagination || {}
   });
   const kioskIdList = data?.map((x) => {
     const fields = x.data?.content?.dataType === "moveObject" ? x.data.content.fields : null;
-    return fields?.for;
+    return fields?.cap ? fields?.cap?.fields?.for : fields?.for;
   });
   const filteredData = data.filter((x) => "data" in x).map((x) => x.data);
   return {
     nextCursor,
     hasNextPage,
     kioskOwnerCaps: filteredData.map((x, idx) => ({
+      isPersonal: x.type !== KIOSK_OWNER_CAP,
       digest: x.digest,
       version: x.version,
       objectId: x.objectId,
@@ -480,6 +559,7 @@ async function getOwnedKiosks(client, address, options) {
 }
 
 // src/query/transfer-policy.ts
+import { isValidSuiAddress as isValidSuiAddress2 } from "@mysten/sui.js/utils";
 async function queryTransferPolicy(client, type) {
   const { data } = await client.queryEvents({
     query: {
@@ -495,7 +575,7 @@ async function queryTransferPolicy(client, type) {
     if (!policy || !policy.bcs || !("bcsBytes" in policy.bcs)) {
       throw new Error(`Invalid policy: ${policy?.objectId}, expected object, got package`);
     }
-    let parsed = bcs.de(TRANSFER_POLICY_TYPE, policy.bcs.bcsBytes, "base64");
+    const parsed = bcs.de(TRANSFER_POLICY_TYPE, policy.bcs.bcsBytes, "base64");
     return {
       id: policy?.objectId,
       type: `${TRANSFER_POLICY_TYPE}<${type}>`,
@@ -505,60 +585,987 @@ async function queryTransferPolicy(client, type) {
     };
   });
 }
+async function queryTransferPolicyCapsByType(client, address, type) {
+  if (!isValidSuiAddress2(address))
+    return [];
+  const filter = {
+    MatchAll: [
+      {
+        StructType: `${TRANSFER_POLICY_CAP_TYPE}<${type}>`
+      }
+    ]
+  };
+  const data = await getAllOwnedObjects({
+    client,
+    filter,
+    owner: address
+  });
+  return data.map((item) => parseTransferPolicyCapObject(item)).filter((item) => !!item);
+}
+async function queryOwnedTransferPolicies(client, address) {
+  if (!isValidSuiAddress2(address))
+    return;
+  const filter = {
+    MatchAll: [
+      {
+        MoveModule: {
+          module: "transfer_policy",
+          package: "0x2"
+        }
+      }
+    ]
+  };
+  const data = await getAllOwnedObjects({ client, owner: address, filter });
+  const policies = [];
+  for (const item of data) {
+    const data2 = parseTransferPolicyCapObject(item);
+    if (data2)
+      policies.push(data2);
+  }
+  return policies;
+}
+
+// src/client/kiosk-client.ts
+var KioskClient = class {
+  constructor(options) {
+    this.client = options.client;
+    this.network = options.network;
+    this.rules = rules;
+    this.packageIds = options.packageIds;
+    if (options.packageIds)
+      this.rules.push(...getBaseRules(options.packageIds));
+  }
+  /// Querying
+  /**
+   * Get an addresses's owned kiosks.
+   * @param address The address for which we want to retrieve the kiosks.
+   * @returns An Object containing all the `kioskOwnerCap` objects as well as the kioskIds.
+   */
+  async getOwnedKiosks({ address }) {
+    const personalPackageId = this.packageIds?.personalKioskRulePackageId || PERSONAL_KIOSK_RULE_ADDRESS[this.network];
+    return getOwnedKiosks(this.client, address, {
+      personalKioskType: personalPackageId ? `${personalPackageId}::personal_kiosk::PersonalKioskCap` : ""
+    });
+  }
+  /**
+   * Fetches the kiosk contents.
+   * @param kioskId The ID of the kiosk to fetch.
+   * @param options Optioal
+   * @returns
+   */
+  async getKiosk({ id, options }) {
+    return (await fetchKiosk(
+      this.client,
+      id,
+      {
+        limit: 1e3
+      },
+      options || {}
+    )).data;
+  }
+  /**
+   * Query the Transfer Policy(ies) for type `T`.
+   * @param type The Type we're querying for (E.g `0xMyAddress::hero::Hero`)
+   */
+  async getTransferPolicies({ type }) {
+    return queryTransferPolicy(this.client, type);
+  }
+  /**
+   * Query all the owned transfer policies for an address.
+   * Returns `TransferPolicyCap` which uncludes `policyId, policyCapId, type`.
+   * @param address The address we're searching the owned transfer policies for.
+   */
+  async getOwnedTransferPolicies({ address }) {
+    return queryOwnedTransferPolicies(this.client, address);
+  }
+  /**
+   * Query the Transfer Policy Cap for type `T`, owned by `address`
+   * @param type The Type `T` for the object
+   * @param address The address that owns the cap.
+   */
+  async getOwnedTransferPoliciesByType({ type, address }) {
+    return queryTransferPolicyCapsByType(this.client, address, type);
+  }
+  // Someone would just have to create a `kiosk-client.ts` file in their project, initialize a KioskClient
+  // and call the `addRuleResolver` function. Each rule has a `resolve` function.
+  // The resolve function is automatically called on `purchaseAndResolve` function call.
+  addRuleResolver(rule) {
+    if (this.rules.find((x) => x.rule === rule.rule))
+      throw new Error(`Rule ${rule.rule} resolver already exists.`);
+    this.rules.push(rule);
+  }
+  /**
+   * A convenient helper to get the packageIds for our supported ruleset,
+   * based on `kioskClient` configuration.
+   */
+  getRulePackageId(rule) {
+    const rules2 = this.packageIds || {};
+    const network = this.network;
+    if (!rules2[rule] && network !== "mainnet" /* MAINNET */ && network !== "testnet" /* TESTNET */) {
+      throw new Error(`Missing packageId for rule ${rule}`);
+    }
+    switch (rule) {
+      case "kioskLockRulePackageId":
+        return rules2[rule] || KIOSK_LOCK_RULE_ADDRESS[network];
+      case "royaltyRulePackageId":
+        return rules2[rule] || ROYALTY_RULE_ADDRESS[network];
+      case "personalKioskRulePackageId":
+        return rules2[rule] || PERSONAL_KIOSK_RULE_ADDRESS[network];
+      case "floorPriceRulePackageId":
+        return rules2[rule] || FLOOR_PRICE_RULE_ADDRESS[network];
+    }
+  }
+};
+
+// src/tx/rules/attach.ts
+function attachKioskLockRuleTx(tx, type, policy, policyCap, packageId) {
+  tx.moveCall({
+    target: `${packageId}::kiosk_lock_rule::add`,
+    typeArguments: [type],
+    arguments: [objArg(tx, policy), objArg(tx, policyCap)]
+  });
+}
+function attachRoyaltyRuleTx(tx, type, policy, policyCap, percentageBps, minAmount, packageId) {
+  if (Number(percentageBps) < 0 || Number(percentageBps) > 1e4)
+    throw new Error("Invalid basis point percentage. Use a value between [0,10000].");
+  tx.moveCall({
+    target: `${packageId}::royalty_rule::add`,
+    typeArguments: [type],
+    arguments: [
+      objArg(tx, policy),
+      objArg(tx, policyCap),
+      tx.pure(percentageBps, "u16"),
+      tx.pure(minAmount, "u64")
+    ]
+  });
+}
+function attachPersonalKioskRuleTx(tx, type, policy, policyCap, packageId) {
+  tx.moveCall({
+    target: `${packageId}::personal_kiosk_rule::add`,
+    typeArguments: [type],
+    arguments: [objArg(tx, policy), objArg(tx, policyCap)]
+  });
+}
+function attachFloorPriceRuleTx(tx, type, policy, policyCap, minPrice, packageId) {
+  tx.moveCall({
+    target: `${packageId}::floor_price_rule::add`,
+    typeArguments: [type],
+    arguments: [objArg(tx, policy), objArg(tx, policyCap), tx.pure(minPrice, "u64")]
+  });
+}
+
+// src/tx/transfer-policy.ts
+function createTransferPolicy(tx, itemType, publisher) {
+  const [transferPolicy, transferPolicyCap] = createTransferPolicyWithoutSharing(
+    tx,
+    itemType,
+    publisher
+  );
+  shareTransferPolicy(tx, itemType, transferPolicy);
+  return transferPolicyCap;
+}
+function createTransferPolicyWithoutSharing(tx, itemType, publisher) {
+  const [transferPolicy, transferPolicyCap] = tx.moveCall({
+    target: `${TRANSFER_POLICY_MODULE}::new`,
+    typeArguments: [itemType],
+    arguments: [objArg(tx, publisher)]
+  });
+  return [transferPolicy, transferPolicyCap];
+}
+function shareTransferPolicy(tx, itemType, transferPolicy) {
+  tx.moveCall({
+    target: `0x2::transfer::public_share_object`,
+    typeArguments: [`${TRANSFER_POLICY_TYPE}<${itemType}>`],
+    arguments: [transferPolicy]
+  });
+}
+function withdrawFromPolicy(tx, itemType, policy, policyCap, amount) {
+  const amountArg = tx.pure(amount ? { Some: amount } : { None: true }, "Option<u64>");
+  const [profits] = tx.moveCall({
+    target: `${TRANSFER_POLICY_MODULE}::withdraw`,
+    typeArguments: [itemType],
+    arguments: [objArg(tx, policy), objArg(tx, policyCap), amountArg]
+  });
+  return profits;
+}
+function confirmRequest(tx, itemType, policy, request) {
+  tx.moveCall({
+    target: `${TRANSFER_POLICY_MODULE}::confirm_request`,
+    typeArguments: [itemType],
+    arguments: [objArg(tx, policy), request]
+  });
+}
+function removeTransferPolicyRule(tx, itemType, ruleType, configType, policy, policyCap) {
+  tx.moveCall({
+    target: `${TRANSFER_POLICY_MODULE}::remove_rule`,
+    typeArguments: [itemType, ruleType, configType],
+    arguments: [objArg(tx, policy), objArg(tx, policyCap)]
+  });
+}
+
+// src/client/tp-transaction.ts
+var _validateInputs, validateInputs_fn, _setup, setup_fn;
+var TransferPolicyTransaction = class {
+  constructor({ kioskClient, transactionBlock, cap }) {
+    // Internal function that that the policy's Id + Cap + type have been set.
+    __privateAdd(this, _validateInputs);
+    /**
+     * Setup the state of the TransferPolicyTransaction.
+     */
+    __privateAdd(this, _setup);
+    this.kioskClient = kioskClient;
+    this.transactionBlock = transactionBlock;
+    if (cap)
+      this.setCap(cap);
+  }
+  /**
+   * A function to create a new transfer policy.
+   * Checks if there's already an existing transfer policy to prevent
+   * double transfer polciy mistakes.
+   * There's an optional `skipCheck` flag that will just create the policy
+   * without checking
+   *
+   * @param type The Type (`T`) for which we're creating the transfer policy.
+   * @param publisher The Publisher Object Id.
+   * @param address Address to save the `TransferPolicyCap` object to.
+   * @param skipCheck (Optional) skip checking if a transfer policy already exists
+   */
+  async createAndShare({
+    type,
+    publisher,
+    address,
+    skipCheck
+  }) {
+    if (!skipCheck) {
+      const policies = await this.kioskClient.getTransferPolicies({ type });
+      if (policies.length > 0)
+        throw new Error("There's already transfer policy for this Type.");
+    }
+    const cap = createTransferPolicy(this.transactionBlock, type, publisher);
+    this.transactionBlock.transferObjects([cap], this.transactionBlock.pure(address, "address"));
+  }
+  /**
+   * A convenient function to create a Transfer Policy and attach some rules
+   * before sharing it (so you can prepare it in a single PTB)
+   * @param type The Type (`T`) for which we're creating the transfer policy.
+   * @param publisher The Publisher Object Id.
+   * @param address Address to save the `TransferPolicyCap` object to.
+   * @param skipCheck (Optional) skip checking if a transfer policy already exists
+   */
+  async create({
+    type,
+    publisher,
+    skipCheck
+  }) {
+    if (!skipCheck) {
+      const policies = await this.kioskClient.getTransferPolicies({ type });
+      if (policies.length > 0)
+        throw new Error("There's already transfer policy for this Type.");
+    }
+    const [policy, policyCap] = createTransferPolicyWithoutSharing(
+      this.transactionBlock,
+      type,
+      publisher
+    );
+    __privateMethod(this, _setup, setup_fn).call(this, policy, policyCap, type);
+    return this;
+  }
+  /**
+   * This can be called after calling the `create` function to share the `TransferPolicy`,
+   * and transfer the `TransferPolicyCap` to the specified address
+   *
+   * @param address The address to transfer the `TransferPolicyCap`
+   */
+  shareAndTransferCap(address) {
+    if (!this.type || !this.policyCap || !this.policy)
+      throw new Error("This function can only be called after `transferPolicyManager.create`");
+    shareTransferPolicy(this.transactionBlock, this.type, this.policy);
+    this.transactionBlock.transferObjects(
+      [this.policyCap],
+      this.transactionBlock.pure(address, "address")
+    );
+  }
+  /**
+   * Setup the TransferPolicy by passing a `cap` returned from `kioskClient.getOwnedTransferPolicies` or
+   * `kioskClient.getOwnedTransferPoliciesByType`.
+   * @param policyCapId The `TransferPolicyCap`
+   */
+  setCap({ policyId, policyCapId, type }) {
+    return __privateMethod(this, _setup, setup_fn).call(this, policyId, policyCapId, type);
+  }
+  /**
+   * Withdraw from the transfer policy's profits.
+   * @param address Address to transfer the profits to.
+   * @param amount (Optional) amount parameter. Will withdraw all profits if the amount is not specified.
+   */
+  withdraw(address, amount) {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    const coin = withdrawFromPolicy(
+      this.transactionBlock,
+      this.type,
+      this.policy,
+      this.policyCap,
+      amount
+    );
+    this.transactionBlock.transferObjects([coin], this.transactionBlock.pure(address, "address"));
+    return this;
+  }
+  /**
+   *  Adds the Kiosk Royalty rule to the Transfer Policy.
+   *  You can pass the percentage, as well as a minimum amount.
+   *  The royalty that will be paid is the MAX(percentage, minAmount).
+   * 	You can pass 0 in either value if you want only percentage royalty, or a fixed amount fee.
+   * 	(but you should define at least one of them for the rule to make sense).
+   *
+   * 	@param percentageBps The royalty percentage in basis points. Use `percentageToBasisPoints` helper to convert from percentage [0,100].
+   * 	@param minAmount The minimum royalty amount per request in MIST.
+   */
+  addRoyaltyRule(percentageBps, minAmount) {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    attachRoyaltyRuleTx(
+      this.transactionBlock,
+      this.type,
+      this.policy,
+      this.policyCap,
+      percentageBps,
+      minAmount,
+      this.kioskClient.getRulePackageId("royaltyRulePackageId")
+    );
+    return this;
+  }
+  /**
+   * Adds the Kiosk Lock Rule to the Transfer Policy.
+   * This Rule forces buyer to lock the item in the kiosk, preserving strong royalties.
+   */
+  addLockRule() {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    attachKioskLockRuleTx(
+      this.transactionBlock,
+      this.type,
+      this.policy,
+      this.policyCap,
+      this.kioskClient.getRulePackageId("kioskLockRulePackageId")
+    );
+    return this;
+  }
+  /**
+   * Attaches the Personal Kiosk Rule, making a purchase valid only for `SoulBound` kiosks.
+   */
+  addPersonalKioskRule() {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    attachPersonalKioskRuleTx(
+      this.transactionBlock,
+      this.type,
+      this.policy,
+      this.policyCap,
+      this.kioskClient.getRulePackageId("personalKioskRulePackageId")
+    );
+    return this;
+  }
+  /**
+   * A function to add the floor price rule to a transfer policy.
+   * @param minPrice The minimum price in MIST.
+   */
+  addFloorPriceRule(minPrice) {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    attachFloorPriceRuleTx(
+      this.transactionBlock,
+      this.type,
+      this.policy,
+      this.policyCap,
+      minPrice,
+      this.kioskClient.getRulePackageId("floorPriceRulePackageId")
+    );
+    return this;
+  }
+  /**
+   * Generic helper to remove a rule, not from the SDK's base ruleset.
+   * @param ruleType The Rule Type
+   * @param configType The Config Type
+   */
+  removeRule({ ruleType, configType }) {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    removeTransferPolicyRule(
+      this.transactionBlock,
+      this.type,
+      ruleType,
+      configType,
+      this.policy,
+      this.policyCap
+    );
+  }
+  /**
+   * Removes the lock rule.
+   */
+  removeLockRule() {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    const packageId = this.kioskClient.getRulePackageId("kioskLockRulePackageId");
+    removeTransferPolicyRule(
+      this.transactionBlock,
+      this.type,
+      `${packageId}::kiosk_lock_rule::Rule`,
+      `${packageId}::kiosk_lock_rule::Config`,
+      this.policy,
+      this.policyCap
+    );
+    return this;
+  }
+  /**
+   * Removes the Royalty rule
+   */
+  removeRoyaltyRule() {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    const packageId = this.kioskClient.getRulePackageId("royaltyRulePackageId");
+    removeTransferPolicyRule(
+      this.transactionBlock,
+      this.type,
+      `${packageId}::royalty_rule::Rule`,
+      `${packageId}::royalty_rule::Config`,
+      this.policy,
+      this.policyCap
+    );
+    return this;
+  }
+  removePersonalKioskRule() {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    const packageId = this.kioskClient.getRulePackageId("personalKioskRulePackageId");
+    removeTransferPolicyRule(
+      this.transactionBlock,
+      this.type,
+      `${packageId}::personal_kiosk_rule::Rule`,
+      `bool`,
+      this.policy,
+      this.policyCap
+    );
+    return this;
+  }
+  removeFloorPriceRule() {
+    __privateMethod(this, _validateInputs, validateInputs_fn).call(this);
+    const packageId = this.kioskClient.getRulePackageId("floorPriceRulePackageId");
+    removeTransferPolicyRule(
+      this.transactionBlock,
+      this.type,
+      `${packageId}::floor_price_rule::Rule`,
+      `${packageId}::floor_price_rule::Config`,
+      this.policy,
+      this.policyCap
+    );
+    return this;
+  }
+  getPolicy() {
+    if (!this.policy)
+      throw new Error("Policy not set.");
+    return this.policy;
+  }
+  getPolicyCap() {
+    if (!this.policyCap)
+      throw new Error("Transfer Policy Cap not set.");
+    return this.policyCap;
+  }
+};
+_validateInputs = new WeakSet();
+validateInputs_fn = function() {
+  const genericErrorMessage = `Please use 'setCap()' to setup the TransferPolicy.`;
+  if (!this.policy)
+    throw new Error(`${genericErrorMessage} Missing: Transfer Policy Object.`);
+  if (!this.policyCap)
+    throw new Error(`${genericErrorMessage} Missing: TransferPolicyCap Object ID`);
+  if (!this.type)
+    throw new Error(
+      `${genericErrorMessage} Missing: Transfer Policy object type (e.g. {packageId}::item::Item)`
+    );
+};
+_setup = new WeakSet();
+setup_fn = function(policyId, policyCap, type) {
+  this.policy = policyId;
+  this.policyCap = policyCap;
+  this.type = type;
+  return this;
+};
+
+// src/tx/personal-kiosk.ts
+function convertToPersonalTx(tx, kiosk, kioskOwnerCap, packageId) {
+  const personalKioskCap = tx.moveCall({
+    target: `${packageId}::personal_kiosk::new`,
+    arguments: [objArg(tx, kiosk), objArg(tx, kioskOwnerCap)]
+  });
+  return personalKioskCap;
+}
+function transferPersonalCapTx(tx, personalKioskCap, packageId) {
+  tx.moveCall({
+    target: `${packageId}::personal_kiosk::transfer_to_sender`,
+    arguments: [personalKioskCap]
+  });
+}
+
+// src/client/kiosk-transaction.ts
+var _pendingShare, _pendingTransfer, _promise, _personalCap, _finalized, _borrowFromPersonalCap, borrowFromPersonalCap_fn, _setPendingStatuses, setPendingStatuses_fn, _validateKioskIsSet, validateKioskIsSet_fn, _validateFinalizedStatus, validateFinalizedStatus_fn;
+var KioskTransaction = class {
+  constructor({ transactionBlock, kioskClient, cap }) {
+    /**
+     * A function to borrow from `personalCap`.
+     */
+    __privateAdd(this, _borrowFromPersonalCap);
+    __privateAdd(this, _setPendingStatuses);
+    __privateAdd(this, _validateKioskIsSet);
+    // Validates that `finalize`
+    __privateAdd(this, _validateFinalizedStatus);
+    // If we're pending `share` of a new kiosk, `finalize()` will share it.
+    __privateAdd(this, _pendingShare, void 0);
+    // If we're pending transferring of the cap, `finalize()` will either error or transfer the cap if it's a new personal.
+    __privateAdd(this, _pendingTransfer, void 0);
+    // The promise that the personalCap will be returned on `finalize()`.
+    __privateAdd(this, _promise, void 0);
+    // The personal kiosk argument.
+    __privateAdd(this, _personalCap, void 0);
+    // A flag that checks whether kiosk TX is finalized.
+    __privateAdd(this, _finalized, false);
+    this.transactionBlock = transactionBlock;
+    this.kioskClient = kioskClient;
+    if (cap)
+      this.setCap(cap);
+  }
+  /**
+   * Creates a kiosk and saves `kiosk` and `kioskOwnerCap` in state.
+   * Helpful if we want to chain some actions before sharing + transferring the cap to the specified address.
+   * @param borrow If true, the `kioskOwnerCap` is borrowed from the `PersonalKioskCap` to be used in next transactions.
+   */
+  create() {
+    __privateMethod(this, _validateFinalizedStatus, validateFinalizedStatus_fn).call(this);
+    __privateMethod(this, _setPendingStatuses, setPendingStatuses_fn).call(this, {
+      share: true,
+      transfer: true
+    });
+    const [kiosk, cap] = createKiosk(this.transactionBlock);
+    this.kiosk = kiosk;
+    this.kioskCap = cap;
+    return this;
+  }
+  /**
+   * Creates a personal kiosk & shares it.
+   * The `PersonalKioskCap` is transferred to the signer.
+   * @param borrow If true, the `kioskOwnerCap` is borrowed from the `PersonalKioskCap` to be used in next transactions.
+   */
+  createPersonal(borrow) {
+    __privateSet(this, _pendingShare, true);
+    return this.create().convertToPersonal(borrow);
+  }
+  /**
+   * Converts a kiosk to a Personal (Soulbound) Kiosk.
+   * Requires initialization by either calling `ktxb.create()` or `ktxb.setCap()`.
+   */
+  convertToPersonal(borrow) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    const cap = convertToPersonalTx(
+      this.transactionBlock,
+      this.kiosk,
+      this.kioskCap,
+      this.kioskClient.getRulePackageId("personalKioskRulePackageId")
+    );
+    if (borrow)
+      __privateMethod(this, _borrowFromPersonalCap, borrowFromPersonalCap_fn).call(this, cap);
+    else
+      __privateSet(this, _personalCap, cap);
+    __privateMethod(this, _setPendingStatuses, setPendingStatuses_fn).call(this, { transfer: true });
+    return this;
+  }
+  /**
+   * Single function way to create a kiosk, share it and transfer the cap to the specified address.
+   */
+  createAndShare(address) {
+    __privateMethod(this, _validateFinalizedStatus, validateFinalizedStatus_fn).call(this);
+    const cap = createKioskAndShare(this.transactionBlock);
+    this.transactionBlock.transferObjects([cap], this.transactionBlock.pure(address, "address"));
+  }
+  /**
+   * Shares the kiosk.
+   */
+  share() {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    __privateMethod(this, _setPendingStatuses, setPendingStatuses_fn).call(this, { share: false });
+    shareKiosk(this.transactionBlock, this.kiosk);
+  }
+  /**
+   * Should be called only after `create` is called.
+   * It shares the kiosk & transfers the cap to the specified address.
+   */
+  shareAndTransferCap(address) {
+    if (__privateGet(this, _personalCap))
+      throw new Error("You can only call `shareAndTransferCap` on a non-personal kiosk.");
+    __privateMethod(this, _setPendingStatuses, setPendingStatuses_fn).call(this, { transfer: false });
+    this.share();
+    this.transactionBlock.transferObjects(
+      [this.kioskCap],
+      this.transactionBlock.pure(address, "address")
+    );
+  }
+  /**
+   * A function to borrow an item from a kiosk & execute any function with it.
+   * Example: You could borrow a Fren out of a kiosk, attach an accessory (or mix), and return it.
+   */
+  borrowTx({ itemType, itemId }, callback) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    const [itemObj, promise] = borrowValue(
+      this.transactionBlock,
+      itemType,
+      this.kiosk,
+      this.kioskCap,
+      itemId
+    );
+    callback(itemObj);
+    this.return({ itemType, item: itemObj, promise });
+  }
+  /**
+   * Borrows an item from the kiosk.
+   * This will fail if the item is listed for sale.
+   *
+   * Requires calling `return`.
+   */
+  borrow({ itemType, itemId }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    const [itemObj, promise] = borrowValue(
+      this.transactionBlock,
+      itemType,
+      this.kiosk,
+      this.kioskCap,
+      itemId
+    );
+    return [itemObj, promise];
+  }
+  /**
+   * Returns the item back to the kiosk.
+   * Accepts the parameters returned from the `borrow` function.
+   */
+  return({ itemType, item, promise }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    returnValue(this.transactionBlock, itemType, this.kiosk, item, promise);
+    return this;
+  }
+  /**
+   * A function to withdraw from kiosk
+   * @param address Where to trasnfer the coin.
+   * @param amount The amount we aim to withdraw.
+   */
+  withdraw(address, amount) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    const coin = withdrawFromKiosk(
+      this.transactionBlock,
+      this.kiosk,
+      this.kioskCap,
+      amount
+    );
+    this.transactionBlock.transferObjects([coin], this.transactionBlock.pure(address, "address"));
+    return this;
+  }
+  /**
+   * A function to place an item in the kiosk.
+   * @param itemType The type `T` of the item
+   * @param item The ID or Transaction Argument of the item
+   */
+  place({ itemType, item }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    place(this.transactionBlock, itemType, this.kiosk, this.kioskCap, item);
+    return this;
+  }
+  /**
+   * A function to place an item in the kiosk and list it for sale in one transaction.
+   * @param itemType The type `T` of the item
+   * @param item The ID or Transaction Argument of the item
+   * @param price The price in MIST
+   */
+  placeAndList({ itemType, item, price }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    placeAndList(this.transactionBlock, itemType, this.kiosk, this.kioskCap, item, price);
+    return this;
+  }
+  /**
+   * A function to list an item in the kiosk.
+   * @param itemType The type `T` of the item
+   * @param itemId The ID of the item
+   * @param price The price in MIST
+   */
+  list({ itemType, itemId, price }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    list(this.transactionBlock, itemType, this.kiosk, this.kioskCap, itemId, price);
+    return this;
+  }
+  /**
+   * A function to delist an item from the kiosk.
+   * @param itemType The type `T` of the item
+   * @param itemId The ID of the item
+   */
+  delist({ itemType, itemId }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    delist(this.transactionBlock, itemType, this.kiosk, this.kioskCap, itemId);
+    return this;
+  }
+  /**
+  	 * A function to take an item from the kiosk. The transaction won't succeed if the item is listed or locked.
+  
+  	 * @param itemType The type `T` of the item
+  	 * @param itemId The ID of the item
+  	 */
+  take({ itemType, itemId }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    return take(this.transactionBlock, itemType, this.kiosk, this.kioskCap, itemId);
+  }
+  /**
+   * Transfer a non-locked/non-listed item to an address.
+   *
+   * @param itemType The type `T` of the item
+   * @param itemId The ID of the item
+   * @param address The destination address
+   */
+  transfer({ itemType, itemId, address }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    const item = this.take({ itemType, itemId });
+    this.transactionBlock.transferObjects([item], this.transactionBlock.pure(address, "address"));
+    return this;
+  }
+  /**
+  	 * A function to take lock an item in the kiosk.
+  
+  	 * @param itemType The type `T` of the item
+  	 * @param itemId The ID of the item
+  	 * @param policy The Policy ID or Transaction Argument for item T
+  	 */
+  lock({ itemType, itemId, policy }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    lock(this.transactionBlock, itemType, this.kiosk, this.kioskCap, policy, itemId);
+    return this;
+  }
+  /**
+   * Purchase an item from a seller's kiosk.
+   * Returns [item, transferRequest]
+   * Can be called like: `const [item, transferRequest] = kioskTx.purchase({...})`
+   * @param itemType The type `T` of the item
+   * @param itemId The ID of the item
+   * @param price The price in MIST
+   * @param sellerKiosk The kiosk which is selling the item. Can be an id or an object argument.
+   */
+  purchase({
+    itemType,
+    itemId,
+    price,
+    sellerKiosk
+  }) {
+    const coin = this.transactionBlock.splitCoins(this.transactionBlock.gas, [
+      this.transactionBlock.pure(price, "u64")
+    ]);
+    return purchase(this.transactionBlock, itemType, sellerKiosk, itemId, coin);
+  }
+  /**
+   * A function to purchase and resolve a transfer policy.
+   * If the transfer policy has the `lock` rule, the item is locked in the kiosk.
+   * Otherwise, the item is placed in the kiosk.
+   * @param itemType The type of the item
+   * @param itemId The id of the item
+   * @param price The price of the specified item
+   * @param sellerKiosk The kiosk which is selling the item. Can be an id or an object argument.
+   * @param extraArgs Used to pass arguments for custom rule resolvers.
+   */
+  async purchaseAndResolve({
+    itemType,
+    itemId,
+    price,
+    sellerKiosk,
+    extraArgs
+  }) {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    const policies = await this.kioskClient.getTransferPolicies({ type: itemType });
+    if (policies.length === 0) {
+      throw new Error(
+        `The type ${itemType} doesn't have a Transfer Policy so it can't be traded through kiosk.`
+      );
+    }
+    const policy = policies[0];
+    const [purchasedItem, transferRequest] = this.purchase({
+      itemType,
+      itemId,
+      price,
+      sellerKiosk
+    });
+    let canTransferOutsideKiosk = true;
+    for (const rule of policy.rules) {
+      const ruleDefinition = this.kioskClient.rules.find(
+        (x) => getNormalizedRuleType(x.rule) === getNormalizedRuleType(rule)
+      );
+      if (!ruleDefinition)
+        throw new Error(`No resolver for the following rule: ${rule}.`);
+      if (ruleDefinition.hasLockingRule)
+        canTransferOutsideKiosk = false;
+      ruleDefinition.resolveRuleFunction({
+        packageId: ruleDefinition.packageId,
+        transactionBlock: this.transactionBlock,
+        itemType,
+        itemId,
+        price: price.toString(),
+        sellerKiosk,
+        policyId: policy.id,
+        transferRequest,
+        purchasedItem,
+        kiosk: this.kiosk,
+        kioskCap: this.kioskCap,
+        extraArgs: extraArgs || {}
+      });
+    }
+    confirmRequest(this.transactionBlock, itemType, policy.id, transferRequest);
+    if (canTransferOutsideKiosk)
+      this.place({ itemType, item: purchasedItem });
+    return this;
+  }
+  /**
+   * A function to setup the client using an existing `ownerCap`,
+   * as return from the `kioskClient.getOwnedKiosks` function.
+   * @param cap `KioskOwnerCap` object as returned from `getOwnedKiosks` SDK call.
+   */
+  setCap(cap) {
+    __privateMethod(this, _validateFinalizedStatus, validateFinalizedStatus_fn).call(this);
+    this.kiosk = objArg(this.transactionBlock, cap.kioskId);
+    if (!cap.isPersonal) {
+      this.kioskCap = objArg(this.transactionBlock, cap.objectId);
+      return;
+    }
+    return __privateMethod(this, _borrowFromPersonalCap, borrowFromPersonalCap_fn).call(this, cap.objectId);
+  }
+  /**
+   *	A function that ends up the kiosk building txb & returns the `kioskOwnerCap` back to the
+   *  `PersonalKioskCap`, in case we are operating on a personal kiosk.
+   * 	It will also share the `kiosk` if it's not shared, and finalize the transfer of the personal cap if it's pending.
+   */
+  finalize() {
+    __privateMethod(this, _validateKioskIsSet, validateKioskIsSet_fn).call(this);
+    if (__privateGet(this, _pendingShare))
+      this.share();
+    if (!__privateGet(this, _personalCap)) {
+      if (__privateGet(this, _pendingTransfer))
+        throw new Error(
+          "You need to transfer the `kioskOwnerCap` by calling `shareAndTransferCap()` before wrap"
+        );
+      return;
+    }
+    const packageId = this.kioskClient.getRulePackageId("personalKioskRulePackageId");
+    if (__privateGet(this, _promise)) {
+      this.transactionBlock.moveCall({
+        target: `${packageId}::personal_kiosk::return_val`,
+        arguments: [
+          __privateGet(this, _personalCap),
+          objArg(this.transactionBlock, this.kioskCap),
+          __privateGet(this, _promise)
+        ]
+      });
+    }
+    if (__privateGet(this, _pendingTransfer))
+      transferPersonalCapTx(this.transactionBlock, __privateGet(this, _personalCap), packageId);
+    __privateSet(this, _finalized, true);
+  }
+  // Some setters in case we want custom behavior.
+  setKioskCap(cap) {
+    __privateMethod(this, _validateFinalizedStatus, validateFinalizedStatus_fn).call(this);
+    this.kioskCap = cap;
+    return this;
+  }
+  setKiosk(kiosk) {
+    __privateMethod(this, _validateFinalizedStatus, validateFinalizedStatus_fn).call(this);
+    this.kiosk = kiosk;
+    return this;
+  }
+  // Some getters
+  /*
+   * Returns the active transaction's kiosk, or undefined if `setCap` or `create()` hasn't been called yet.
+   */
+  getKiosk() {
+    __privateMethod(this, _validateFinalizedStatus, validateFinalizedStatus_fn).call(this);
+    if (!this.kiosk)
+      throw new Error("Kiosk is not set.");
+    return this.kiosk;
+  }
+  /*
+   * Returns the active transaction's kioskOwnerCap, or undefined if `setCap` or `create()` hasn't been called yet.
+   */
+  getKioskCap() {
+    __privateMethod(this, _validateFinalizedStatus, validateFinalizedStatus_fn).call(this);
+    if (!this.kioskCap)
+      throw new Error("Kiosk cap is not set");
+    return this.kioskCap;
+  }
+};
+_pendingShare = new WeakMap();
+_pendingTransfer = new WeakMap();
+_promise = new WeakMap();
+_personalCap = new WeakMap();
+_finalized = new WeakMap();
+_borrowFromPersonalCap = new WeakSet();
+borrowFromPersonalCap_fn = function(personalCap) {
+  const [kioskCap, promise] = this.transactionBlock.moveCall({
+    target: `${this.kioskClient.getRulePackageId(
+      "personalKioskRulePackageId"
+    )}::personal_kiosk::borrow_val`,
+    arguments: [objArg(this.transactionBlock, personalCap)]
+  });
+  this.kioskCap = kioskCap;
+  __privateSet(this, _personalCap, objArg(this.transactionBlock, personalCap));
+  __privateSet(this, _promise, promise);
+  return this;
+};
+_setPendingStatuses = new WeakSet();
+setPendingStatuses_fn = function({ share, transfer }) {
+  if (transfer !== void 0)
+    __privateSet(this, _pendingTransfer, transfer);
+  if (share !== void 0)
+    __privateSet(this, _pendingShare, share);
+};
+_validateKioskIsSet = new WeakSet();
+validateKioskIsSet_fn = function() {
+  __privateMethod(this, _validateFinalizedStatus, validateFinalizedStatus_fn).call(this);
+  if (!this.kiosk || !this.kioskCap)
+    throw new Error(
+      "You need to initialize the client by either supplying an existing owner cap or by creating a new by calling `.create()`"
+    );
+};
+_validateFinalizedStatus = new WeakSet();
+validateFinalizedStatus_fn = function() {
+  if (__privateGet(this, _finalized))
+    throw new Error("You can't add more transactions to a finalized kiosk transaction block.");
+};
 export {
+  FLOOR_PRICE_RULE_ADDRESS,
   KIOSK_ITEM,
   KIOSK_LISTING,
   KIOSK_LOCK,
   KIOSK_LOCK_RULE,
+  KIOSK_LOCK_RULE_ADDRESS,
   KIOSK_MODULE,
   KIOSK_OWNER_CAP,
   KIOSK_PURCHASE_CAP,
   KIOSK_TYPE,
-  MAINNET_RULES_PACKAGE_ADDRESS,
+  KioskClient,
+  KioskTransaction,
+  Network,
+  PERSONAL_KIOSK_RULE_ADDRESS,
   ROYALTY_RULE,
-  TESTNET_RULES_PACKAGE_ADDRESS,
+  ROYALTY_RULE_ADDRESS,
+  TRANSFER_POLICY_CAP_TYPE,
   TRANSFER_POLICY_CREATED_EVENT,
   TRANSFER_POLICY_MODULE,
   TRANSFER_POLICY_TYPE,
-  attachKioskLockRule,
+  TransferPolicyTransaction,
   attachListingsAndPrices,
   attachLockedItems,
-  attachRoyaltyRule,
-  bcs,
-  borrow,
-  borrowMut,
-  borrowValue,
-  confirmRequest,
-  createKiosk,
-  createKioskAndShare,
-  createTransferPolicy,
-  customEnvironment,
-  delist,
+  attachObjects,
   extractKioskData,
-  fetchKiosk,
   getAllDynamicFields,
+  getAllObjects,
+  getAllOwnedObjects,
+  getBaseRules,
   getKioskObject,
-  getOwnedKiosks,
-  getRulePackageAddress,
+  getNormalizedRuleType,
   getTypeWithoutPackageAddress,
-  list,
-  lock,
-  mainnetEnvironment,
+  mainnetRules,
   objArg,
+  parseTransferPolicyCapObject,
   percentageToBasisPoints,
-  place,
-  placeAndList,
-  purchase,
-  purchaseAndResolvePolicies,
-  queryTransferPolicy,
-  removeTransferPolicyRule,
-  resolveKioskLockRule,
-  resolveRoyaltyRule,
-  returnValue,
-  rulesPackageAddresses,
-  take,
-  testnetEnvironment,
-  withdrawFromKiosk,
-  withdrawFromPolicy
+  rules,
+  testnetRules
 };
 //# sourceMappingURL=index.mjs.map