@medialane/sdk 0.198.0 → 0.199.0

package/dist/starknet/index.cjs

@@ -1,45 +1,45 @@
 'use strict';
 
-var chunk2R7XBA34_cjs = require('../chunk-2R7XBA34.cjs');
-var chunk7EYJC5CB_cjs = require('../chunk-7EYJC5CB.cjs');
+var chunkMEJ47LC3_cjs = require('../chunk-MEJ47LC3.cjs');
+var chunkZLMIHQWM_cjs = require('../chunk-ZLMIHQWM.cjs');
+var chunk3HPMEDYH_cjs = require('../chunk-3HPMEDYH.cjs');
+var chunkH2NJB3AK_cjs = require('../chunk-H2NJB3AK.cjs');
+require('../chunk-W76AZ5WC.cjs');
 require('../chunk-Q7SFCCGT.cjs');
 var starknet = require('starknet');
-var hkdf_js = require('@noble/hashes/hkdf.js');
-var sha2_js = require('@noble/hashes/sha2.js');
 
-// src/starknet/marketplace/errors.ts
-var MedialaneError = class extends Error {
-  constructor(message, code = "UNKNOWN", cause) {
-    super(message);
-    this.code = code;
-    this.cause = cause;
-    this.name = "MedialaneError";
-  }
-};
-
-// src/starknet/marketplace/utils.ts
-var START_TIME_BUFFER_SECS = 30;
-function newContract(abi, address, providerOrAccount) {
-  const C = starknet.Contract;
-  return C.length === 1 ? new starknet.Contract({ abi, address, providerOrAccount }) : new starknet.Contract(
-    abi,
-    address,
-    providerOrAccount
-  );
+function createChainProvider(backendUrl, apiKey) {
+  return new starknet.RpcProvider({
+    nodeUrl: `${backendUrl.replace(/\/$/, "")}/v1/rpc`,
+    headers: apiKey ? { "x-api-key": apiKey } : {},
+    blockIdentifier: "latest"
+  });
 }
-function getChainId(config) {
-  if (config.chain !== "STARKNET") {
-    throw new Error(`SNIP-12 signing is Starknet-only; got chain "${config.chain}"`);
+
+// src/starknet/client.ts
+var NO_BACKEND = "backendUrl not configured. Pass backendUrl to MedialaneClient to use";
+var MedialaneClient = class {
+  constructor(rawConfig = {}) {
+    this.config = chunkMEJ47LC3_cjs.resolveConfig(rawConfig);
+    const config = this.config;
+    this.api = config.backendUrl ? new chunk3HPMEDYH_cjs.ApiClient({ baseUrl: config.backendUrl, apiKey: config.apiKey, retry: config.retryOptions, chain: config.chain }) : new chunk3HPMEDYH_cjs.ApiClient({
+      baseUrl: "https://medialane-sdk-no-backend.invalid",
+      apiKey: config.apiKey,
+      fetch: () => {
+        throw new Error(`${NO_BACKEND} .api`);
+      }
+    });
   }
-  return starknet.constants.StarknetChainId.SN_MAIN;
-}
-function resolveToken(currency) {
-  const token = chunk2R7XBA34_cjs.SUPPORTED_TOKENS.find(
-    (t) => t.symbol === currency.toUpperCase() || t.address.toLowerCase() === currency.toLowerCase()
-  );
-  if (!token) throw new MedialaneError(`Unsupported currency: ${currency}`, "INVALID_PARAMS");
-  return token;
-}
+  get chain() {
+    return this.config.chain;
+  }
+  get provider() {
+    if (!this.config.backendUrl) {
+      throw new Error(`${NO_BACKEND} .provider`);
+    }
+    return this._provider ?? (this._provider = createChainProvider(this.config.backendUrl, this.config.apiKey));
+  }
+};
 
 // src/starknet/abis/ipMarketplace.ts
 var IPMarketplaceABI = [
@@ -10377,148 +10377,121 @@ var IPGenesisABI = [
     ]
   }
 ];
-var FRAGMENT_KEY = "pop-proof";
-var toHex = (x) => "0x" + x.toString(16).padStart(64, "0");
-var poseidon = (xs) => BigInt(starknet.hash.computePoseidonHashOnElements(xs.map((x) => "0x" + x.toString(16))));
-var nodeHash = (a, b) => a < b ? poseidon([a, b]) : poseidon([b, a]);
-function popLeafHash(address) {
-  return poseidon([poseidon([BigInt(address)])]);
+var START_TIME_BUFFER_SECS = 30;
+function newContract(abi, address, providerOrAccount) {
+  const C = starknet.Contract;
+  return C.length === 1 ? new starknet.Contract({ abi, address, providerOrAccount }) : new starknet.Contract(
+    abi,
+    address,
+    providerOrAccount
+  );
 }
-function merkleTree(leafHashes) {
-  const leaves = [...leafHashes].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  const tree = new Array(2 * leaves.length - 1);
-  leaves.forEach((leaf, i) => tree[tree.length - 1 - i] = leaf);
-  for (let i = tree.length - 1 - leaves.length; i >= 0; i--) {
-    tree[i] = nodeHash(tree[2 * i + 1], tree[2 * i + 2]);
+function getChainId(config) {
+  if (config.chain !== "STARKNET") {
+    throw new Error(`SNIP-12 signing is Starknet-only; got chain "${config.chain}"`);
   }
-  return {
-    root: tree[0],
-    proof(leaf) {
-      let i = tree.lastIndexOf(leaf);
-      if (i < tree.length - leaves.length) throw new Error("Not a leaf of this tree");
-      const proof = [];
-      while (i > 0) {
-        proof.push(tree[i % 2 === 1 ? i + 1 : i - 1]);
-        i = Math.floor((i - 1) / 2);
-      }
-      return proof;
-    }
-  };
-}
-function buildPopAllowlist(addresses) {
-  const unique = [...new Set(addresses.map((a) => chunk2R7XBA34_cjs.normalizeAddress("STARKNET", a)))];
-  if (unique.length === 0) throw new Error("An allowlist needs at least one address");
-  const leaves = unique.map((address) => ({ address, leaf: popLeafHash(address) }));
-  const tree = merkleTree(leaves.map((l) => l.leaf));
-  const proofs = {};
-  for (const { address, leaf } of leaves) proofs[address] = tree.proof(leaf).map(toHex);
-  return { root: toHex(tree.root), proofs };
-}
-function verifyPopProof(root, address, proof) {
-  let computed = popLeafHash(address);
-  for (const sibling of proof) computed = nodeHash(computed, BigInt(sibling));
-  return computed === BigInt(root);
-}
-function encodePopClaimFragment(proof) {
-  return `#${FRAGMENT_KEY}=${proof.join(",")}`;
+  return starknet.constants.StarknetChainId.SN_MAIN;
 }
-function decodePopClaimFragment(fragment) {
-  const raw = new URLSearchParams(fragment.replace(/^#/, "")).get(FRAGMENT_KEY);
-  if (raw === null) return null;
-  if (raw === "") return [];
-  const parts = raw.split(",");
-  return parts.every((p) => /^0x[0-9a-fA-F]{1,64}$/.test(p)) ? parts : null;
+function resolveToken(currency) {
+  const token = chunk3HPMEDYH_cjs.SUPPORTED_TOKENS.find(
+    (t) => t.symbol === currency.toUpperCase() || t.address.toLowerCase() === currency.toLowerCase()
+  );
+  if (!token) throw new chunk3HPMEDYH_cjs.MedialaneError(`Unsupported currency: ${currency}`, "INVALID_PARAMS");
+  return token;
 }
-
-// src/starknet/pop-claim.ts
-function popClaimLinks(origin, collection, list) {
-  const base = `${origin}${chunk2R7XBA34_cjs.collectionHref("STARKNET", collection)}`;
-  return Object.entries(list.proofs).map(([address, proof]) => ({
-    address,
-    url: `${base}${encodePopClaimFragment(proof)}`
-  }));
+var STARKNET_DOMAIN = [
+  { name: "name", type: "shortstring" },
+  { name: "version", type: "shortstring" },
+  { name: "chainId", type: "shortstring" },
+  { name: "revision", type: "shortstring" }
+];
+var OFFER_ITEM = [
+  { name: "item_type", type: "shortstring" },
+  { name: "token", type: "ContractAddress" },
+  { name: "identifier_or_criteria", type: "felt" },
+  { name: "amount", type: "felt" }
+];
+var CONSIDERATION_ITEM = [
+  { name: "item_type", type: "shortstring" },
+  { name: "token", type: "ContractAddress" },
+  { name: "identifier_or_criteria", type: "felt" },
+  { name: "amount", type: "felt" },
+  { name: "recipient", type: "ContractAddress" }
+];
+var ORDER_PARAMETERS = [
+  { name: "offerer", type: "ContractAddress" },
+  { name: "marketplace", type: "ContractAddress" },
+  { name: "offer", type: "OfferItem" },
+  { name: "consideration", type: "ConsiderationItem" },
+  { name: "royalty_max_bps", type: "felt" },
+  { name: "start_time", type: "felt" },
+  { name: "end_time", type: "felt" },
+  { name: "salt", type: "felt" },
+  { name: "counter", type: "felt" }
+];
+var ORDER_CANCELLATION = [
+  { name: "order_hash", type: "felt" },
+  { name: "offerer", type: "ContractAddress" }
+];
+var DOMAIN_VERSION = {
+  erc721: "5",
+  erc1155: "4"
+};
+function buildDomain(standard, chainId) {
+  return {
+    name: "Medialane",
+    version: DOMAIN_VERSION[standard],
+    chainId,
+    revision: starknet.TypedDataRevision.ACTIVE
+  };
 }
-function popClaimLinksCsv(links) {
-  return ["address,claim_link", ...links.map((l) => `${l.address},${l.url}`)].join("\n");
+function buildOrderTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc721", chainId),
+    primaryType: "OrderParameters",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderParameters: ORDER_PARAMETERS,
+      OfferItem: OFFER_ITEM,
+      ConsiderationItem: CONSIDERATION_ITEM
+    },
+    message
+  };
 }
-async function popClaimInfo(provider, collection) {
-  const contractAddress = chunk2R7XBA34_cjs.normalizeAddress("STARKNET", collection);
-  const [root, end] = await Promise.all([
-    provider.callContract({ contractAddress, entrypoint: "allowlist_root", calldata: [] }),
-    provider.callContract({ contractAddress, entrypoint: "claim_end_time", calldata: [] })
-  ]);
-  return { root: root[0] ?? "0x0", claimEndTime: Number(BigInt(end[0] ?? "0x0")) };
+function build1155OrderTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc1155", chainId),
+    primaryType: "OrderParameters",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderParameters: ORDER_PARAMETERS,
+      OfferItem: OFFER_ITEM,
+      ConsiderationItem: CONSIDERATION_ITEM
+    },
+    message
+  };
 }
-function popClaimState(input) {
-  const { hasClaimed, proof, wallet, info } = input;
-  if (hasClaimed === true) return "claimed";
-  if (hasClaimed === null || info === null) return "loading";
-  if (BigInt(info.root) === 0n) return "closed";
-  if (info.claimEndTime !== 0 && info.now > info.claimEndTime) return "ended";
-  if (proof === null) return "no-link";
-  if (!wallet || !verifyPopProof(info.root, wallet, proof)) return "wrong-wallet";
-  return "ready";
+function buildCancellationTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc721", chainId),
+    primaryType: "OrderCancellation",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderCancellation: ORDER_CANCELLATION
+    },
+    message
+  };
 }
-var addr = (a) => chunk2R7XBA34_cjs.normalizeAddress("STARKNET", a);
-var byteArrayFelts = (s) => starknet.CallData.compile([starknet.byteArray.byteArrayFromString(s)]);
-var popCalls = {
-  claim(collection, proof) {
-    return { contractAddress: addr(collection), entrypoint: "claim", calldata: [String(proof.length), ...proof] };
-  },
-  /** An empty `tokenUri` uses the collection's URI. */
-  issue(collection, recipient, tokenUri = "") {
-    return { contractAddress: addr(collection), entrypoint: "issue", calldata: [addr(recipient), ...byteArrayFelts(tokenUri)] };
-  },
-  /** Only the token's holder can burn it. */
-  burn(collection, tokenId) {
-    const id = starknet.cairo.uint256(BigInt(tokenId));
-    return { contractAddress: addr(collection), entrypoint: "burn", calldata: [String(id.low), String(id.high)] };
-  },
-  setAllowlistRoot(collection, root) {
-    return { contractAddress: addr(collection), entrypoint: "set_allowlist_root", calldata: [root] };
-  }
-};
-
-// src/starknet/services/pop.ts
-var PopService = class {
-  constructor(config) {
-    this.factoryAddress = chunk7EYJC5CB_cjs.getStarknetCoordinates(config.chain).popFactory;
-  }
-  async createCollection(account, params) {
-    const factory = newContract(POPFactoryABI, this.factoryAddress, account);
-    const call = factory.populate("create_collection", [params.name, params.symbol, params.baseUri, params.claimEndTime]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async setAllowlistRoot(account, params) {
-    const call = popCalls.setAllowlistRoot(params.collection, params.root);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async claim(account, params) {
-    const call = popCalls.claim(params.collection, params.proof);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async issue(account, params) {
-    const call = popCalls.issue(params.collection, params.recipient, params.tokenUri);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  /** Destroys the caller's own credential; the address cannot receive another from this collection. */
-  async burn(account, params) {
-    const call = popCalls.burn(params.collection, params.tokenId);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-async function popHasClaimed(provider, collection, address) {
-  const res = await provider.callContract({
-    contractAddress: chunk2R7XBA34_cjs.normalizeAddress("STARKNET", collection),
-    entrypoint: "has_claimed",
-    calldata: [chunk2R7XBA34_cjs.normalizeAddress("STARKNET", address)]
-  });
-  return BigInt(res[0] ?? "0x0") !== 0n;
+function build1155CancellationTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc1155", chainId),
+    primaryType: "OrderCancellation",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderCancellation: ORDER_CANCELLATION
+    },
+    message
+  };
 }
 function feeBps(surface, cfg) {
   if (!cfg.enabled || !cfg.fundAddress) return 0;
@@ -10537,815 +10510,15 @@ function buildFeeCall(p, cfg) {
     calldata: [cfg.fundAddress, u.low.toString(), u.high.toString()]
   };
 }
-var DROP_MAX_CLAIM_QUANTITY = 50n;
-var addr2 = (a) => chunk2R7XBA34_cjs.normalizeAddress("STARKNET", a);
-var factoryData = new starknet.CallData(DropFactoryABI);
-var collectionData = new starknet.CallData(DropCollectionABI);
-function toContractTerms(t) {
-  const price = BigInt(t.price);
-  return {
-    start_time: t.startTime,
-    end_time: t.endTime,
-    price: starknet.cairo.uint256(price),
-    payment_token: price === 0n ? "0x0" : addr2(t.paymentToken),
-    max_per_wallet: starknet.cairo.uint256(BigInt(t.maxPerWallet))
-  };
-}
-var dropCalls = {
-  create(factory, p) {
-    return {
-      contractAddress: addr2(factory),
-      entrypoint: "create_drop",
-      calldata: factoryData.compile("create_drop", {
-        name: p.name,
-        symbol: p.symbol,
-        base_uri: p.baseUri,
-        max_supply: starknet.cairo.uint256(BigInt(p.maxSupply)),
-        terms: toContractTerms(p.terms),
-        allowlist_root: p.allowlistRoot ?? "0x0"
-      })
-    };
-  },
-  /** Approve (paid drops) and claim. The platform fee call is added by the caller. */
-  claim(collection, p) {
-    const quantity = BigInt(p.quantity);
-    if (quantity < 1n || quantity > DROP_MAX_CLAIM_QUANTITY) throw new RangeError(`quantity must be 1 to ${DROP_MAX_CLAIM_QUANTITY}`);
-    const total = BigInt(p.price) * quantity;
-    const calls = [];
-    if (total > 0n) {
-      calls.push({
-        contractAddress: addr2(p.paymentToken),
-        entrypoint: "approve",
-        calldata: starknet.CallData.compile([addr2(collection), starknet.cairo.uint256(total)])
-      });
-    }
-    calls.push({
-      contractAddress: addr2(collection),
-      entrypoint: "claim",
-      calldata: collectionData.compile("claim", { quantity: starknet.cairo.uint256(quantity), proof: p.proof ?? [] })
-    });
-    return calls;
-  },
-  /** Organizer only: free mint within the supply cap. */
-  issue(collection, recipient, quantity) {
-    const q = BigInt(quantity);
-    if (q < 1n) throw new RangeError("quantity must be at least 1");
-    return {
-      contractAddress: addr2(collection),
-      entrypoint: "issue",
-      calldata: collectionData.compile("issue", { recipient: addr2(recipient), quantity: starknet.cairo.uint256(q) })
-    };
-  },
-  /** Organizer only. 0 opens the drop to everyone. */
-  setAllowlistRoot(collection, root) {
-    return { contractAddress: addr2(collection), entrypoint: "set_allowlist_root", calldata: collectionData.compile("set_allowlist_root", { root }) };
-  }
-};
-function dropMintCost(price, quantity, feeBps2) {
-  const subtotal = BigInt(price) * BigInt(quantity);
-  const fee = feeAmount(subtotal, feeBps2);
-  return { subtotal, fee, total: subtotal + fee };
-}
-
-// src/starknet/drop-state.ts
-var hex = (v) => chunk2R7XBA34_cjs.normalizeAddress("STARKNET", v ?? "0x0");
-var u256 = (low, high) => BigInt(low ?? "0x0") + (BigInt(high ?? "0x0") << 128n);
-async function readDrop(provider, collection) {
-  const contractAddress = hex(collection);
-  const read = (entrypoint) => provider.callContract({ contractAddress, entrypoint, calldata: [] });
-  const [organizer, terms, root, max, minted] = await Promise.all([
-    read("organizer"),
-    read("terms"),
-    read("allowlist_root"),
-    read("max_supply"),
-    read("total_minted")
-  ]);
-  return {
-    organizer: hex(organizer[0]),
-    startTime: Number(BigInt(terms[0] ?? "0x0")),
-    endTime: Number(BigInt(terms[1] ?? "0x0")),
-    price: u256(terms[2], terms[3]),
-    paymentToken: hex(terms[4]),
-    maxPerWallet: u256(terms[5], terms[6]),
-    allowlistRoot: root[0] ?? "0x0",
-    maxSupply: u256(max[0], max[1]),
-    totalMinted: u256(minted[0], minted[1])
-  };
-}
-async function dropClaimedBy(provider, collection, wallet) {
-  const res = await provider.callContract({ contractAddress: hex(collection), entrypoint: "claimed_by", calldata: [hex(wallet)] });
-  return u256(res[0], res[1]);
-}
-function dropMintState(input) {
-  const none = (state) => ({ state, maxQuantity: 0n });
-  const { drop, wallet, claimed, proof, balance, now } = input;
-  if (!drop) return none("loading");
-  if (drop.startTime !== 0 && now < drop.startTime) return none("upcoming");
-  if (drop.endTime !== 0 && now > drop.endTime) return none("ended");
-  const supplyLeft = drop.maxSupply === 0n ? null : drop.maxSupply - drop.totalMinted;
-  if (supplyLeft !== null && supplyLeft <= 0n) return none("sold-out");
-  if (!wallet) return none("no-wallet");
-  if (BigInt(drop.allowlistRoot) !== 0n) {
-    if (proof === null) return none("no-link");
-    if (!verifyPopProof(drop.allowlistRoot, wallet, proof)) return none("not-on-list");
-  }
-  if (claimed === null) return none("loading");
-  const walletLeft = drop.maxPerWallet === 0n ? null : drop.maxPerWallet - claimed;
-  if (walletLeft !== null && walletLeft <= 0n) return none("limit-reached");
-  let max = DROP_MAX_CLAIM_QUANTITY;
-  if (supplyLeft !== null && supplyLeft < max) max = supplyLeft;
-  if (walletLeft !== null && walletLeft < max) max = walletLeft;
-  if (drop.price > 0n) {
-    if (balance === null) return none("loading");
-    while (max > 0n && dropMintCost(drop.price, max, input.feeBps).total > balance) max--;
-    if (max === 0n) return none("insufficient-balance");
-  }
-  return { state: "ready", maxQuantity: max };
-}
-function dropClaimLinks(origin, collection, list) {
-  const base = `${origin}${chunk2R7XBA34_cjs.dropHref(collection)}`;
-  return Object.entries(list.proofs).map(([address, proof]) => ({
-    address,
-    url: `${base}${encodePopClaimFragment(proof)}`
-  }));
-}
-
-// src/starknet/services/drop.ts
-var DropService = class {
-  constructor(config) {
-    this.factoryAddress = chunk7EYJC5CB_cjs.getStarknetCoordinates(config.chain).dropFactory;
-    this.config = config;
-  }
-  async createDrop(account, params) {
-    const res = await account.execute([dropCalls.create(this.factoryAddress, params)]);
-    return { txHash: res.transaction_hash };
-  }
-  /** Mints `quantity` to the account, paying the drop's price and the platform fee. */
-  async claim(account, params) {
-    const drop = await readDrop(account.provider, params.collection);
-    const calls = dropCalls.claim(params.collection, {
-      quantity: params.quantity,
-      proof: params.proof,
-      price: drop.price,
-      paymentToken: drop.paymentToken
-    });
-    const fee = drop.price > 0n ? buildFeeCall(
-      { surface: "launchpad", token: drop.paymentToken, grossAmount: drop.price * BigInt(params.quantity) },
-      this.config.feeConfig
-    ) : null;
-    const res = await account.execute(fee ? [...calls, fee] : calls);
-    return { txHash: res.transaction_hash };
-  }
-  async issue(account, params) {
-    const res = await account.execute([dropCalls.issue(params.collection, params.recipient, params.quantity)]);
-    return { txHash: res.transaction_hash };
-  }
-  async setAllowlistRoot(account, params) {
-    const res = await account.execute([dropCalls.setAllowlistRoot(params.collection, params.root)]);
-    return { txHash: res.transaction_hash };
-  }
-};
-
-// src/starknet/services/erc1155collection.ts
-var ERC1155CollectionService = class {
-  constructor(config) {
-    this.factoryAddress = config.collection1155Contract ?? chunk7EYJC5CB_cjs.getStarknetCoordinates(config.chain).collection1155;
-  }
-  _factory(account) {
-    return newContract(
-      IPCollection1155FactoryABI,
-      chunk2R7XBA34_cjs.normalizeAddress("STARKNET", this.factoryAddress),
-      account
-    );
-  }
-  _collection(address, account) {
-    return newContract(
-      IPCollection1155ABI,
-      chunk2R7XBA34_cjs.normalizeAddress("STARKNET", address),
-      account
-    );
-  }
-  async deployCollection(account, params) {
-    const factory = this._factory(account);
-    const call = factory.populate("deploy_collection", [params.name, params.symbol, params.baseUri]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async mintEdition(account, params) {
-    const collection = this._collection(params.collection, account);
-    const call = collection.populate("mint_edition", [
-      params.to,
-      BigInt(params.value),
-      params.tokenUri
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async batchMintEdition(account, params) {
-    const collection = this._collection(params.collection, account);
-    const values = params.items.map((i) => BigInt(i.value));
-    const tokenUris = params.items.map((i) => i.tokenUri);
-    const call = collection.populate("batch_mint_edition", [
-      params.to,
-      values,
-      tokenUris
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async addSupply(account, params) {
-    const collection = this._collection(params.collection, account);
-    const call = collection.populate("add_supply", [
-      params.to,
-      BigInt(params.tokenId),
-      BigInt(params.value)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async setDefaultRoyalty(account, params) {
-    const collection = this._collection(params.collection, account);
-    const call = collection.populate("set_default_royalty", [
-      params.receiver,
-      BigInt(params.feeNumerator)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async setTokenRoyalty(account, params) {
-    const collection = this._collection(params.collection, account);
-    const call = collection.populate("set_token_royalty", [
-      BigInt(params.tokenId),
-      params.receiver,
-      BigInt(params.feeNumerator)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async setApprovalForAll(account, params) {
-    const collection = this._collection(params.collection, account);
-    const call = collection.populate("set_approval_for_all", [
-      params.operator,
-      params.approved
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-
-// src/starknet/services/coinLaunchMath.ts
-var COIN_DECIMALS = 18;
-var SUGGESTED_DEFAULT_PRICE = 0.01;
-var MIN_SUPPLY = 1000n;
-var MAX_SUPPLY = 1000000000000n;
-var MAX_FELT_BYTES = 31;
-function byteLen(s) {
-  return new TextEncoder().encode(s).length;
-}
-function validateName(s) {
-  if (!s.trim()) return "Name is required";
-  if (byteLen(s) > MAX_FELT_BYTES) return `Name must be at most ${MAX_FELT_BYTES} bytes`;
-  return null;
-}
-function validateSymbol(s) {
-  if (!s.trim()) return "Symbol is required";
-  if (byteLen(s) > MAX_FELT_BYTES) return `Symbol must be at most ${MAX_FELT_BYTES} bytes`;
-  return null;
-}
-function validateSupply(human) {
-  if (!/^\d+$/.test(human.trim())) return "Supply must be a whole number";
-  const v = BigInt(human.trim());
-  if (v < MIN_SUPPLY) return `Supply must be at least ${MIN_SUPPLY.toString()}`;
-  if (v > MAX_SUPPLY) return `Supply must be at most ${MAX_SUPPLY.toString()}`;
-  return null;
-}
-function toRaw(human, decimals = COIN_DECIMALS) {
-  return human * 10n ** BigInt(decimals);
-}
-function teamCoinsRaw(supplyRaw, pct) {
-  const bps = BigInt(Math.round(pct * 100));
-  return supplyRaw * bps / 10000n;
-}
-var PRICE_SCALE = 1000000000000n;
-function buybackQuoteRaw(teamCoinsRawValue, price, quoteDecimals) {
-  const priceScaled = BigInt(Math.round(price * Number(PRICE_SCALE)));
-  return teamCoinsRawValue * priceScaled * 10n ** BigInt(quoteDecimals) / (PRICE_SCALE * 10n ** BigInt(COIN_DECIMALS));
-}
-function fdvHuman(supplyHuman, price) {
-  return supplyHuman * price;
-}
-
-// src/starknet/services/creatorCoin.ts
-var VALIDATED_EKUBO_PARAMS = {
-  fee: "0xc49ba5e353f7d00000000000000000",
-  tickSpacing: 5982n,
-  startingPrice: { mag: 4600158n, sign: true },
-  bound: 88719042n
-};
-var TICK_BASE = 1.000001;
-function priceToEkuboParams(quoteDecimals, price = SUGGESTED_DEFAULT_PRICE) {
-  const decAdj = 10 ** (COIN_DECIMALS - quoteDecimals);
-  const rawRatio = price / decAdj;
-  const tickSpacing = Number(VALIDATED_EKUBO_PARAMS.tickSpacing);
-  const rawTick = Math.log(rawRatio) / Math.log(TICK_BASE);
-  const roundedTick = Math.trunc(rawTick / tickSpacing) * tickSpacing;
-  return {
-    fee: VALIDATED_EKUBO_PARAMS.fee,
-    tickSpacing: VALIDATED_EKUBO_PARAMS.tickSpacing,
-    startingPrice: { mag: BigInt(Math.abs(roundedTick)), sign: roundedTick < 0 },
-    bound: VALIDATED_EKUBO_PARAMS.bound
-  };
-}
-function validatePrice(quoteDecimals, price) {
-  if (!isFinite(price) || price <= 0) return "Price must be a positive number";
-  const decAdj = 10 ** (COIN_DECIMALS - quoteDecimals);
-  const rawRatio = price / decAdj;
-  if (!isFinite(rawRatio) || rawRatio <= 0) return "Price must be a positive number";
-  const rawTick = Math.log(rawRatio) / Math.log(TICK_BASE);
-  if (!isFinite(rawTick)) return "Price is outside the supported range";
-  const bound = Number(VALIDATED_EKUBO_PARAMS.bound);
-  if (Math.abs(rawTick) >= bound) return "Price is outside the supported range";
-  return null;
-}
-var MAX_TEAM_ALLOCATION_PERCENT = 10;
-var MAX_HOLDERS_AT_LAUNCH = 10;
-function u2562(parts, offset = 0) {
-  return BigInt(parts[offset] ?? "0x0") + (BigInt(parts[offset + 1] ?? "0x0") << 128n);
-}
-async function getCreatorCoinGuarantees(coinAddress, provider) {
-  const call = (entrypoint) => provider.callContract({ contractAddress: coinAddress, entrypoint, calldata: [] });
-  const [launchedRes, allocRes] = await Promise.all([
-    call("is_launched").catch(() => null),
-    call("get_team_allocation").catch(() => null)
-  ]);
-  if (!launchedRes || !allocRes) return null;
-  const [supplyRes, blockRes, liquidityRes] = await Promise.all([
-    call("total_supply"),
-    call("launched_at_block_number").catch(() => null),
-    call("liquidity_type").catch(() => null)
-  ]);
-  const isLaunched = BigInt(launchedRes[0] ?? "0x0") !== 0n;
-  const totalSupply = u2562(supplyRes);
-  const teamAllocation = u2562(allocRes);
-  const teamAllocationPercent = totalSupply > 0n ? Number(teamAllocation * 10000n / totalSupply) / 100 : null;
-  const launchedAtBlock = isLaunched && blockRes?.[0] != null ? Number(BigInt(blockRes[0])) : null;
-  const liquidityPositionId = liquidityRes && BigInt(liquidityRes[0] ?? "0x1") === 0n && liquidityRes[2] != null ? BigInt(liquidityRes[2]).toString() : null;
-  return {
-    isLaunched,
-    launchedAtBlock,
-    totalSupplyRaw: totalSupply.toString(),
-    teamAllocationRaw: teamAllocation.toString(),
-    teamAllocationPercent,
-    liquidityPositionId
-  };
-}
-var _factoryContract = null;
-function factoryContract() {
-  if (!_factoryContract) {
-    _factoryContract = newContract(
-      CreatorCoinFactoryABI,
-      chunk7EYJC5CB_cjs.getStarknetCoordinates("STARKNET").creatorCoinFactory
-    );
-  }
-  return _factoryContract;
-}
-function buildCreateCreatorCoinCall(params) {
-  const salt = params.salt ?? BigInt("0x" + Date.now().toString(16));
-  return factoryContract().populate("create_creator_coin", [
-    params.owner,
-    params.name,
-    params.symbol,
-    BigInt(params.initialSupply),
-    BigInt(salt)
-  ]);
-}
-function buildLaunchOnEkuboCalls(params) {
-  const ek = params.ekubo;
-  const launchParameters = {
-    creator_coin_address: params.creatorCoin,
-    transfer_restriction_delay: params.transferRestrictionDelay ?? 0,
-    max_percentage_buy_launch: params.maxPercentageBuyLaunch ?? 200,
-    quote_address: params.quoteToken,
-    initial_holders: params.initialHolders,
-    initial_holders_amounts: params.initialHoldersAmounts.map((a) => BigInt(a))
-  };
-  const ekuboParameters = {
-    fee: BigInt(ek.fee),
-    tick_spacing: BigInt(ek.tickSpacing),
-    starting_price: { mag: BigInt(ek.startingPrice.mag), sign: ek.startingPrice.sign },
-    bound: BigInt(ek.bound)
-  };
-  const calls = [];
-  if (params.quoteFundAmount !== void 0) {
-    const amt = starknet.uint256.bnToUint256(BigInt(params.quoteFundAmount));
-    calls.push({
-      contractAddress: params.quoteToken,
-      entrypoint: "transfer",
-      calldata: [chunk7EYJC5CB_cjs.getStarknetCoordinates("STARKNET").creatorCoinFactory, amt.low, amt.high]
-    });
-  }
-  calls.push(factoryContract().populate("launch_on_ekubo", [launchParameters, ekuboParameters]));
-  return calls;
-}
-var CREATOR_COIN_CREATED_SELECTOR = starknet.hash.getSelectorFromName("CreatorCoinCreated");
-function parseCreatorCoinCreated(receipt) {
-  const factory = chunk2R7XBA34_cjs.normalizeAddress("STARKNET", chunk7EYJC5CB_cjs.getStarknetCoordinates("STARKNET").creatorCoinFactory);
-  for (const ev of receipt?.events ?? []) {
-    let from;
-    try {
-      from = chunk2R7XBA34_cjs.normalizeAddress("STARKNET", ev.from_address ?? "");
-    } catch {
-      continue;
-    }
-    if (from !== factory) continue;
-    const k0 = ev.keys?.[0];
-    if (!k0 || chunk2R7XBA34_cjs.normalizeAddress("STARKNET", k0) !== chunk2R7XBA34_cjs.normalizeAddress("STARKNET", CREATOR_COIN_CREATED_SELECTOR)) continue;
-    const data = ev.data ?? [];
-    if (data.length < 1) continue;
-    return chunk2R7XBA34_cjs.normalizeAddress("STARKNET", data[data.length - 1]);
-  }
-  throw new Error("Coin deployed but the coin address could not be read from the receipt");
-}
-var CreatorCoinService = class {
-  constructor(config) {
-    this.factoryAddress = chunk7EYJC5CB_cjs.getStarknetCoordinates(config.chain).creatorCoinFactory;
-  }
-  _factory(account) {
-    return newContract(CreatorCoinFactoryABI, this.factoryAddress, account);
-  }
-  async createCreatorCoin(account, params) {
-    const res = await account.execute([buildCreateCreatorCoinCall(params)]);
-    return { txHash: res.transaction_hash };
-  }
-  async launchOnEkubo(account, params) {
-    const res = await account.execute(buildLaunchOnEkuboCalls(params));
-    return { txHash: res.transaction_hash };
-  }
-  async isCreatorCoin(address, account) {
-    const r = await this._factory(account).is_creator_coin(address);
-    return BigInt(r) === 1n;
-  }
-};
-var TicketService = class {
-  constructor(config) {
-    this.factoryAddress = chunk7EYJC5CB_cjs.getStarknetCoordinates(config.chain).ipTicketsFactory;
-  }
-  _factory(account, factoryAddress) {
-    const address = factoryAddress ?? this.factoryAddress;
-    if (!address) throw new Error("IP-Tickets factory address not configured for this chain");
-    return newContract(IPTicketCollectionFactoryABI, chunk2R7XBA34_cjs.normalizeAddress("STARKNET", address), account);
-  }
-  _collection(address, account) {
-    return newContract(IPTicketCollectionABI, chunk2R7XBA34_cjs.normalizeAddress("STARKNET", address), account);
-  }
-  async deployCollection(account, params) {
-    const call = this._factory(account, params.factoryAddress).populate("deploy_collection", [
-      params.name,
-      params.symbol,
-      params.baseUri
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async createTicket(account, params) {
-    const startTime = params.startTime != null ? new starknet.CairoOption(starknet.CairoOptionVariant.Some, params.startTime) : new starknet.CairoOption(starknet.CairoOptionVariant.None);
-    const endTime = params.endTime != null ? new starknet.CairoOption(starknet.CairoOptionVariant.Some, params.endTime) : new starknet.CairoOption(starknet.CairoOptionVariant.None);
-    const call = this._collection(params.collection, account).populate("create_ticket", [
-      starknet.cairo.uint256(params.maxSupply),
-      startTime,
-      endTime,
-      params.royaltyBps,
-      params.metadataUri
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async mint(account, params) {
-    const call = this._collection(params.collection, account).populate("mint", [
-      params.to,
-      starknet.cairo.uint256(params.tokenId),
-      starknet.cairo.uint256(params.amount)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-var ClubService = class {
-  constructor(config) {
-    this.factoryAddress = chunk7EYJC5CB_cjs.getStarknetCoordinates(config.chain).ipClubFactory;
-  }
-  _factory(account, factoryAddress) {
-    const address = factoryAddress ?? this.factoryAddress;
-    if (!address) throw new Error("IP-Club factory address not configured for this chain");
-    return newContract(IPClubFactoryABI, chunk2R7XBA34_cjs.normalizeAddress("STARKNET", address), account);
-  }
-  _collection(address, account) {
-    return newContract(IPClubCollectionABI, chunk2R7XBA34_cjs.normalizeAddress("STARKNET", address), account);
-  }
-  async deployCollection(account, params) {
-    const call = this._factory(account, params.factoryAddress).populate("deploy_collection", [
-      params.name,
-      params.symbol,
-      params.baseUri
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async createMembership(account, params) {
-    const startTime = params.startTime != null ? new starknet.CairoOption(starknet.CairoOptionVariant.Some, params.startTime) : new starknet.CairoOption(starknet.CairoOptionVariant.None);
-    const endTime = params.endTime != null ? new starknet.CairoOption(starknet.CairoOptionVariant.Some, params.endTime) : new starknet.CairoOption(starknet.CairoOptionVariant.None);
-    const call = this._collection(params.collection, account).populate("create_membership", [
-      starknet.cairo.uint256(params.maxSupply),
-      startTime,
-      endTime,
-      params.royaltyBps,
-      params.metadataUri
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async mint(account, params) {
-    const call = this._collection(params.collection, account).populate("mint", [
-      params.to,
-      starknet.cairo.uint256(params.tokenId),
-      starknet.cairo.uint256(params.amount)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-var SponsorshipService = class {
-  constructor(config) {
-    this.sponsorshipAddress = chunk7EYJC5CB_cjs.getStarknetCoordinates(config.chain).ipSponsorship;
-  }
-  _contract(account, address) {
-    const resolved = address ?? this.sponsorshipAddress;
-    if (!resolved) {
-      throw new Error("IP-Sponsorship address not configured for this chain");
-    }
-    return newContract(IPSponsorshipABI, chunk2R7XBA34_cjs.normalizeAddress("STARKNET", resolved), account);
-  }
-  async createOffer(account, params) {
-    const specificSponsor = params.specificSponsor ? new starknet.CairoOption(starknet.CairoOptionVariant.Some, params.specificSponsor) : new starknet.CairoOption(starknet.CairoOptionVariant.None);
-    const call = this._contract(account, params.sponsorshipAddress).populate("create_offer", [
-      params.nftContract,
-      starknet.cairo.uint256(params.tokenId),
-      starknet.cairo.uint256(params.minAmount),
-      params.duration,
-      params.paymentToken,
-      params.licenseTermsUri,
-      params.transferable,
-      starknet.cairo.uint256(params.royaltyBps),
-      specificSponsor
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async setOfferOpen(account, params) {
-    const call = this._contract(account, params.sponsorshipAddress).populate("set_offer_open", [
-      starknet.cairo.uint256(params.offerId),
-      params.open
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async placeBid(account, params) {
-    const sponsorshipAddress = params.sponsorshipAddress ?? this.sponsorshipAddress;
-    if (!sponsorshipAddress) {
-      throw new Error("IP-Sponsorship address not configured for this chain");
-    }
-    const amount = starknet.cairo.uint256(params.amount);
-    const approveCall = {
-      contractAddress: params.paymentToken,
-      entrypoint: "approve",
-      calldata: [chunk2R7XBA34_cjs.normalizeAddress("STARKNET", sponsorshipAddress), amount.low.toString(), amount.high.toString()]
-    };
-    const bidCall = this._contract(account, sponsorshipAddress).populate("place_bid", [
-      starknet.cairo.uint256(params.offerId),
-      amount
-    ]);
-    const res = await account.execute([approveCall, bidCall]);
-    return { txHash: res.transaction_hash };
-  }
-  async retractBid(account, params) {
-    const call = this._contract(account, params.sponsorshipAddress).populate("retract_bid", [
-      starknet.cairo.uint256(params.offerId)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async acceptBid(account, params) {
-    const call = this._contract(account, params.sponsorshipAddress).populate("accept_bid", [
-      starknet.cairo.uint256(params.offerId),
-      params.sponsor
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async proposeSponsorship(account, params) {
-    const call = this._contract(account, params.sponsorshipAddress).populate("propose_sponsorship", [
-      params.nftContract,
-      starknet.cairo.uint256(params.tokenId),
-      starknet.cairo.uint256(params.amount),
-      params.duration,
-      params.validUntil ?? 0,
-      params.paymentToken,
-      params.licenseTermsUri,
-      params.transferable,
-      starknet.cairo.uint256(params.royaltyBps)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async withdrawProposal(account, params) {
-    const call = this._contract(account, params.sponsorshipAddress).populate("withdraw_proposal", [
-      starknet.cairo.uint256(params.proposalId)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async acceptProposal(account, params) {
-    const call = this._contract(account, params.sponsorshipAddress).populate("accept_proposal", [
-      starknet.cairo.uint256(params.proposalId)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async rejectProposal(account, params) {
-    const call = this._contract(account, params.sponsorshipAddress).populate("reject_proposal", [
-      starknet.cairo.uint256(params.proposalId)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-function createChainProvider(backendUrl, apiKey) {
-  return new starknet.RpcProvider({
-    nodeUrl: `${backendUrl.replace(/\/$/, "")}/v1/rpc`,
-    headers: apiKey ? { "x-api-key": apiKey } : {},
-    blockIdentifier: "latest"
-  });
-}
-
-// src/starknet/client.ts
-var MedialaneClient = class {
-  constructor(rawConfig = {}) {
-    this.config = chunk2R7XBA34_cjs.resolveConfig(rawConfig);
-    this.services = {
-      pop: new PopService(this.config),
-      drop: new DropService(this.config),
-      erc1155Collection: new ERC1155CollectionService(this.config),
-      creatorCoin: new CreatorCoinService(this.config),
-      ticket: new TicketService(this.config),
-      club: new ClubService(this.config),
-      sponsorship: new SponsorshipService(this.config)
-    };
-    if (!this.config.backendUrl) {
-      const sentinel = new chunk2R7XBA34_cjs.ApiClient("https://medialane-sdk-no-backend.invalid", this.config.apiKey);
-      const apiMethodNames = new Set(
-        Object.getOwnPropertyNames(chunk2R7XBA34_cjs.ApiClient.prototype).filter(
-          (k) => k !== "constructor" && typeof sentinel[k] === "function"
-        )
-      );
-      this.api = new Proxy(sentinel, {
-        get(target, prop, receiver) {
-          if (typeof prop === "symbol" || !apiMethodNames.has(prop)) {
-            return Reflect.get(target, prop, receiver);
-          }
-          return () => {
-            throw new Error(
-              `backendUrl not configured. Pass backendUrl to MedialaneClient to use .api.${String(prop)}()`
-            );
-          };
-        }
-      });
-    } else {
-      this.api = new chunk2R7XBA34_cjs.ApiClient(this.config.backendUrl, this.config.apiKey, this.config.retryOptions, this.config.chain);
-    }
-  }
-  get chain() {
-    return this.config.chain;
-  }
-  get provider() {
-    if (!this.config.backendUrl) {
-      throw new Error("backendUrl not configured. Pass backendUrl to MedialaneClient to use .provider");
-    }
-    return this._provider ?? (this._provider = createChainProvider(this.config.backendUrl, this.config.apiKey));
-  }
-  get marketplaceContract() {
-    return this.config.marketplaceContract;
-  }
-};
-
-// src/starknet/erc20.ts
-async function erc20Balance(provider, token, holder) {
-  const read = (entrypoint) => provider.callContract({ contractAddress: token, entrypoint, calldata: [holder] }, "latest");
-  const [low = "0x0", high = "0x0"] = await read("balanceOf").catch(() => read("balance_of"));
-  return BigInt(low) + (BigInt(high) << 128n);
-}
-var STARKNET_DOMAIN = [
-  { name: "name", type: "shortstring" },
-  { name: "version", type: "shortstring" },
-  { name: "chainId", type: "shortstring" },
-  { name: "revision", type: "shortstring" }
-];
-var OFFER_ITEM = [
-  { name: "item_type", type: "shortstring" },
-  { name: "token", type: "ContractAddress" },
-  { name: "identifier_or_criteria", type: "felt" },
-  { name: "amount", type: "felt" }
-];
-var CONSIDERATION_ITEM = [
-  { name: "item_type", type: "shortstring" },
-  { name: "token", type: "ContractAddress" },
-  { name: "identifier_or_criteria", type: "felt" },
-  { name: "amount", type: "felt" },
-  { name: "recipient", type: "ContractAddress" }
-];
-var ORDER_PARAMETERS = [
-  { name: "offerer", type: "ContractAddress" },
-  { name: "marketplace", type: "ContractAddress" },
-  { name: "offer", type: "OfferItem" },
-  { name: "consideration", type: "ConsiderationItem" },
-  { name: "royalty_max_bps", type: "felt" },
-  { name: "start_time", type: "felt" },
-  { name: "end_time", type: "felt" },
-  { name: "salt", type: "felt" },
-  { name: "counter", type: "felt" }
-];
-var ORDER_CANCELLATION = [
-  { name: "order_hash", type: "felt" },
-  { name: "offerer", type: "ContractAddress" }
-];
-var DOMAIN_VERSION = {
-  erc721: "5",
-  erc1155: "4"
-};
-function buildDomain(standard, chainId) {
-  return {
-    name: "Medialane",
-    version: DOMAIN_VERSION[standard],
-    chainId,
-    revision: starknet.TypedDataRevision.ACTIVE
-  };
-}
-function buildOrderTypedData(message, chainId) {
-  return {
-    domain: buildDomain("erc721", chainId),
-    primaryType: "OrderParameters",
-    types: {
-      StarknetDomain: STARKNET_DOMAIN,
-      OrderParameters: ORDER_PARAMETERS,
-      OfferItem: OFFER_ITEM,
-      ConsiderationItem: CONSIDERATION_ITEM
-    },
-    message
-  };
-}
-function build1155OrderTypedData(message, chainId) {
-  return {
-    domain: buildDomain("erc1155", chainId),
-    primaryType: "OrderParameters",
-    types: {
-      StarknetDomain: STARKNET_DOMAIN,
-      OrderParameters: ORDER_PARAMETERS,
-      OfferItem: OFFER_ITEM,
-      ConsiderationItem: CONSIDERATION_ITEM
-    },
-    message
-  };
-}
-function buildCancellationTypedData(message, chainId) {
-  return {
-    domain: buildDomain("erc721", chainId),
-    primaryType: "OrderCancellation",
-    types: {
-      StarknetDomain: STARKNET_DOMAIN,
-      OrderCancellation: ORDER_CANCELLATION
-    },
-    message
-  };
-}
-function build1155CancellationTypedData(message, chainId) {
-  return {
-    domain: buildDomain("erc1155", chainId),
-    primaryType: "OrderCancellation",
-    types: {
-      StarknetDomain: STARKNET_DOMAIN,
-      OrderCancellation: ORDER_CANCELLATION
-    },
-    message
-  };
-}
 
 // src/starknet/marketplace/build.ts
 function contractFor(cfg) {
-  return newContract(IPMarketplaceABI, cfg.marketplaceContract);
+  return newContract(IPMarketplaceABI, cfg.marketplace721Contract);
 }
 function buildListingOrder(i, cfg) {
   const orderParams = {
     offerer: i.offerer,
-    marketplace: cfg.marketplaceContract,
+    marketplace: cfg.marketplace721Contract,
     offer: { item_type: "ERC721", token: i.nftContract, identifier_or_criteria: i.tokenId, amount: "1" },
     consideration: {
       item_type: "ERC20",
@@ -11360,13 +10533,13 @@ function buildListingOrder(i, cfg) {
     salt: i.salt,
     counter: i.counter
   };
-  const typedData = chunk2R7XBA34_cjs.stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
+  const typedData = chunkMEJ47LC3_cjs.stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
   return { orderParams, typedData };
 }
 function buildOfferOrder(i, cfg) {
   const orderParams = {
     offerer: i.offerer,
-    marketplace: cfg.marketplaceContract,
+    marketplace: cfg.marketplace721Contract,
     offer: { item_type: "ERC20", token: i.paymentTokenAddress, identifier_or_criteria: "0", amount: i.priceWei },
     consideration: {
       item_type: "ERC721",
@@ -11381,11 +10554,11 @@ function buildOfferOrder(i, cfg) {
     salt: i.salt,
     counter: i.counter
   };
-  const typedData = chunk2R7XBA34_cjs.stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
+  const typedData = chunkMEJ47LC3_cjs.stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
   return { orderParams, typedData };
 }
 function registerPayload(orderParams, signature) {
-  return chunk2R7XBA34_cjs.stringifyBigInts({
+  return chunkMEJ47LC3_cjs.stringifyBigInts({
     parameters: {
       ...orderParams,
       offer: { ...orderParams.offer, item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type) },
@@ -11406,7 +10579,7 @@ function buildFulfillCalls(a, cfg) {
   const approve = {
     contractAddress: a.paymentToken,
     entrypoint: "approve",
-    calldata: [cfg.marketplaceContract, u.low.toString(), u.high.toString()]
+    calldata: [cfg.marketplace721Contract, u.low.toString(), u.high.toString()]
   };
   const fulfill = contractFor(cfg).populate("fulfill_order", [a.orderHash]);
   const fee = buildFeeCall(
@@ -11416,14 +10589,14 @@ function buildFulfillCalls(a, cfg) {
   return fee ? [approve, fulfill, fee] : [approve, fulfill];
 }
 function buildCancelCalls(a, cfg) {
-  const cancelRequest = chunk2R7XBA34_cjs.stringifyBigInts({
+  const cancelRequest = chunkMEJ47LC3_cjs.stringifyBigInts({
     cancelation: { order_hash: a.orderHash, offerer: a.offerer },
     signature: a.signature
   });
   return [contractFor(cfg).populate("cancel_order", [cancelRequest])];
 }
 function buildCancelTypedData(orderHash, offerer, cfg) {
-  return chunk2R7XBA34_cjs.stringifyBigInts(buildCancellationTypedData({ order_hash: orderHash, offerer }, getChainId(cfg)));
+  return chunkMEJ47LC3_cjs.stringifyBigInts(buildCancellationTypedData({ order_hash: orderHash, offerer }, getChainId(cfg)));
 }
 function contractFor2(cfg) {
   return newContract(Medialane1155ABI, cfg.marketplace1155Contract);
@@ -11446,7 +10619,7 @@ function buildListing1155Order(i, cfg) {
     salt: i.salt,
     counter: i.counter
   };
-  const typedData = chunk2R7XBA34_cjs.stringifyBigInts(
+  const typedData = chunkMEJ47LC3_cjs.stringifyBigInts(
     build1155OrderTypedData(orderParams, getChainId(cfg))
   );
   return { orderParams, typedData };
@@ -11469,13 +10642,13 @@ function buildOffer1155Order(i, cfg) {
     salt: i.salt,
     counter: i.counter
   };
-  const typedData = chunk2R7XBA34_cjs.stringifyBigInts(
+  const typedData = chunkMEJ47LC3_cjs.stringifyBigInts(
     build1155OrderTypedData(orderParams, getChainId(cfg))
   );
   return { orderParams, typedData };
 }
 function registerPayload2(orderParams, signature) {
-  return chunk2R7XBA34_cjs.stringifyBigInts({
+  return chunkMEJ47LC3_cjs.stringifyBigInts({
     parameters: {
       ...orderParams,
       offer: { ...orderParams.offer, item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type) },
@@ -11506,14 +10679,14 @@ function buildFulfill1155Calls(a, cfg) {
   return fee ? [approve, fulfill, fee] : [approve, fulfill];
 }
 function buildCancel1155Calls(a, cfg) {
-  const cancelPayload = chunk2R7XBA34_cjs.stringifyBigInts({
+  const cancelPayload = chunkMEJ47LC3_cjs.stringifyBigInts({
     cancelation: { order_hash: a.orderHash, offerer: a.offerer },
     signature: a.signature
   });
   return [contractFor2(cfg).populate("cancel_order", [cancelPayload])];
 }
 function buildCancel1155TypedData(orderHash, offerer, cfg) {
-  return chunk2R7XBA34_cjs.stringifyBigInts(
+  return chunkMEJ47LC3_cjs.stringifyBigInts(
     build1155CancellationTypedData({ order_hash: orderHash, offerer }, getChainId(cfg))
   );
 }
@@ -11527,15 +10700,15 @@ var StarknetVenue = class {
   }
   async incrementCounter(signer) {
     return signer.execute([
-      { contractAddress: this.deps.config.marketplaceContract, entrypoint: "increment_counter", calldata: [] }
+      { contractAddress: this.deps.config.marketplace721Contract, entrypoint: "increment_counter", calldata: [] }
     ]);
   }
   getOrderDetails(orderRef) {
-    const marketplace = newContract(IPMarketplaceABI, this.deps.config.marketplaceContract, this.deps.provider);
+    const marketplace = newContract(IPMarketplaceABI, this.deps.config.marketplace721Contract, this.deps.provider);
     return marketplace.get_order_details(orderRef);
   }
   async getCounter(address) {
-    return this.readCounter(this.deps.config.marketplaceContract, address);
+    return this.readCounter(this.deps.config.marketplace721Contract, address);
   }
   async fulfillOrder(signer, orderRef, opts) {
     const o = await this.deps.resolveOrder(orderRef);
@@ -11558,7 +10731,7 @@ var StarknetVenue = class {
     const startTime = Math.floor(Date.now() / 1e3) + START_TIME_BUFFER_SECS;
     const endTime = p.endTime && p.endTime > 0 ? p.endTime : startTime + NO_EXPIRY_SECONDS;
     const quantity = p.quantity ?? "1";
-    const marketplace = standard === "ERC1155" ? this.deps.config.marketplace1155Contract : this.deps.config.marketplaceContract;
+    const marketplace = standard === "ERC1155" ? this.deps.config.marketplace1155Contract : this.deps.config.marketplace721Contract;
     const counter = String(await this.readCounter(marketplace, signer.address));
     let typedData;
     let buildCalls;
@@ -11620,7 +10793,7 @@ var StarknetVenue = class {
     const approve = {
       contractAddress: nftContract,
       entrypoint: "approve",
-      calldata: [this.deps.config.marketplaceContract, id.low.toString(), id.high.toString()]
+      calldata: [this.deps.config.marketplace721Contract, id.low.toString(), id.high.toString()]
     };
     let approved = false;
     try {
@@ -11629,7 +10802,7 @@ var StarknetVenue = class {
         entrypoint: "get_approved",
         calldata: [id.low.toString(), id.high.toString()]
       });
-      approved = BigInt(res[0]).toString() === BigInt(this.deps.config.marketplaceContract).toString();
+      approved = BigInt(res[0]).toString() === BigInt(this.deps.config.marketplace721Contract).toString();
     } catch {
     }
     return { approvalNeeded: !approved, approve };
@@ -11818,13 +10991,7 @@ var FundingTransferNotSentError = class extends Error {
   }
 };
 function fundingApiFor(client) {
-  return {
-    createFunding: (input) => client.createFunding(input),
-    getFundingChallenge: (id, payer) => client.getFundingChallenge(id, payer),
-    authorizeFunding: (id, input) => client.authorizeFunding(id, input),
-    submitFunding: (id, txHash) => client.submitFunding(id, txHash),
-    cancelFunding: (id) => client.cancelFunding(id)
-  };
+  return client.portal.funding;
 }
 function buildFundingTransferCall(instructions) {
   const amount = BigInt(instructions.amountAtomic);
@@ -11843,32 +11010,32 @@ async function fundWithChainTransfer(api, wallet, options) {
   const maxPolls = options.maxPolls ?? 20;
   step("creating");
   const params = options.amount !== void 0 ? { amount: options.amount } : { amountUsdc: options.amountUsdc };
-  const { data: intent } = await api.createFunding({ method: "chain-transfer", params });
+  const intent = await api.create({ method: "chain-transfer", params });
   let txHash;
   let transferStarted = false;
   try {
     step("signing");
-    const challenge = await api.getFundingChallenge(intent.id, wallet.address);
-    const signature = await wallet.signTypedData(challenge.data.typedData);
+    const challenge = await api.challenge(intent.id, wallet.address);
+    const signature = await wallet.signTypedData(challenge.typedData);
     step("authorizing");
-    const authorized = await api.authorizeFunding(intent.id, { payer: wallet.address, signature });
+    const authorized = await api.authorize(intent.id, { payer: wallet.address, signature });
     step("paying");
     transferStarted = true;
-    ({ txHash } = await wallet.sendTransfer(buildFundingTransferCall(authorized.data.instructions)));
+    ({ txHash } = await wallet.sendTransfer(buildFundingTransferCall(authorized.instructions)));
   } catch (err) {
     if (!transferStarted || err instanceof FundingTransferNotSentError) {
-      await api.cancelFunding(intent.id).catch(() => void 0);
+      await api.cancel(intent.id).catch(() => void 0);
     }
     throw err;
   }
   step("confirming");
   let reason = "waiting for the transfer to confirm";
   for (let attempt = 0; attempt < maxPolls; attempt++) {
-    const res = await api.submitFunding(intent.id, txHash);
-    if (res.data.status === "SETTLED") {
-      return { status: "SETTLED", intentId: intent.id, credited: res.data.credited };
+    const res = await api.submit(intent.id, txHash);
+    if (res.status === "SETTLED") {
+      return { status: "SETTLED", intentId: intent.id, credited: res.credited };
     }
-    reason = res.data.reason;
+    reason = res.reason;
     await sleep(pollMs);
   }
   return { status: "PENDING", intentId: intent.id, reason };
@@ -11876,13 +11043,13 @@ async function fundWithChainTransfer(api, wallet, options) {
 
 // src/starknet/services/executeIntent.ts
 async function confirmIntentBestEffort(client, intentId, txHash) {
-  await client.api.confirmIntent(intentId, txHash).catch(() => {
+  await client.api.intents.confirm(intentId, txHash).catch(() => {
   });
 }
 var SYNC_TIMEOUT_MS = 2e4;
 var SYNC_RETRY_MS = 2e3;
 function readableLater(err) {
-  return err instanceof chunk2R7XBA34_cjs.MedialaneApiError && err.status === 404;
+  return err instanceof chunk3HPMEDYH_cjs.MedialaneApiError && err.status === 404;
 }
 async function syncTransactionBestEffort(client, txHash, timeoutMs = SYNC_TIMEOUT_MS, retryMs = SYNC_RETRY_MS) {
   const deadline = Date.now() + timeoutMs;
@@ -11893,8 +11060,8 @@ async function syncTransactionBestEffort(client, txHash, timeoutMs = SYNC_TIMEOU
   });
   const sync = (async () => {
     while (!stopped) {
-      const again = await client.api.syncTransaction(txHash).then(
-        (res) => res.data?.pending === true,
+      const again = await client.api.intents.syncTransaction(txHash).then(
+        (res) => res?.pending === true,
         readableLater
       );
       if (!again || Date.now() + retryMs >= deadline) return;
@@ -11917,21 +11084,21 @@ async function assertTransactionSucceeded(provider, txHash, retryDelaysMs = RECE
       const receipt = await provider.getTransactionReceipt(txHash);
       const status = receipt.execution_status ?? receipt.status;
       if (status === "REVERTED" || status === "REJECTED") {
-        throw new chunk2R7XBA34_cjs.UserFacingError("Transaction was submitted but reverted onchain. Please check your balance and try again.");
+        throw new chunk3HPMEDYH_cjs.UserFacingError("Transaction was submitted but reverted onchain. Please check your balance and try again.");
       }
       if (status) return receipt;
     } catch (err) {
       if (err instanceof Error && err.message.includes("reverted onchain")) throw err;
     }
   }
-  throw new chunk2R7XBA34_cjs.UserFacingError("Verification timed out. Check your account for the transaction status.");
+  throw new chunk3HPMEDYH_cjs.UserFacingError("Verification timed out. Check your account for the transaction status.");
 }
 async function executeIntent(signer, client, intent, opts = {}) {
   let calls;
   if (intent.requiresSignature) {
     const signature = await signer.signTypedData(intent.typedData);
-    const signed = await client.api.submitIntentSignature(intent.id, signature);
-    calls = signed.data.calls;
+    const signed = await client.api.intents.submitSignature(intent.id, signature);
+    calls = signed.calls;
   } else {
     calls = intent.calls;
   }
@@ -11973,18 +11140,18 @@ function sameFelt(a, b) {
     return false;
   }
 }
-function u2563(low, high) {
+function u256(low, high) {
   return (BigInt(low ?? 0) + (BigInt(high ?? 0) << 128n)).toString();
 }
 function deployedCollectionFromReceipt(receipt, service) {
-  const factory = chunk2R7XBA34_cjs.getService(service)?.onchain?.STARKNET?.factoryAddress;
+  const factory = chunkMEJ47LC3_cjs.getService(service)?.onchain?.STARKNET?.factoryAddress;
   const { event, address } = DEPLOY_EVENTS[service];
   const selector = BigInt(starknet.hash.getSelectorFromName(event));
   for (const e of receipt.events ?? []) {
     if (factory && !sameFelt(e.from_address, factory)) continue;
     if (!sameFelt(e.keys?.[0], selector)) continue;
     const value = address(e);
-    if (value) return chunk2R7XBA34_cjs.normalizeAddress("STARKNET", value);
+    if (value) return chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", value);
   }
   return null;
 }
@@ -11992,771 +11159,816 @@ function mintedTokenIdFromReceipt(receipt, contract) {
   for (const e of receipt.events ?? []) {
     if (!sameFelt(e.from_address, contract)) continue;
     const keys = e.keys ?? [];
-    if (sameFelt(keys[0], IP_MINTED_SELECTOR) && keys.length >= 3) return u2563(keys[1], keys[2]);
-    if (sameFelt(keys[0], TRANSFER_SELECTOR) && keys.length === 5 && sameFelt(keys[1], 0n)) return u2563(keys[3], keys[4]);
+    if (sameFelt(keys[0], IP_MINTED_SELECTOR) && keys.length >= 3) return u256(keys[1], keys[2]);
+    if (sameFelt(keys[0], TRANSFER_SELECTOR) && keys.length === 5 && sameFelt(keys[1], 0n)) return u256(keys[3], keys[4]);
   }
   return null;
 }
-
-// src/starknet/services/sponsoredExecutor.ts
-var SponsoredCallRejectedError = class extends Error {
-};
-var FALLBACK_FUNDING_FAILURES = /* @__PURE__ */ new Set(["sponsor_unavailable", "credits_exhausted"]);
-function allowsFallbackFunding(code, status, stage) {
-  if (code) return FALLBACK_FUNDING_FAILURES.has(code);
-  return stage === "build" ? status >= 500 : status === 503;
-}
-async function failureOf(res, fallback) {
-  const body = await res.json().catch(() => null);
-  return { reason: body?.error || fallback, code: typeof body?.code === "string" ? body.code : void 0 };
-}
-async function executeSponsored(config, signer, request) {
-  const doFetch = config.fetchImpl ?? fetch;
-  const base = config.proxyUrl.replace(/\/$/, "");
-  const headers = { "Content-Type": "application/json", ...config.headers };
-  const buildRes = await doFetch(`${base}/build`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(request)
-  });
-  if (!buildRes.ok) {
-    const { reason, code } = await failureOf(buildRes, "We couldn't prepare this transaction.");
-    if (allowsFallbackFunding(code, buildRes.status, "build")) return { status: "unavailable", reason };
-    throw new SponsoredCallRejectedError(reason);
-  }
-  const { typedData } = await buildRes.json();
-  const signature = await signer.signTypedData(typedData);
-  const executeRes = await doFetch(`${base}/execute`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ ...request, typedData, signature })
-  });
-  if (!executeRes.ok) {
-    const { reason, code } = await failureOf(executeRes, "We couldn't submit this transaction.");
-    if (allowsFallbackFunding(code, executeRes.status, "execute")) {
-      return { status: "unavailable", reason };
-    }
-    throw new SponsoredCallRejectedError(reason);
-  }
-  const { transactionHash } = await executeRes.json();
-  return { status: "sponsored", transactionHash };
+var FRAGMENT_KEY = "pop-proof";
+var toHex = (x) => "0x" + x.toString(16).padStart(64, "0");
+var poseidon = (xs) => BigInt(starknet.hash.computePoseidonHashOnElements(xs.map((x) => "0x" + x.toString(16))));
+var nodeHash = (a, b) => a < b ? poseidon([a, b]) : poseidon([b, a]);
+function popLeafHash(address) {
+  return poseidon([poseidon([BigInt(address)])]);
 }
-function encodeByteArray(str) {
-  const bytes = new TextEncoder().encode(str);
-  const fullChunks = [];
-  let i = 0;
-  while (i + 31 <= bytes.length) {
-    let val = 0n;
-    for (const b of bytes.slice(i, i + 31)) {
-      val = val << 8n | BigInt(b);
-    }
-    fullChunks.push(starknet.num.toHex(val));
-    i += 31;
-  }
-  const remaining = bytes.slice(i);
-  let pendingVal = 0n;
-  for (const b of remaining) {
-    pendingVal = pendingVal << 8n | BigInt(b);
+function merkleTree(leafHashes) {
+  const leaves = [...leafHashes].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const tree = new Array(2 * leaves.length - 1);
+  leaves.forEach((leaf, i) => tree[tree.length - 1 - i] = leaf);
+  for (let i = tree.length - 1 - leaves.length; i >= 0; i--) {
+    tree[i] = nodeHash(tree[2 * i + 1], tree[2 * i + 2]);
   }
-  return [
-    fullChunks.length.toString(),
-    ...fullChunks,
-    starknet.num.toHex(pendingVal),
-    remaining.length.toString()
-  ];
-}
-var STARK_ORDER = 3618502788666131213697322783095070105526743751716087489154079457884512865583n;
-function deriveOwnerKeyPair(secret, recipientId) {
-  const prk = hkdf_js.extract(sha2_js.sha256, secret);
-  const okm = hkdf_js.expand(sha2_js.sha256, prk, new TextEncoder().encode(recipientId), 32);
-  let scalar = BigInt("0x" + Buffer.from(okm).toString("hex")) % STARK_ORDER;
-  if (scalar === 0n) scalar = 1n;
-  const privateKey = starknet.num.toHex(scalar);
-  const publicKey = starknet.ec.starkCurve.getStarkKey(privateKey);
-  return { privateKey, publicKey };
-}
-var STARKNET_SIGNER_TYPE = "0x537461726b6e6574205369676e6572";
-var OPTION_NONE = "0x1";
-var SIGNER_STARKNET = "0x0";
-function computeOwnerGuid(ownerPubkey) {
-  return starknet.hash.computePoseidonHash(STARKNET_SIGNER_TYPE, starknet.num.toHex(ownerPubkey));
-}
-function changeOwners(accountAddress, guidsToRemove, pubkeysToAdd) {
-  return {
-    contractAddress: accountAddress,
-    entrypoint: "change_owners",
-    calldata: [
-      starknet.num.toHex(guidsToRemove.length),
-      ...guidsToRemove,
-      starknet.num.toHex(pubkeysToAdd.length),
-      ...pubkeysToAdd.flatMap((p) => [SIGNER_STARKNET, starknet.num.toHex(p)]),
-      OPTION_NONE
-    ]
-  };
-}
-function buildAddOwnerCall(accountAddress, addOwnerPubkey) {
-  return changeOwners(accountAddress, [], [addOwnerPubkey]);
-}
-function buildRemoveOwnerCall(accountAddress, removeOwnerPubkey) {
-  return changeOwners(accountAddress, [computeOwnerGuid(removeOwnerPubkey)], []);
-}
-function buildRemoveOwnerByGuidCall(accountAddress, ownerGuid) {
-  return changeOwners(accountAddress, [starknet.num.toHex(ownerGuid)], []);
-}
-function buildDeployAccountParams(ownerPubkey, salt = 0) {
-  return {
-    classHash: chunk2R7XBA34_cjs.STARKNET_MEDIAWALLET_CLASS_HASH,
-    constructorCalldata: chunk2R7XBA34_cjs.ownerConstructorCalldata(ownerPubkey),
-    addressSalt: starknet.num.toHex(salt),
-    contractAddress: chunk2R7XBA34_cjs.computeAccountAddress(ownerPubkey, salt)
-  };
-}
-var norm = (address) => chunk2R7XBA34_cjs.normalizeAddress("STARKNET", address);
-var SIGNER_TYPE_NAMES = ["Starknet", "Secp256k1", "Secp256r1"];
-function encodeFeltArray(items) {
-  return [starknet.num.toHex(items.length), ...items];
-}
-function encodeStarknetSigner(pubkey) {
-  return ["0x0", starknet.num.toHex(pubkey)];
-}
-function encodeStarknetSignerArray(pubkeys) {
-  return [starknet.num.toHex(pubkeys.length), ...pubkeys.flatMap(encodeStarknetSigner)];
-}
-function buildSetFirstGuardianCall(address, guardianPubkey) {
   return {
-    contractAddress: norm(address),
-    entrypoint: "change_guardians",
-    calldata: [...encodeFeltArray([]), ...encodeStarknetSignerArray([guardianPubkey])]
+    root: tree[0],
+    proof(leaf) {
+      let i = tree.lastIndexOf(leaf);
+      if (i < tree.length - leaves.length) throw new Error("Not a leaf of this tree");
+      const proof = [];
+      while (i > 0) {
+        proof.push(tree[i % 2 === 1 ? i + 1 : i - 1]);
+        i = Math.floor((i - 1) / 2);
+      }
+      return proof;
+    }
   };
 }
-function buildTriggerEscapeOwnerCall(targetAddress, newOwnerPubkey) {
-  return {
-    contractAddress: norm(targetAddress),
-    entrypoint: "trigger_escape_owner",
-    calldata: encodeStarknetSigner(newOwnerPubkey)
-  };
+function buildPopAllowlist(addresses) {
+  const unique = [...new Set(addresses.map((a) => chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", a)))];
+  if (unique.length === 0) throw new Error("An allowlist needs at least one address");
+  const leaves = unique.map((address) => ({ address, leaf: popLeafHash(address) }));
+  const tree = merkleTree(leaves.map((l) => l.leaf));
+  const proofs = {};
+  for (const { address, leaf } of leaves) proofs[address] = tree.proof(leaf).map(toHex);
+  return { root: toHex(tree.root), proofs };
 }
-function buildCompleteEscapeOwnerCall(targetAddress) {
-  return { contractAddress: norm(targetAddress), entrypoint: "escape_owner", calldata: [] };
+function verifyPopProof(root, address, proof) {
+  let computed = popLeafHash(address);
+  for (const sibling of proof) computed = nodeHash(computed, BigInt(sibling));
+  return computed === BigInt(root);
 }
-function buildCancelEscapeCall(address) {
-  return { contractAddress: norm(address), entrypoint: "cancel_escape", calldata: [] };
+function encodePopClaimFragment(proof) {
+  return `#${FRAGMENT_KEY}=${proof.join(",")}`;
 }
-function decodeGuardiansInfo(res) {
-  const len = Number(res[0]);
-  const out = [];
-  for (let i = 0; i < len; i++) {
-    const base = 1 + i * 3;
-    out.push({
-      type: SIGNER_TYPE_NAMES[Number(res[base])] ?? "Starknet",
-      guid: res[base + 1],
-      storedValue: res[base + 2]
-    });
-  }
-  return out;
+function decodePopClaimFragment(fragment) {
+  const raw = new URLSearchParams(fragment.replace(/^#/, "")).get(FRAGMENT_KEY);
+  if (raw === null) return null;
+  if (raw === "") return [];
+  const parts = raw.split(",");
+  return parts.every((p) => /^0x[0-9a-fA-F]{1,64}$/.test(p)) ? parts : null;
 }
-var ESCAPE_TYPE_NAMES = ["None", "Guardian", "Owner"];
-var ESCAPE_STATUS_NAMES = ["None", "NotReady", "Ready", "Expired"];
-function decodeEscapeAndStatus(res) {
-  const readyAt = Number(res[0]);
-  const escapeType = ESCAPE_TYPE_NAMES[Number(res[1])] ?? "None";
-  const optionTag = Number(res[2]);
-  const statusIndex = optionTag === 0 ? 5 : 3;
-  const status = ESCAPE_STATUS_NAMES[Number(res[statusIndex])] ?? "None";
-  return { readyAt, escapeType, status };
+function popClaimLinks(origin, collection, list) {
+  const base = `${origin}${chunkMEJ47LC3_cjs.collectionHref("STARKNET", collection)}`;
+  return Object.entries(list.proofs).map(([address, proof]) => ({
+    address,
+    url: `${base}${encodePopClaimFragment(proof)}`
+  }));
 }
-async function getGuardians(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_guardians_info",
-    calldata: []
-  });
-  return decodeGuardiansInfo(res);
+function popClaimLinksCsv(links) {
+  return ["address,claim_link", ...links.map((l) => `${l.address},${l.url}`)].join("\n");
 }
-async function getOwners(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_owners_info",
-    calldata: []
-  });
-  return decodeGuardiansInfo(res);
+async function popClaimInfo(provider, collection) {
+  const contractAddress = chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", collection);
+  const [root, end] = await Promise.all([
+    provider.callContract({ contractAddress, entrypoint: "allowlist_root", calldata: [] }),
+    provider.callContract({ contractAddress, entrypoint: "claim_end_time", calldata: [] })
+  ]);
+  return { root: root[0] ?? "0x0", claimEndTime: Number(BigInt(end[0] ?? "0x0")) };
 }
-async function getEscape(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_escape_and_status",
-    calldata: []
-  });
-  return decodeEscapeAndStatus(res);
+function popClaimState(input) {
+  const { hasClaimed, proof, wallet, info } = input;
+  if (hasClaimed === true) return "claimed";
+  if (hasClaimed === null || info === null) return "loading";
+  if (BigInt(info.root) === 0n) return "closed";
+  if (info.claimEndTime !== 0 && info.now > info.claimEndTime) return "ended";
+  if (proof === null) return "no-link";
+  if (!wallet || !verifyPopProof(info.root, wallet, proof)) return "wrong-wallet";
+  return "ready";
 }
-async function getEscapeSecurityPeriod(provider, address) {
+var addr = (a) => chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", a);
+var byteArrayFelts = (s) => starknet.CallData.compile([starknet.byteArray.byteArrayFromString(s)]);
+var popCalls = {
+  claim(collection, proof) {
+    return { contractAddress: addr(collection), entrypoint: "claim", calldata: [String(proof.length), ...proof] };
+  },
+  /** An empty `tokenUri` uses the collection's URI. */
+  issue(collection, recipient, tokenUri = "") {
+    return { contractAddress: addr(collection), entrypoint: "issue", calldata: [addr(recipient), ...byteArrayFelts(tokenUri)] };
+  },
+  /** Only the token's holder can burn it. */
+  burn(collection, tokenId) {
+    const id = starknet.cairo.uint256(BigInt(tokenId));
+    return { contractAddress: addr(collection), entrypoint: "burn", calldata: [String(id.low), String(id.high)] };
+  },
+  setAllowlistRoot(collection, root) {
+    return { contractAddress: addr(collection), entrypoint: "set_allowlist_root", calldata: [root] };
+  }
+};
+async function popHasClaimed(provider, collection, address) {
   const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_escape_security_period",
-    calldata: []
+    contractAddress: chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", collection),
+    entrypoint: "has_claimed",
+    calldata: [chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", address)]
   });
-  return Number(res[0]);
+  return BigInt(res[0] ?? "0x0") !== 0n;
 }
-
-// src/wallet/store.ts
-function createOwnerStore(config) {
-  const { storeKey, changeEvent } = config;
-  const announce = () => {
-    if (typeof window === "undefined") return;
-    window.dispatchEvent(new Event(changeEvent));
-  };
+var DROP_MAX_CLAIM_QUANTITY = 50n;
+var addr2 = (a) => chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", a);
+var factoryData = new starknet.CallData(DropFactoryABI);
+var collectionData = new starknet.CallData(DropCollectionABI);
+function toContractTerms(t) {
+  const price = BigInt(t.price);
   return {
-    load() {
-      if (typeof window === "undefined") return null;
-      try {
-        const raw = localStorage.getItem(storeKey);
-        return raw ? JSON.parse(raw) : null;
-      } catch {
-        return null;
-      }
-    },
-    loadAddress() {
-      return this.load()?.address ?? null;
-    },
-    save(sealed) {
-      const previous = this.load();
-      if (previous && previous.address !== sealed.address) {
-        localStorage.setItem(`${storeKey}:${previous.address}`, JSON.stringify(previous));
-      }
-      localStorage.setItem(storeKey, JSON.stringify(sealed));
-      announce();
-    },
-    clear() {
-      localStorage.removeItem(storeKey);
-      announce();
-    },
-    notifyChange: announce,
-    onChange(listener) {
-      window.addEventListener(changeEvent, listener);
-      return () => window.removeEventListener(changeEvent, listener);
-    }
+    start_time: t.startTime,
+    end_time: t.endTime,
+    price: starknet.cairo.uint256(price),
+    payment_token: price === 0n ? "0x0" : addr2(t.paymentToken),
+    max_per_wallet: starknet.cairo.uint256(BigInt(t.maxPerWallet))
   };
 }
-
-// src/wallet/pairing.ts
-var SCHEME = "medialane-device";
-var VERSION = 1;
-var LABEL_MAX = 32;
-var STARK_PRIME = (1n << 251n) + 17n * (1n << 192n) + 1n;
-var InvalidPairingPayloadError = class extends Error {
-  constructor(message = "This code is not a Medialane device request.") {
-    super(message);
-    this.name = "InvalidPairingPayloadError";
+var dropCalls = {
+  create(factory, p) {
+    return {
+      contractAddress: addr2(factory),
+      entrypoint: "create_drop",
+      calldata: factoryData.compile("create_drop", {
+        name: p.name,
+        symbol: p.symbol,
+        base_uri: p.baseUri,
+        max_supply: starknet.cairo.uint256(BigInt(p.maxSupply)),
+        terms: toContractTerms(p.terms),
+        allowlist_root: p.allowlistRoot ?? "0x0"
+      })
+    };
+  },
+  /** Approve (paid drops) and claim. The platform fee call is added by the caller. */
+  claim(collection, p) {
+    const quantity = BigInt(p.quantity);
+    if (quantity < 1n || quantity > DROP_MAX_CLAIM_QUANTITY) throw new RangeError(`quantity must be 1 to ${DROP_MAX_CLAIM_QUANTITY}`);
+    const total = BigInt(p.price) * quantity;
+    const calls = [];
+    if (total > 0n) {
+      calls.push({
+        contractAddress: addr2(p.paymentToken),
+        entrypoint: "approve",
+        calldata: starknet.CallData.compile([addr2(collection), starknet.cairo.uint256(total)])
+      });
+    }
+    calls.push({
+      contractAddress: addr2(collection),
+      entrypoint: "claim",
+      calldata: collectionData.compile("claim", { quantity: starknet.cairo.uint256(quantity), proof: p.proof ?? [] })
+    });
+    return calls;
+  },
+  /** Organizer only: free mint within the supply cap. */
+  issue(collection, recipient, quantity) {
+    const q = BigInt(quantity);
+    if (q < 1n) throw new RangeError("quantity must be at least 1");
+    return {
+      contractAddress: addr2(collection),
+      entrypoint: "issue",
+      calldata: collectionData.compile("issue", { recipient: addr2(recipient), quantity: starknet.cairo.uint256(q) })
+    };
+  },
+  /** Organizer only. 0 opens the drop to everyone. */
+  setAllowlistRoot(collection, root) {
+    return { contractAddress: addr2(collection), entrypoint: "set_allowlist_root", calldata: collectionData.compile("set_allowlist_root", { root }) };
   }
 };
-function normalisePublicKey(input) {
-  if (typeof input !== "string" || !/^0x[0-9a-fA-F]+$/.test(input)) {
-    throw new InvalidPairingPayloadError("That device key is not valid.");
-  }
-  const value = BigInt(input);
-  if (value === 0n || value >= STARK_PRIME) {
-    throw new InvalidPairingPayloadError("That device key is not valid.");
-  }
-  return `0x${value.toString(16)}`;
+function dropMintCost(price, quantity, feeBps2) {
+  const subtotal = BigInt(price) * BigInt(quantity);
+  const fee = feeAmount(subtotal, feeBps2);
+  return { subtotal, fee, total: subtotal + fee };
 }
-function sanitiseLabel(input) {
-  const raw = typeof input === "string" ? input : "";
-  return raw.replace(/\s+/g, " ").trim().slice(0, LABEL_MAX);
+
+// src/starknet/drop-state.ts
+var hex = (v) => chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", v ?? "0x0");
+var u2562 = (low, high) => BigInt(low ?? "0x0") + (BigInt(high ?? "0x0") << 128n);
+async function readDrop(provider, collection) {
+  const contractAddress = hex(collection);
+  const read = (entrypoint) => provider.callContract({ contractAddress, entrypoint, calldata: [] });
+  const [organizer, terms, root, max, minted] = await Promise.all([
+    read("organizer"),
+    read("terms"),
+    read("allowlist_root"),
+    read("max_supply"),
+    read("total_minted")
+  ]);
+  return {
+    organizer: hex(organizer[0]),
+    startTime: Number(BigInt(terms[0] ?? "0x0")),
+    endTime: Number(BigInt(terms[1] ?? "0x0")),
+    price: u2562(terms[2], terms[3]),
+    paymentToken: hex(terms[4]),
+    maxPerWallet: u2562(terms[5], terms[6]),
+    allowlistRoot: root[0] ?? "0x0",
+    maxSupply: u2562(max[0], max[1]),
+    totalMinted: u2562(minted[0], minted[1])
+  };
 }
-function encodePairingPayload(payload) {
-  return JSON.stringify({
-    scheme: SCHEME,
-    version: VERSION,
-    publicKey: normalisePublicKey(payload.publicKey),
-    label: sanitiseLabel(payload.label)
+async function buildDropClaimCalls(provider, collection, input, feeConfig) {
+  const drop = await readDrop(provider, collection);
+  const calls = dropCalls.claim(collection, {
+    quantity: input.quantity,
+    proof: input.proof,
+    price: drop.price,
+    paymentToken: drop.paymentToken
   });
+  if (drop.price === 0n) return calls;
+  const fee = buildFeeCall(
+    { surface: "launchpad", token: drop.paymentToken, grossAmount: drop.price * BigInt(input.quantity) },
+    feeConfig
+  );
+  return fee ? [...calls, fee] : calls;
 }
-function parsePairingPayload(encoded) {
-  let data;
-  try {
-    data = JSON.parse(encoded);
-  } catch {
-    throw new InvalidPairingPayloadError();
-  }
-  if (data === null || typeof data !== "object") throw new InvalidPairingPayloadError();
-  if (data.scheme !== SCHEME || data.version !== VERSION) throw new InvalidPairingPayloadError();
-  return {
-    publicKey: normalisePublicKey(data.publicKey),
-    label: sanitiseLabel(data.label)
-  };
+async function dropClaimedBy(provider, collection, wallet) {
+  const res = await provider.callContract({ contractAddress: hex(collection), entrypoint: "claimed_by", calldata: [hex(wallet)] });
+  return u2562(res[0], res[1]);
 }
-function parseAccountAddress(input) {
-  const trimmed = typeof input === "string" ? input.trim() : "";
-  if (!/^0x[0-9a-fA-F]{50,64}$/.test(trimmed)) {
-    throw new InvalidPairingPayloadError("That does not look like an account address.");
+function dropMintState(input) {
+  const none = (state) => ({ state, maxQuantity: 0n });
+  const { drop, wallet, claimed, proof, balance, now } = input;
+  if (!drop) return none("loading");
+  if (drop.startTime !== 0 && now < drop.startTime) return none("upcoming");
+  if (drop.endTime !== 0 && now > drop.endTime) return none("ended");
+  const supplyLeft = drop.maxSupply === 0n ? null : drop.maxSupply - drop.totalMinted;
+  if (supplyLeft !== null && supplyLeft <= 0n) return none("sold-out");
+  if (!wallet) return none("no-wallet");
+  if (BigInt(drop.allowlistRoot) !== 0n) {
+    if (proof === null) return none("no-link");
+    if (!verifyPopProof(drop.allowlistRoot, wallet, proof)) return none("not-on-list");
   }
-  if (BigInt(trimmed) === 0n) {
-    throw new InvalidPairingPayloadError("That does not look like an account address.");
+  if (claimed === null) return none("loading");
+  const walletLeft = drop.maxPerWallet === 0n ? null : drop.maxPerWallet - claimed;
+  if (walletLeft !== null && walletLeft <= 0n) return none("limit-reached");
+  let max = DROP_MAX_CLAIM_QUANTITY;
+  if (supplyLeft !== null && supplyLeft < max) max = supplyLeft;
+  if (walletLeft !== null && walletLeft < max) max = walletLeft;
+  if (drop.price > 0n) {
+    if (balance === null) return none("loading");
+    while (max > 0n && dropMintCost(drop.price, max, input.feeBps).total > balance) max--;
+    if (max === 0n) return none("insufficient-balance");
   }
-  return trimmed;
+  return { state: "ready", maxQuantity: max };
 }
-
-// src/wallet/recovery-key.ts
-var PREFIX = "medialane-recovery:v1:";
-var ADDRESS = /^0x[0-9a-fA-F]{1,64}$/;
-var InvalidRecoveryKeyError = class extends Error {
-  constructor(message = "This is not a valid recovery key.") {
-    super(message);
-    this.name = "InvalidRecoveryKeyError";
-  }
+function dropClaimLinks(origin, collection, list) {
+  const base = `${origin}${chunkMEJ47LC3_cjs.dropHref(collection)}`;
+  return Object.entries(list.proofs).map(([address, proof]) => ({
+    address,
+    url: `${base}${encodePopClaimFragment(proof)}`
+  }));
+}
+function populateCall(abi, contractAddress, entrypoint, args) {
+  return { contractAddress, entrypoint, calldata: new starknet.CallData(abi).compile(entrypoint, args) };
+}
+var addr3 = (address) => chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", address);
+var optionOf = (value) => value != null ? new starknet.CairoOption(starknet.CairoOptionVariant.Some, value) : new starknet.CairoOption(starknet.CairoOptionVariant.None);
+var deployCollectionCall = (abi, factory, p) => populateCall(abi, addr3(factory), "deploy_collection", [p.name, p.symbol, p.baseUri]);
+var popFactoryCalls = {
+  createCollection: (factory, p) => populateCall(POPFactoryABI, factory, "create_collection", [p.name, p.symbol, p.baseUri, p.claimEndTime])
 };
-var canonicalAddress = (address) => `0x${BigInt(address).toString(16).padStart(64, "0")}`;
-function keyPair(privateKey) {
-  try {
-    return chunk2R7XBA34_cjs.starkKeyPairFromPrivateKey(privateKey);
-  } catch {
-    throw new InvalidRecoveryKeyError();
-  }
+var ticketCalls = {
+  deployCollection: (factory, p) => deployCollectionCall(IPTicketCollectionFactoryABI, factory, p),
+  createTicket: (p) => populateCall(IPTicketCollectionABI, addr3(p.collection), "create_ticket", [
+    starknet.cairo.uint256(p.maxSupply),
+    optionOf(p.startTime),
+    optionOf(p.endTime),
+    p.royaltyBps,
+    p.metadataUri
+  ]),
+  mint: (p) => populateCall(IPTicketCollectionABI, addr3(p.collection), "mint", [
+    p.to,
+    starknet.cairo.uint256(p.tokenId),
+    starknet.cairo.uint256(p.amount)
+  ])
+};
+var clubCalls = {
+  deployCollection: (factory, p) => deployCollectionCall(IPClubFactoryABI, factory, p),
+  createMembership: (p) => populateCall(IPClubCollectionABI, addr3(p.collection), "create_membership", [
+    starknet.cairo.uint256(p.maxSupply),
+    optionOf(p.startTime),
+    optionOf(p.endTime),
+    p.royaltyBps,
+    p.metadataUri
+  ]),
+  mint: (p) => populateCall(IPClubCollectionABI, addr3(p.collection), "mint", [
+    p.to,
+    starknet.cairo.uint256(p.tokenId),
+    starknet.cairo.uint256(p.amount)
+  ])
+};
+var sponsorship = (contract, entrypoint, args) => populateCall(IPSponsorshipABI, addr3(contract), entrypoint, args);
+var sponsorshipCalls = {
+  createOffer: (contract, p) => sponsorship(contract, "create_offer", [
+    p.nftContract,
+    starknet.cairo.uint256(p.tokenId),
+    starknet.cairo.uint256(p.minAmount),
+    p.duration,
+    p.paymentToken,
+    p.licenseTermsUri,
+    p.transferable,
+    starknet.cairo.uint256(p.royaltyBps),
+    p.specificSponsor ? new starknet.CairoOption(starknet.CairoOptionVariant.Some, p.specificSponsor) : new starknet.CairoOption(starknet.CairoOptionVariant.None)
+  ]),
+  setOfferOpen: (contract, p) => sponsorship(contract, "set_offer_open", [starknet.cairo.uint256(p.offerId), p.open]),
+  placeBid: (contract, p) => {
+    const amount = starknet.cairo.uint256(p.amount);
+    return [
+      {
+        contractAddress: p.paymentToken,
+        entrypoint: "approve",
+        calldata: [addr3(contract), amount.low.toString(), amount.high.toString()]
+      },
+      sponsorship(contract, "place_bid", [starknet.cairo.uint256(p.offerId), amount])
+    ];
+  },
+  retractBid: (contract, p) => sponsorship(contract, "retract_bid", [starknet.cairo.uint256(p.offerId)]),
+  acceptBid: (contract, p) => sponsorship(contract, "accept_bid", [starknet.cairo.uint256(p.offerId), p.sponsor]),
+  propose: (contract, p) => sponsorship(contract, "propose_sponsorship", [
+    p.nftContract,
+    starknet.cairo.uint256(p.tokenId),
+    starknet.cairo.uint256(p.amount),
+    p.duration,
+    p.validUntil ?? 0,
+    p.paymentToken,
+    p.licenseTermsUri,
+    p.transferable,
+    starknet.cairo.uint256(p.royaltyBps)
+  ]),
+  withdrawProposal: (contract, p) => sponsorship(contract, "withdraw_proposal", [starknet.cairo.uint256(p.proposalId)]),
+  acceptProposal: (contract, p) => sponsorship(contract, "accept_proposal", [starknet.cairo.uint256(p.proposalId)]),
+  rejectProposal: (contract, p) => sponsorship(contract, "reject_proposal", [starknet.cairo.uint256(p.proposalId)])
+};
+var edition = (collection, entrypoint, args) => populateCall(IPCollection1155ABI, addr3(collection), entrypoint, args);
+var editionCalls = {
+  deployCollection: (factory, p) => deployCollectionCall(IPCollection1155FactoryABI, factory, p),
+  mintEdition: (p) => edition(p.collection, "mint_edition", [p.to, BigInt(p.value), p.tokenUri]),
+  batchMintEdition: (p) => edition(p.collection, "batch_mint_edition", [
+    p.to,
+    p.items.map((i) => BigInt(i.value)),
+    p.items.map((i) => i.tokenUri)
+  ]),
+  addSupply: (p) => edition(p.collection, "add_supply", [p.to, BigInt(p.tokenId), BigInt(p.value)]),
+  setDefaultRoyalty: (p) => edition(p.collection, "set_default_royalty", [p.receiver, BigInt(p.feeNumerator)]),
+  setTokenRoyalty: (p) => edition(p.collection, "set_token_royalty", [BigInt(p.tokenId), p.receiver, BigInt(p.feeNumerator)]),
+  setApprovalForAll: (p) => edition(p.collection, "set_approval_for_all", [p.operator, p.approved])
+};
+
+// src/starknet/services/coinLaunchMath.ts
+var COIN_DECIMALS = 18;
+var SUGGESTED_DEFAULT_PRICE = 0.01;
+var MIN_SUPPLY = 1000n;
+var MAX_SUPPLY = 1000000000000n;
+var MAX_FELT_BYTES = 31;
+function byteLen(s) {
+  return new TextEncoder().encode(s).length;
 }
-function encodeRecoveryKey(key) {
-  if (!ADDRESS.test(key.walletAddress) || BigInt(key.walletAddress) === 0n) throw new InvalidRecoveryKeyError();
-  return `${PREFIX}${canonicalAddress(key.walletAddress)}:${keyPair(key.privateKey).privateKeyHex}`;
+function validateName(s) {
+  if (!s.trim()) return "Name is required";
+  if (byteLen(s) > MAX_FELT_BYTES) return `Name must be at most ${MAX_FELT_BYTES} bytes`;
+  return null;
 }
-function parseRecoveryKey(input) {
-  const trimmed = input.trim();
-  if (!trimmed.startsWith(PREFIX)) {
-    const { privateKeyHex, publicKeyHex } = keyPair(trimmed);
-    return { walletAddress: chunk2R7XBA34_cjs.computeAccountAddress(publicKeyHex, 0), privateKey: privateKeyHex };
-  }
-  const parts = trimmed.slice(PREFIX.length).split(":");
-  const [walletAddress, privateKey] = parts;
-  if (parts.length !== 2 || !walletAddress || !privateKey || !ADDRESS.test(walletAddress) || BigInt(walletAddress) === 0n) {
-    throw new InvalidRecoveryKeyError();
-  }
-  return { walletAddress: canonicalAddress(walletAddress), privateKey: keyPair(privateKey).privateKeyHex };
+function validateSymbol(s) {
+  if (!s.trim()) return "Symbol is required";
+  if (byteLen(s) > MAX_FELT_BYTES) return `Symbol must be at most ${MAX_FELT_BYTES} bytes`;
+  return null;
 }
-
-// src/wallet/guardian-status.ts
-function describeGuardianStatus(guardians) {
-  if (guardians.length === 0) return { kind: "none" };
-  return { kind: "active", guardian: guardians[0] };
+function validateSupply(human) {
+  if (!/^\d+$/.test(human.trim())) return "Supply must be a whole number";
+  const v = BigInt(human.trim());
+  if (v < MIN_SUPPLY) return `Supply must be at least ${MIN_SUPPLY.toString()}`;
+  if (v > MAX_SUPPLY) return `Supply must be at most ${MAX_SUPPLY.toString()}`;
+  return null;
 }
-function describeRecoveryAction(escape) {
-  if (escape.escapeType !== "Owner") return "none";
-  if (escape.status === "Ready") return "complete";
-  if (escape.status === "Expired") return "start";
-  return "none";
+function toRaw(human, decimals = COIN_DECIMALS) {
+  return human * 10n ** BigInt(decimals);
+}
+function teamCoinsRaw(supplyRaw, pct) {
+  const bps = BigInt(Math.round(pct * 100));
+  return supplyRaw * bps / 10000n;
 }
-function normalizeWalletAddress(address) {
-  return chunk2R7XBA34_cjs.normalizeAddress("STARKNET", address);
+var PRICE_SCALE = 1000000000000n;
+function buybackQuoteRaw(teamCoinsRawValue, price, quoteDecimals) {
+  const priceScaled = BigInt(Math.round(price * Number(PRICE_SCALE)));
+  return teamCoinsRawValue * priceScaled * 10n ** BigInt(quoteDecimals) / (PRICE_SCALE * 10n ** BigInt(COIN_DECIMALS));
 }
-function isValidStarknetAddress(address) {
-  try {
-    starknet.validateAndParseAddress(address.trim());
-    return true;
-  } catch {
-    return false;
-  }
+function fdvHuman(supplyHuman, price) {
+  return supplyHuman * price;
 }
-var CONTRACT_NOT_FOUND = 20;
-async function isDeployed(provider, address) {
-  try {
-    await provider.getClassHashAt(normalizeWalletAddress(address));
-    return true;
-  } catch (err) {
-    if (err?.code === CONTRACT_NOT_FOUND) return false;
-    throw err;
-  }
+
+// src/starknet/services/creatorCoin.ts
+var VALIDATED_EKUBO_PARAMS = {
+  fee: "0xc49ba5e353f7d00000000000000000",
+  tickSpacing: 5982n,
+  startingPrice: { mag: 4600158n, sign: true },
+  bound: 88719042n
+};
+var TICK_BASE = 1.000001;
+function priceToEkuboParams(quoteDecimals, price = SUGGESTED_DEFAULT_PRICE) {
+  const decAdj = 10 ** (COIN_DECIMALS - quoteDecimals);
+  const rawRatio = price / decAdj;
+  const tickSpacing = Number(VALIDATED_EKUBO_PARAMS.tickSpacing);
+  const rawTick = Math.log(rawRatio) / Math.log(TICK_BASE);
+  const roundedTick = Math.trunc(rawTick / tickSpacing) * tickSpacing;
+  return {
+    fee: VALIDATED_EKUBO_PARAMS.fee,
+    tickSpacing: VALIDATED_EKUBO_PARAMS.tickSpacing,
+    startingPrice: { mag: BigInt(Math.abs(roundedTick)), sign: roundedTick < 0 },
+    bound: VALIDATED_EKUBO_PARAMS.bound
+  };
+}
+function validatePrice(quoteDecimals, price) {
+  if (!isFinite(price) || price <= 0) return "Price must be a positive number";
+  const decAdj = 10 ** (COIN_DECIMALS - quoteDecimals);
+  const rawRatio = price / decAdj;
+  if (!isFinite(rawRatio) || rawRatio <= 0) return "Price must be a positive number";
+  const rawTick = Math.log(rawRatio) / Math.log(TICK_BASE);
+  if (!isFinite(rawTick)) return "Price is outside the supported range";
+  const bound = Number(VALIDATED_EKUBO_PARAMS.bound);
+  if (Math.abs(rawTick) >= bound) return "Price is outside the supported range";
+  return null;
 }
-
-// src/wallet/self-fund-consent.ts
-function createSelfFundConsent(estimateFee) {
-  let handler = null;
+var MAX_TEAM_ALLOCATION_PERCENT = 10;
+var MAX_HOLDERS_AT_LAUNCH = 10;
+function u2563(parts, offset = 0) {
+  return BigInt(parts[offset] ?? "0x0") + (BigInt(parts[offset + 1] ?? "0x0") << 128n);
+}
+async function getCreatorCoinGuarantees(coinAddress, provider) {
+  const call = (entrypoint) => provider.callContract({ contractAddress: coinAddress, entrypoint, calldata: [] });
+  const [launchedRes, allocRes] = await Promise.all([
+    call("is_launched").catch(() => null),
+    call("get_team_allocation").catch(() => null)
+  ]);
+  if (!launchedRes || !allocRes) return null;
+  const [supplyRes, blockRes, liquidityRes] = await Promise.all([
+    call("total_supply"),
+    call("launched_at_block_number").catch(() => null),
+    call("liquidity_type").catch(() => null)
+  ]);
+  const isLaunched = BigInt(launchedRes[0] ?? "0x0") !== 0n;
+  const totalSupply = u2563(supplyRes);
+  const teamAllocation = u2563(allocRes);
+  const teamAllocationPercent = totalSupply > 0n ? Number(teamAllocation * 10000n / totalSupply) / 100 : null;
+  const launchedAtBlock = isLaunched && blockRes?.[0] != null ? Number(BigInt(blockRes[0])) : null;
+  const liquidityPositionId = liquidityRes && BigInt(liquidityRes[0] ?? "0x1") === 0n && liquidityRes[2] != null ? BigInt(liquidityRes[2]).toString() : null;
   return {
-    registerHandler(next) {
-      handler = next;
-    },
-    async request({ address, calls }) {
-      if (!handler) return false;
-      const feeEstimate = address && calls ? estimateFee(address, calls).catch(() => null) : Promise.resolve(null);
-      return handler(feeEstimate);
-    }
+    isLaunched,
+    launchedAtBlock,
+    totalSupplyRaw: totalSupply.toString(),
+    teamAllocationRaw: teamAllocation.toString(),
+    teamAllocationPercent,
+    liquidityPositionId
   };
 }
-function accountFor(provider, address, privateKeyHex) {
-  return new starknet.Account({ provider, address, signer: privateKeyHex, cairoVersion: "1" });
-}
-async function estimateSelfFundedFee(provider, address, calls) {
-  const account = new starknet.Account({ provider, address, signer: "0x1", cairoVersion: "1" });
-  const estimate = await account.estimateInvokeFee(calls);
-  const balanceRaw = await feeTokenBalance(provider, address, estimate.unit).catch(() => null);
-  return { feeRaw: estimate.overall_fee, unit: estimate.unit, balanceRaw };
-}
-async function feeTokenBalance(provider, address, unit) {
-  const token = chunk2R7XBA34_cjs.getTokenBySymbol(unit === "FRI" ? "STRK" : "ETH");
-  if (!token) throw new Error(`No fee token for unit ${unit}`);
-  return erc20Balance(provider, token.address, address);
+var factoryAddress = () => chunkH2NJB3AK_cjs.getStarknetCoordinates("STARKNET").creatorCoinFactory;
+function buildCreateCreatorCoinCall(params) {
+  const salt = params.salt ?? BigInt("0x" + Date.now().toString(16));
+  return populateCall(CreatorCoinFactoryABI, factoryAddress(), "create_creator_coin", [
+    params.owner,
+    params.name,
+    params.symbol,
+    BigInt(params.initialSupply),
+    BigInt(salt)
+  ]);
 }
-function selfFundedExecutor(deps) {
-  return {
-    async execute({ userAddress, privateKeyHex, calls }) {
-      const account = accountFor(deps.provider(), userAddress, privateKeyHex);
-      const { transaction_hash } = await account.execute(calls);
-      return { transactionHash: transaction_hash };
-    }
+function buildLaunchOnEkuboCalls(params) {
+  const ek = params.ekubo;
+  const launchParameters = {
+    creator_coin_address: params.creatorCoin,
+    transfer_restriction_delay: params.transferRestrictionDelay ?? 0,
+    max_percentage_buy_launch: params.maxPercentageBuyLaunch ?? 200,
+    quote_address: params.quoteToken,
+    initial_holders: params.initialHolders,
+    initial_holders_amounts: params.initialHoldersAmounts.map((a) => BigInt(a))
   };
-}
-function sponsoredExecutor(deps) {
-  const fallback = deps.fallback ?? selfFundedExecutor(deps);
-  return {
-    async execute(input) {
-      const { userAddress, privateKeyHex, calls, intentIds } = input;
-      if (!intentIds?.length) {
-        const consented2 = await deps.consent.request({ address: userAddress, calls });
-        if (!consented2) throw new SponsoredCallRejectedError("This action can't be sponsored");
-        return fallback.execute(input);
-      }
-      const result = await executeSponsored(
-        { proxyUrl: deps.proxyUrl, fetchImpl: deps.fetchImpl },
-        {
-          address: userAddress,
-          signTypedData: async (data) => chunk2R7XBA34_cjs.signWithPrivateKey(privateKeyHex, starknet.typedData.getMessageHash(data, userAddress))
-        },
-        { intentIds }
-      );
-      if (result.status === "sponsored") return { transactionHash: result.transactionHash };
-      const consented = await deps.consent.request({ address: userAddress, calls });
-      if (!consented) throw new SponsoredCallRejectedError(result.reason);
-      return fallback.execute(input);
-    }
+  const ekuboParameters = {
+    fee: BigInt(ek.fee),
+    tick_spacing: BigInt(ek.tickSpacing),
+    starting_price: { mag: BigInt(ek.startingPrice.mag), sign: ek.startingPrice.sign },
+    bound: BigInt(ek.bound)
   };
-}
-async function describeFailure(res, fallback) {
-  const body = await res.json().catch(() => null);
-  throw new Error(body?.error || fallback);
-}
-async function deploySponsored(input) {
-  const doFetch = input.fetchImpl ?? fetch;
-  const base = input.proxyUrl.replace(/\/$/, "");
-  const buildRes = await doFetch(`${base}/build`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      ownerPubkey: input.ownerPubKey,
-      ownerAddress: input.ownerAddress,
-      salt: input.salt ?? "0x0"
-    })
-  });
-  if (!buildRes.ok) {
-    await describeFailure(buildRes, "We couldn't prepare your wallet deployment. Please try again.");
-  }
-  const { typedData, deployment, calls } = await buildRes.json();
-  const account = new starknet.Account({
-    provider: input.provider,
-    address: input.ownerAddress,
-    signer: input.privateKeyHex,
-    cairoVersion: "1"
-  });
-  const signature = starknet.stark.signatureToHexArray(await account.signMessage(typedData));
-  const executeRes = await doFetch(`${base}/execute`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ ownerAddress: input.ownerAddress, typedData, signature, deployment, calls })
-  });
-  if (!executeRes.ok) {
-    await describeFailure(executeRes, "We couldn't complete your wallet deployment. Please try again.");
-  }
-  const { transactionHash } = await executeRes.json();
-  return { transactionHash };
-}
-async function deploySelfFunded(input) {
-  const classHash = chunk7EYJC5CB_cjs.getCoordinates("STARKNET").mediaWalletClassHash;
-  if (!classHash) throw new Error("Media Wallet class hash is not configured");
-  const account = new starknet.Account({
-    provider: input.provider,
-    address: input.ownerAddress,
-    signer: input.privateKeyHex,
-    cairoVersion: "1"
-  });
-  const { transaction_hash } = await account.deployAccount({
-    classHash,
-    constructorCalldata: chunk2R7XBA34_cjs.ownerConstructorCalldata(input.ownerPubKey),
-    addressSalt: 0,
-    contractAddress: input.ownerAddress
-  });
-  return { transactionHash: transaction_hash };
-}
-async function waitUntilDeployed(provider, address, timeoutMs = 9e4, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
-  const deadline = Date.now() + timeoutMs;
-  let wait = 1e3;
-  for (; ; ) {
-    if (await isDeployed(provider, address).catch(() => false)) return;
-    if (Date.now() >= deadline) {
-      throw new Error(
-        "Your wallet was submitted but has not appeared on Starknet yet. Please try again in a moment."
-      );
-    }
-    await sleep(wait);
-    wait = Math.min(Math.round(wait * 1.5), 5e3);
+  const calls = [];
+  if (params.quoteFundAmount !== void 0) {
+    const amt = starknet.uint256.bnToUint256(BigInt(params.quoteFundAmount));
+    calls.push({
+      contractAddress: params.quoteToken,
+      entrypoint: "transfer",
+      calldata: [factoryAddress(), amt.low, amt.high]
+    });
   }
+  calls.push(populateCall(CreatorCoinFactoryABI, factoryAddress(), "launch_on_ekubo", [launchParameters, ekuboParameters]));
+  return calls;
 }
-async function deployWallet(deps, wallet) {
-  const sponsored = deps.deploySponsoredImpl ?? deploySponsored;
-  const selfFunded = deps.deploySelfFundedImpl ?? deploySelfFunded;
-  if (deps.deployProxyUrl) {
+var CREATOR_COIN_CREATED_SELECTOR = starknet.hash.getSelectorFromName("CreatorCoinCreated");
+function parseCreatorCoinCreated(receipt) {
+  const factory = chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", chunkH2NJB3AK_cjs.getStarknetCoordinates("STARKNET").creatorCoinFactory);
+  for (const ev of receipt?.events ?? []) {
+    let from;
     try {
-      await sponsored({
-        proxyUrl: deps.deployProxyUrl,
-        provider: deps.provider(),
-        fetchImpl: deps.fetchImpl,
-        ...wallet
-      });
-    } catch (sponsoredErr) {
-      try {
-        await selfFunded({ provider: deps.provider(), ...wallet });
-      } catch (selfFundedErr) {
-        const sponsored2 = sponsoredErr instanceof Error ? sponsoredErr.message : String(sponsoredErr);
-        const selfFunded2 = selfFundedErr instanceof Error ? selfFundedErr.message : String(selfFundedErr);
-        throw new Error(`Sponsored deploy failed: ${sponsored2}. Self-funded fallback failed: ${selfFunded2}`);
-      }
+      from = chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", ev.from_address ?? "");
+    } catch {
+      continue;
     }
-  } else {
-    await selfFunded({ provider: deps.provider(), ...wallet });
-  }
-  await (deps.waitUntilDeployedImpl ?? waitUntilDeployed)(deps.provider(), wallet.ownerAddress);
-}
-async function completeDeployment(deps, onStep, options = {}) {
-  let sealed = options.forceNew ? null : deps.store.load();
-  if (sealed && await (deps.isDeployedImpl ?? isDeployed)(deps.provider(), sealed.address).catch(() => false)) {
-    sealed = null;
-  }
-  let privateKeyHex;
-  if (!sealed) {
-    onStep("creating-passkey");
-    const created = await deps.passkey.createOwnerKey();
-    sealed = created.sealed;
-    privateKeyHex = created.privateKeyHex;
-    deps.store.save(sealed);
-  } else {
-    privateKeyHex = await deps.passkey.unlockOwnerKey(sealed);
+    if (from !== factory) continue;
+    const k0 = ev.keys?.[0];
+    if (!k0 || chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", k0) !== chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", CREATOR_COIN_CREATED_SELECTOR)) continue;
+    const data = ev.data ?? [];
+    if (data.length < 1) continue;
+    return chunk3HPMEDYH_cjs.normalizeAddress("STARKNET", data[data.length - 1]);
   }
-  onStep("deploying");
-  await deployWallet(deps, { ownerAddress: sealed.address, ownerPubKey: sealed.ownerPubKey, privateKeyHex });
-  deps.store.notifyChange();
-  return { sealed };
-}
-function createDeploymentCoordinator(execute) {
-  let inFlight = null;
-  let currentStep = null;
-  const listeners = /* @__PURE__ */ new Set();
-  return {
-    run(onStep, options = {}) {
-      if (inFlight) {
-        if (options.forceNew) {
-          return Promise.reject(new Error("A wallet setup is already in progress."));
-        }
-        if (currentStep) onStep(currentStep);
-        listeners.add(onStep);
-        return inFlight.finally(() => listeners.delete(onStep));
-      }
-      listeners.add(onStep);
-      let started;
-      try {
-        started = execute((step) => {
-          currentStep = step;
-          for (const listener of listeners) listener(step);
-        }, options);
-      } catch (err) {
-        listeners.clear();
-        return Promise.reject(err);
-      }
-      const run = started.finally(() => {
-        inFlight = null;
-        currentStep = null;
-        listeners.clear();
-      });
-      inFlight = run;
-      return run;
-    },
-    isDeploying: () => inFlight !== null
-  };
-}
-
-// src/wallet/client.ts
-function describeDevices(owners, thisDevicePubkey) {
-  const mine = computeOwnerGuid(thisDevicePubkey);
-  return owners.map((owner) => ({
-    guid: owner.guid,
-    type: owner.type,
-    isThisDevice: BigInt(owner.guid) === BigInt(mine)
-  }));
-}
-function canRemoveDevice(devices, guid) {
-  if (devices.length <= 1) return false;
-  return devices.some((device) => BigInt(device.guid) === BigInt(guid));
+  throw new Error("Coin deployed but the coin address could not be read from the receipt");
 }
-function createMediaWallet(config) {
-  const ttl = config.unlockTtlMs ?? 2e4;
-  const deployments = createDeploymentCoordinator((onStep, options) => {
-    const deps = {
-      store: config.store,
-      passkey: config.passkey,
-      provider: config.provider,
-      deployProxyUrl: config.deployProxyUrl,
-      fetchImpl: config.fetchImpl
-    };
-    return completeDeployment(deps, onStep, options);
-  });
-  const unlockCache = /* @__PURE__ */ new Map();
-  const lock = (address) => {
-    const entry = unlockCache.get(address);
-    if (!entry) return;
-    clearTimeout(entry.timer);
-    unlockCache.delete(address);
-  };
-  const unlockOnce = (sealed) => {
-    const existing = unlockCache.get(sealed.address);
-    if (existing) return existing.promise;
-    const promise = config.passkey.unlockOwnerKey(sealed).catch((err) => {
-      lock(sealed.address);
-      throw err;
-    });
-    const timer = setTimeout(() => lock(sealed.address), ttl);
-    unlockCache.set(sealed.address, { promise, timer });
-    return promise;
-  };
-  const run = async (sealed, calls, userAddress, intentIds) => {
-    const privateKeyHex = await unlockOnce(sealed);
-    return config.executor.execute({
-      userAddress: userAddress ?? sealed.address,
-      privateKeyHex,
-      calls,
-      intentIds
-    });
-  };
-  const walletIntents = config.walletIntents ?? (async (params) => {
-    if (!config.backendUrl) throw new Error("This wallet has no backend url configured");
-    const created = await new chunk2R7XBA34_cjs.ApiClient(config.backendUrl).createWalletManageIntent(params);
-    return created.data;
+async function isCreatorCoin(provider, address) {
+  const res = await provider.callContract({
+    contractAddress: factoryAddress(),
+    entrypoint: "is_creator_coin",
+    calldata: [address]
   });
-  const manage = async (sealed, params) => {
-    const intent = await walletIntents(params);
-    const { transactionHash } = await run(sealed, intent.calls, params.owner, [intent.id]);
-    return transactionHash;
-  };
-  return {
-    store: config.store,
-    passkey: config.passkey,
-    lock,
-    signerFor(sealed) {
-      return {
-        address: sealed.address,
-        signTypedData: async (data) => {
-          const privateKeyHex = await unlockOnce(sealed);
-          return chunk2R7XBA34_cjs.signWithPrivateKey(privateKeyHex, starknet.typedData.getMessageHash(data, sealed.address));
-        },
-        execute: async (calls, opts) => {
-          const { transactionHash } = await run(sealed, calls, void 0, opts?.intentIds);
-          return { txHash: transactionHash };
-        }
-      };
-    },
-    run,
-    getGuardians: (address) => getGuardians(config.provider(), address),
-    getEscape: (address) => getEscape(config.provider(), address),
-    getEscapeSecurityPeriod: (address) => getEscapeSecurityPeriod(config.provider(), address),
-    getOwners: (address) => getOwners(config.provider(), address),
-    async isOwnerOf(accountAddress, devicePubkey) {
-      const owners = await getOwners(config.provider(), accountAddress);
-      const guid = BigInt(computeOwnerGuid(devicePubkey));
-      return owners.some((owner) => BigInt(owner.guid) === guid);
-    },
-    setFirstGuardian: (sealed, guardianPubkey) => manage(sealed, { owner: sealed.address, action: "set_first_guardian", pubkey: guardianPubkey }),
-    triggerEscapeOwner: (guardianSealed, targetAddress, newOwnerPubkey) => manage(guardianSealed, { owner: normalizeWalletAddress(targetAddress), action: "trigger_escape", newOwnerPubkey }),
-    completeEscapeOwner: (guardianSealed, targetAddress) => manage(guardianSealed, { owner: normalizeWalletAddress(targetAddress), action: "complete_escape" }),
-    cancelEscape: (sealed) => manage(sealed, { owner: sealed.address, action: "cancel_escape" }),
-    addDevice: (sealed, devicePubkey) => manage(sealed, { owner: sealed.address, action: "add_owner", pubkey: devicePubkey }),
-    removeDevice: (sealed, ownerGuid) => manage(sealed, { owner: sealed.address, action: "remove_owner", ownerGuid }),
-    completeDeployment: (onStep, options) => deployments.run(onStep, options),
-    isDeploying: () => deployments.isDeploying()
-  };
+  return BigInt(res[0] ?? "0x0") === 1n;
 }
-
-// src/session/session-wallet.ts
-async function claimSessionWallet(api, walletAddress, deps) {
-  const saved = deps.loadOwner();
-  const resuming = saved !== null && normalizeWalletAddress(saved.address) === normalizeWalletAddress(walletAddress);
-  const sealed = resuming ? saved : { ...(await deps.createOwnerKey()).sealed, address: walletAddress };
-  if (!resuming) deps.saveOwner(sealed);
-  const { removeOwnerGuid } = await api.setupWalletKey({ newOwnerPubkey: sealed.ownerPubKey });
-  if (removeOwnerGuid) await deps.removeOwner(sealed, removeOwnerGuid);
+function encodeByteArray(str) {
+  const bytes = new TextEncoder().encode(str);
+  const fullChunks = [];
+  let i = 0;
+  while (i + 31 <= bytes.length) {
+    let val = 0n;
+    for (const b of bytes.slice(i, i + 31)) {
+      val = val << 8n | BigInt(b);
+    }
+    fullChunks.push(starknet.num.toHex(val));
+    i += 31;
+  }
+  const remaining = bytes.slice(i);
+  let pendingVal = 0n;
+  for (const b of remaining) {
+    pendingVal = pendingVal << 8n | BigInt(b);
+  }
+  return [
+    fullChunks.length.toString(),
+    ...fullChunks,
+    starknet.num.toHex(pendingVal),
+    remaining.length.toString()
+  ];
 }
 
-Object.defineProperty(exports, "DeviceKeyMissingError", {
+Object.defineProperty(exports, "InvalidPairingPayloadError", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.InvalidPairingPayloadError; }
+});
+Object.defineProperty(exports, "InvalidRecoveryKeyError", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.DeviceKeyMissingError; }
+  get: function () { return chunkZLMIHQWM_cjs.InvalidRecoveryKeyError; }
 });
 Object.defineProperty(exports, "InvalidStarkPrivateKeyError", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.InvalidStarkPrivateKeyError; }
+  get: function () { return chunkZLMIHQWM_cjs.InvalidStarkPrivateKeyError; }
 });
-Object.defineProperty(exports, "PasskeyCancelledError", {
+Object.defineProperty(exports, "SponsoredCallRejectedError", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.PasskeyCancelledError; }
+  get: function () { return chunkZLMIHQWM_cjs.SponsoredCallRejectedError; }
 });
-Object.defineProperty(exports, "PasskeyUnsupportedError", {
+Object.defineProperty(exports, "accountFor", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.PasskeyUnsupportedError; }
+  get: function () { return chunkZLMIHQWM_cjs.accountFor; }
 });
-Object.defineProperty(exports, "UserFacingError", {
+Object.defineProperty(exports, "allowsFallbackFunding", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.allowsFallbackFunding; }
+});
+Object.defineProperty(exports, "buildAddOwnerCall", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.UserFacingError; }
+  get: function () { return chunkZLMIHQWM_cjs.buildAddOwnerCall; }
+});
+Object.defineProperty(exports, "buildCancelEscapeCall", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.buildCancelEscapeCall; }
+});
+Object.defineProperty(exports, "buildCompleteEscapeOwnerCall", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.buildCompleteEscapeOwnerCall; }
+});
+Object.defineProperty(exports, "buildDeployAccountParams", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.buildDeployAccountParams; }
+});
+Object.defineProperty(exports, "buildRemoveOwnerByGuidCall", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.buildRemoveOwnerByGuidCall; }
+});
+Object.defineProperty(exports, "buildRemoveOwnerCall", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.buildRemoveOwnerCall; }
+});
+Object.defineProperty(exports, "buildSetFirstGuardianCall", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.buildSetFirstGuardianCall; }
+});
+Object.defineProperty(exports, "buildTriggerEscapeOwnerCall", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.buildTriggerEscapeOwnerCall; }
+});
+Object.defineProperty(exports, "canRemoveDevice", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.canRemoveDevice; }
+});
+Object.defineProperty(exports, "claimSessionWallet", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.claimSessionWallet; }
+});
+Object.defineProperty(exports, "completeDeployment", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.completeDeployment; }
 });
 Object.defineProperty(exports, "computeAccountAddress", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.computeAccountAddress; }
+  get: function () { return chunkZLMIHQWM_cjs.computeAccountAddress; }
+});
+Object.defineProperty(exports, "computeOwnerGuid", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.computeOwnerGuid; }
+});
+Object.defineProperty(exports, "createDeploymentCoordinator", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.createDeploymentCoordinator; }
+});
+Object.defineProperty(exports, "createMediaWallet", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.createMediaWallet; }
+});
+Object.defineProperty(exports, "createOwnerStore", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.createOwnerStore; }
 });
 Object.defineProperty(exports, "createPasskeyOwner", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.createPasskeyOwner; }
+  get: function () { return chunkZLMIHQWM_cjs.createPasskeyOwner; }
+});
+Object.defineProperty(exports, "createSelfFundConsent", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.createSelfFundConsent; }
+});
+Object.defineProperty(exports, "decodeEscapeAndStatus", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.decodeEscapeAndStatus; }
+});
+Object.defineProperty(exports, "decodeGuardiansInfo", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.decodeGuardiansInfo; }
+});
+Object.defineProperty(exports, "deploySelfFunded", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.deploySelfFunded; }
+});
+Object.defineProperty(exports, "deploySponsored", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.deploySponsored; }
 });
 Object.defineProperty(exports, "deriveAesKey", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.deriveAesKey; }
+  get: function () { return chunkZLMIHQWM_cjs.deriveAesKey; }
+});
+Object.defineProperty(exports, "deriveOwnerKeyPair", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.deriveOwnerKeyPair; }
+});
+Object.defineProperty(exports, "describeDevices", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.describeDevices; }
+});
+Object.defineProperty(exports, "describeGuardianStatus", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.describeGuardianStatus; }
+});
+Object.defineProperty(exports, "describeRecoveryAction", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.describeRecoveryAction; }
+});
+Object.defineProperty(exports, "encodePairingPayload", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.encodePairingPayload; }
+});
+Object.defineProperty(exports, "encodeRecoveryKey", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.encodeRecoveryKey; }
+});
+Object.defineProperty(exports, "erc20Balance", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.erc20Balance; }
+});
+Object.defineProperty(exports, "estimateSelfFundedFee", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.estimateSelfFundedFee; }
+});
+Object.defineProperty(exports, "executeSponsored", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.executeSponsored; }
 });
 Object.defineProperty(exports, "generateStarkKeyPair", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.generateStarkKeyPair; }
+  get: function () { return chunkZLMIHQWM_cjs.generateStarkKeyPair; }
+});
+Object.defineProperty(exports, "getEscape", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.getEscape; }
+});
+Object.defineProperty(exports, "getEscapeSecurityPeriod", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.getEscapeSecurityPeriod; }
+});
+Object.defineProperty(exports, "getGuardians", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.getGuardians; }
+});
+Object.defineProperty(exports, "getOwners", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.getOwners; }
 });
 Object.defineProperty(exports, "indexedDbDeviceKeys", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.indexedDbDeviceKeys; }
+  get: function () { return chunkZLMIHQWM_cjs.indexedDbDeviceKeys; }
+});
+Object.defineProperty(exports, "isDeployed", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.isDeployed; }
+});
+Object.defineProperty(exports, "isValidStarknetAddress", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.isValidStarknetAddress; }
+});
+Object.defineProperty(exports, "normalizeWalletAddress", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.normalizeWalletAddress; }
 });
 Object.defineProperty(exports, "ownerConstructorCalldata", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.ownerConstructorCalldata; }
+  get: function () { return chunkZLMIHQWM_cjs.ownerConstructorCalldata; }
+});
+Object.defineProperty(exports, "parseAccountAddress", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.parseAccountAddress; }
+});
+Object.defineProperty(exports, "parsePairingPayload", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.parsePairingPayload; }
+});
+Object.defineProperty(exports, "parseRecoveryKey", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.parseRecoveryKey; }
 });
 Object.defineProperty(exports, "sealPrivateKey", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.sealPrivateKey; }
+  get: function () { return chunkZLMIHQWM_cjs.sealPrivateKey; }
+});
+Object.defineProperty(exports, "selfFundedExecutor", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.selfFundedExecutor; }
 });
 Object.defineProperty(exports, "signWithPrivateKey", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.signWithPrivateKey; }
+  get: function () { return chunkZLMIHQWM_cjs.signWithPrivateKey; }
+});
+Object.defineProperty(exports, "sponsoredExecutor", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.sponsoredExecutor; }
 });
 Object.defineProperty(exports, "starkKeyPairFromPrivateKey", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.starkKeyPairFromPrivateKey; }
+  get: function () { return chunkZLMIHQWM_cjs.starkKeyPairFromPrivateKey; }
 });
 Object.defineProperty(exports, "unsealPrivateKey", {
   enumerable: true,
-  get: function () { return chunk2R7XBA34_cjs.unsealPrivateKey; }
+  get: function () { return chunkZLMIHQWM_cjs.unsealPrivateKey; }
+});
+Object.defineProperty(exports, "waitUntilDeployed", {
+  enumerable: true,
+  get: function () { return chunkZLMIHQWM_cjs.waitUntilDeployed; }
+});
+Object.defineProperty(exports, "DeviceKeyMissingError", {
+  enumerable: true,
+  get: function () { return chunk3HPMEDYH_cjs.DeviceKeyMissingError; }
+});
+Object.defineProperty(exports, "MedialaneError", {
+  enumerable: true,
+  get: function () { return chunk3HPMEDYH_cjs.MedialaneError; }
+});
+Object.defineProperty(exports, "PasskeyCancelledError", {
+  enumerable: true,
+  get: function () { return chunk3HPMEDYH_cjs.PasskeyCancelledError; }
+});
+Object.defineProperty(exports, "PasskeyUnsupportedError", {
+  enumerable: true,
+  get: function () { return chunk3HPMEDYH_cjs.PasskeyUnsupportedError; }
+});
+Object.defineProperty(exports, "UserFacingError", {
+  enumerable: true,
+  get: function () { return chunk3HPMEDYH_cjs.UserFacingError; }
 });
 exports.COIN_MAX_SUPPLY = MAX_SUPPLY;
 exports.COIN_MIN_SUPPLY = MIN_SUPPLY;
-exports.ClubService = ClubService;
 exports.CreatorCoinFactoryABI = CreatorCoinFactoryABI;
-exports.CreatorCoinService = CreatorCoinService;
 exports.DROP_MAX_CLAIM_QUANTITY = DROP_MAX_CLAIM_QUANTITY;
 exports.DropCollectionABI = DropCollectionABI;
 exports.DropFactoryABI = DropFactoryABI;
-exports.DropService = DropService;
-exports.ERC1155CollectionService = ERC1155CollectionService;
 exports.FundingTransferNotSentError = FundingTransferNotSentError;
 exports.IPClubCollectionABI = IPClubCollectionABI;
 exports.IPClubFactoryABI = IPClubFactoryABI;
@@ -12769,122 +11981,79 @@ exports.IPNftABI = IPNftABI;
 exports.IPSponsorshipABI = IPSponsorshipABI;
 exports.IPTicketCollectionABI = IPTicketCollectionABI;
 exports.IPTicketCollectionFactoryABI = IPTicketCollectionFactoryABI;
-exports.InvalidPairingPayloadError = InvalidPairingPayloadError;
-exports.InvalidRecoveryKeyError = InvalidRecoveryKeyError;
 exports.MAX_HOLDERS_AT_LAUNCH = MAX_HOLDERS_AT_LAUNCH;
 exports.MAX_TEAM_ALLOCATION_PERCENT = MAX_TEAM_ALLOCATION_PERCENT;
 exports.Medialane1155ABI = Medialane1155ABI;
 exports.MedialaneClient = MedialaneClient;
-exports.MedialaneError = MedialaneError;
 exports.POPCollectionABI = POPCollectionABI;
 exports.POPFactoryABI = POPFactoryABI;
-exports.PopService = PopService;
 exports.SUGGESTED_DEFAULT_PRICE = SUGGESTED_DEFAULT_PRICE;
-exports.SponsoredCallRejectedError = SponsoredCallRejectedError;
-exports.SponsorshipService = SponsorshipService;
 exports.StarknetVenue = StarknetVenue;
-exports.TicketService = TicketService;
 exports.VALIDATED_EKUBO_PARAMS = VALIDATED_EKUBO_PARAMS;
-exports.accountFor = accountFor;
-exports.allowsFallbackFunding = allowsFallbackFunding;
 exports.apiKeyConfirmationTypedData = apiKeyConfirmationTypedData;
 exports.assertTransactionSucceeded = assertTransactionSucceeded;
 exports.build1155CancellationTypedData = build1155CancellationTypedData;
 exports.build1155OrderTypedData = build1155OrderTypedData;
-exports.buildAddOwnerCall = buildAddOwnerCall;
-exports.buildCancelEscapeCall = buildCancelEscapeCall;
 exports.buildCancellationTypedData = buildCancellationTypedData;
-exports.buildCompleteEscapeOwnerCall = buildCompleteEscapeOwnerCall;
 exports.buildCreateCreatorCoinCall = buildCreateCreatorCoinCall;
-exports.buildDeployAccountParams = buildDeployAccountParams;
+exports.buildDropClaimCalls = buildDropClaimCalls;
 exports.buildFeeCall = buildFeeCall;
 exports.buildFundingTransferCall = buildFundingTransferCall;
 exports.buildLaunchOnEkuboCalls = buildLaunchOnEkuboCalls;
 exports.buildOrderTypedData = buildOrderTypedData;
 exports.buildPopAllowlist = buildPopAllowlist;
-exports.buildRemoveOwnerByGuidCall = buildRemoveOwnerByGuidCall;
-exports.buildRemoveOwnerCall = buildRemoveOwnerCall;
-exports.buildSetFirstGuardianCall = buildSetFirstGuardianCall;
-exports.buildTriggerEscapeOwnerCall = buildTriggerEscapeOwnerCall;
 exports.buybackQuoteRaw = buybackQuoteRaw;
-exports.canRemoveDevice = canRemoveDevice;
-exports.claimSessionWallet = claimSessionWallet;
+exports.clubCalls = clubCalls;
 exports.coinToRaw = toRaw;
-exports.completeDeployment = completeDeployment;
-exports.computeOwnerGuid = computeOwnerGuid;
 exports.confirmIntentBestEffort = confirmIntentBestEffort;
 exports.createChainProvider = createChainProvider;
-exports.createDeploymentCoordinator = createDeploymentCoordinator;
-exports.createMediaWallet = createMediaWallet;
-exports.createOwnerStore = createOwnerStore;
-exports.createSelfFundConsent = createSelfFundConsent;
-exports.decodeEscapeAndStatus = decodeEscapeAndStatus;
-exports.decodeGuardiansInfo = decodeGuardiansInfo;
 exports.decodePopClaimFragment = decodePopClaimFragment;
-exports.deploySelfFunded = deploySelfFunded;
-exports.deploySponsored = deploySponsored;
 exports.deployedCollectionFromReceipt = deployedCollectionFromReceipt;
-exports.deriveOwnerKeyPair = deriveOwnerKeyPair;
-exports.describeDevices = describeDevices;
-exports.describeGuardianStatus = describeGuardianStatus;
-exports.describeRecoveryAction = describeRecoveryAction;
 exports.dropCalls = dropCalls;
 exports.dropClaimLinks = dropClaimLinks;
 exports.dropClaimedBy = dropClaimedBy;
 exports.dropMintCost = dropMintCost;
 exports.dropMintState = dropMintState;
+exports.editionCalls = editionCalls;
 exports.encodeByteArray = encodeByteArray;
-exports.encodePairingPayload = encodePairingPayload;
 exports.encodePopClaimFragment = encodePopClaimFragment;
-exports.encodeRecoveryKey = encodeRecoveryKey;
-exports.erc20Balance = erc20Balance;
-exports.estimateSelfFundedFee = estimateSelfFundedFee;
 exports.executeIntent = executeIntent;
 exports.executeIntents = executeIntents;
-exports.executeSponsored = executeSponsored;
 exports.fdvHuman = fdvHuman;
 exports.feeAmount = feeAmount;
 exports.feeBps = feeBps;
 exports.fundWithChainTransfer = fundWithChainTransfer;
 exports.fundingApiFor = fundingApiFor;
 exports.getCreatorCoinGuarantees = getCreatorCoinGuarantees;
-exports.getEscape = getEscape;
-exports.getEscapeSecurityPeriod = getEscapeSecurityPeriod;
-exports.getGuardians = getGuardians;
-exports.getOwners = getOwners;
 exports.getSiwsStorageKey = getSiwsStorageKey;
 exports.getStoredSiwsToken = getStoredSiwsToken;
-exports.isDeployed = isDeployed;
+exports.isCreatorCoin = isCreatorCoin;
 exports.isSiwsTokenValid = isSiwsTokenValid;
-exports.isValidStarknetAddress = isValidStarknetAddress;
 exports.mintedTokenIdFromReceipt = mintedTokenIdFromReceipt;
 exports.normalizeSiwsSignature = normalizeSiwsSignature;
-exports.normalizeWalletAddress = normalizeWalletAddress;
-exports.parseAccountAddress = parseAccountAddress;
 exports.parseCreatorCoinCreated = parseCreatorCoinCreated;
-exports.parsePairingPayload = parsePairingPayload;
-exports.parseRecoveryKey = parseRecoveryKey;
 exports.popCalls = popCalls;
 exports.popClaimInfo = popClaimInfo;
 exports.popClaimLinks = popClaimLinks;
 exports.popClaimLinksCsv = popClaimLinksCsv;
 exports.popClaimState = popClaimState;
+exports.popFactoryCalls = popFactoryCalls;
 exports.popHasClaimed = popHasClaimed;
+exports.populateCall = populateCall;
 exports.priceToEkuboParams = priceToEkuboParams;
 exports.readDrop = readDrop;
 exports.requestSiwsToken = requestSiwsToken;
-exports.selfFundedExecutor = selfFundedExecutor;
 exports.signInWithWallet = signInWithWallet;
-exports.sponsoredExecutor = sponsoredExecutor;
+exports.sponsorshipCalls = sponsorshipCalls;
 exports.storeSiwsToken = storeSiwsToken;
 exports.syncTransactionBestEffort = syncTransactionBestEffort;
 exports.teamCoinsRaw = teamCoinsRaw;
+exports.ticketCalls = ticketCalls;
 exports.toDropContractTerms = toContractTerms;
 exports.validateCoinName = validateName;
 exports.validateCoinSupply = validateSupply;
 exports.validateCoinSymbol = validateSymbol;
 exports.validatePrice = validatePrice;
 exports.verifyPopProof = verifyPopProof;
-exports.waitUntilDeployed = waitUntilDeployed;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map