@medialane/sdk 0.197.0 → 0.199.0

package/dist/starknet/index.js

@@ -1,44 +1,44 @@
-import { normalizeAddress, collectionHref, dropHref, resolveConfig, ApiClient, UserFacingError, getService, STARKNET_MEDIAWALLET_CLASS_HASH, computeAccountAddress, ownerConstructorCalldata, getTokenBySymbol, signWithPrivateKey, stringifyBigInts, SUPPORTED_TOKENS, MedialaneApiError, starkKeyPairFromPrivateKey } from '../chunk-6WVUUBFI.js';
-export { DeviceKeyMissingError, InvalidStarkPrivateKeyError, PasskeyCancelledError, PasskeyUnsupportedError, UserFacingError, computeAccountAddress, createPasskeyOwner, deriveAesKey, generateStarkKeyPair, indexedDbDeviceKeys, ownerConstructorCalldata, sealPrivateKey, signWithPrivateKey, starkKeyPairFromPrivateKey, unsealPrivateKey } from '../chunk-6WVUUBFI.js';
-import { getStarknetCoordinates, getCoordinates } from '../chunk-3ME5YKTW.js';
+import { resolveConfig, getService, collectionHref, dropHref, stringifyBigInts } from '../chunk-GV4A2WNO.js';
+export { InvalidPairingPayloadError, InvalidRecoveryKeyError, InvalidStarkPrivateKeyError, SponsoredCallRejectedError, accountFor, allowsFallbackFunding, buildAddOwnerCall, buildCancelEscapeCall, buildCompleteEscapeOwnerCall, buildDeployAccountParams, buildRemoveOwnerByGuidCall, buildRemoveOwnerCall, buildSetFirstGuardianCall, buildTriggerEscapeOwnerCall, canRemoveDevice, claimSessionWallet, completeDeployment, computeAccountAddress, computeOwnerGuid, createDeploymentCoordinator, createMediaWallet, createOwnerStore, createPasskeyOwner, createSelfFundConsent, decodeEscapeAndStatus, decodeGuardiansInfo, deploySelfFunded, deploySponsored, deriveAesKey, deriveOwnerKeyPair, describeDevices, describeGuardianStatus, describeRecoveryAction, encodePairingPayload, encodeRecoveryKey, erc20Balance, estimateSelfFundedFee, executeSponsored, generateStarkKeyPair, getEscape, getEscapeSecurityPeriod, getGuardians, getOwners, indexedDbDeviceKeys, isDeployed, isValidStarknetAddress, normalizeWalletAddress, ownerConstructorCalldata, parseAccountAddress, parsePairingPayload, parseRecoveryKey, sealPrivateKey, selfFundedExecutor, signWithPrivateKey, sponsoredExecutor, starkKeyPairFromPrivateKey, unsealPrivateKey, waitUntilDeployed } from '../chunk-GIBIHGSV.js';
+import { ApiClient, UserFacingError, normalizeAddress, SUPPORTED_TOKENS, MedialaneError, MedialaneApiError } from '../chunk-KGAGWULG.js';
+export { DeviceKeyMissingError, MedialaneError, PasskeyCancelledError, PasskeyUnsupportedError, UserFacingError } from '../chunk-KGAGWULG.js';
+import { getStarknetCoordinates } from '../chunk-5KY6P434.js';
+import '../chunk-WRBXQPRL.js';
 import '../chunk-PZ5AY32C.js';
-import { CallData, hash, cairo, uint256, CairoOption, CairoOptionVariant, RpcProvider, num, ec, validateAndParseAddress, Account, typedData, stark, byteArray, Contract, TypedDataRevision, constants, shortString } from 'starknet';
-import { extract, expand } from '@noble/hashes/hkdf.js';
-import { sha256 } from '@noble/hashes/sha2.js';
+import { hash, CallData, RpcProvider, cairo, num, CairoOption, CairoOptionVariant, uint256, TypedDataRevision, Contract, byteArray, constants, shortString } from 'starknet';
 
-// 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 = Contract;
-  return C.length === 1 ? new Contract({ abi, address, providerOrAccount }) : new Contract(
-    abi,
-    address,
-    providerOrAccount
-  );
+function createChainProvider(backendUrl, apiKey) {
+  return new 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 = resolveConfig(rawConfig);
+    const config = this.config;
+    this.api = config.backendUrl ? new ApiClient({ baseUrl: config.backendUrl, apiKey: config.apiKey, retry: config.retryOptions, chain: config.chain }) : new ApiClient({
+      baseUrl: "https://medialane-sdk-no-backend.invalid",
+      apiKey: config.apiKey,
+      fetch: () => {
+        throw new Error(`${NO_BACKEND} .api`);
+      }
+    });
   }
-  return constants.StarknetChainId.SN_MAIN;
-}
-function resolveToken(currency) {
-  const token = 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 = [
@@ -10376,975 +10376,148 @@ var IPGenesisABI = [
     ]
   }
 ];
-var FRAGMENT_KEY = "pop-proof";
-var toHex = (x) => "0x" + x.toString(16).padStart(64, "0");
-var poseidon = (xs) => BigInt(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 = Contract;
+  return C.length === 1 ? new Contract({ abi, address, providerOrAccount }) : new 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 constants.StarknetChainId.SN_MAIN;
+}
+function resolveToken(currency) {
+  const token = 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;
+}
+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 {
-    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;
-    }
+    name: "Medialane",
+    version: DOMAIN_VERSION[standard],
+    chainId,
+    revision: TypedDataRevision.ACTIVE
   };
 }
-function buildPopAllowlist(addresses) {
-  const unique = [...new Set(addresses.map((a) => 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 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 encodePopClaimFragment(proof) {
-  return `#${FRAGMENT_KEY}=${proof.join(",")}`;
+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 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 buildCancellationTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc721", chainId),
+    primaryType: "OrderCancellation",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderCancellation: ORDER_CANCELLATION
+    },
+    message
+  };
 }
-
-// src/starknet/pop-claim.ts
-function popClaimLinks(origin, collection, list) {
-  const base = `${origin}${collectionHref("STARKNET", collection)}`;
-  return Object.entries(list.proofs).map(([address, proof]) => ({
-    address,
-    url: `${base}${encodePopClaimFragment(proof)}`
-  }));
+function build1155CancellationTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc1155", chainId),
+    primaryType: "OrderCancellation",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderCancellation: ORDER_CANCELLATION
+    },
+    message
+  };
 }
-function popClaimLinksCsv(links) {
-  return ["address,claim_link", ...links.map((l) => `${l.address},${l.url}`)].join("\n");
+function feeBps(surface, cfg) {
+  if (!cfg.enabled || !cfg.fundAddress) return 0;
+  return surface === "marketplace" ? cfg.marketplaceBps : surface === "launchpad" ? cfg.launchpadBps : cfg.sponsorshipBps;
 }
-async function popClaimInfo(provider, collection) {
-  const contractAddress = 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 feeAmount(grossAmount, bps) {
+  return bps <= 0 ? 0n : grossAmount * BigInt(bps) / 10000n;
 }
-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";
-}
-var addr = (a) => normalizeAddress("STARKNET", a);
-var byteArrayFelts = (s) => CallData.compile([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 = 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 = 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: normalizeAddress("STARKNET", collection),
-    entrypoint: "has_claimed",
-    calldata: [normalizeAddress("STARKNET", address)]
-  });
-  return BigInt(res[0] ?? "0x0") !== 0n;
-}
-function feeBps(surface, cfg) {
-  if (!cfg.enabled || !cfg.fundAddress) return 0;
-  return surface === "marketplace" ? cfg.marketplaceBps : surface === "launchpad" ? cfg.launchpadBps : cfg.sponsorshipBps;
-}
-function feeAmount(grossAmount, bps) {
-  return bps <= 0 ? 0n : grossAmount * BigInt(bps) / 10000n;
-}
-function buildFeeCall(p, cfg) {
-  const fee = feeAmount(p.grossAmount, feeBps(p.surface, cfg));
-  if (fee <= 0n) return null;
-  const u = cairo.uint256(fee.toString());
-  return {
-    contractAddress: p.token,
-    entrypoint: "transfer",
-    calldata: [cfg.fundAddress, u.low.toString(), u.high.toString()]
-  };
-}
-var DROP_MAX_CLAIM_QUANTITY = 50n;
-var addr2 = (a) => normalizeAddress("STARKNET", a);
-var factoryData = new CallData(DropFactoryABI);
-var collectionData = new CallData(DropCollectionABI);
-function toContractTerms(t) {
-  const price = BigInt(t.price);
-  return {
-    start_time: t.startTime,
-    end_time: t.endTime,
-    price: cairo.uint256(price),
-    payment_token: price === 0n ? "0x0" : addr2(t.paymentToken),
-    max_per_wallet: 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: 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: CallData.compile([addr2(collection), cairo.uint256(total)])
-      });
-    }
-    calls.push({
-      contractAddress: addr2(collection),
-      entrypoint: "claim",
-      calldata: collectionData.compile("claim", { quantity: 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: 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) => 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}${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 = 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 ?? getStarknetCoordinates(config.chain).collection1155;
-  }
-  _factory(account) {
-    return newContract(
-      IPCollection1155FactoryABI,
-      normalizeAddress("STARKNET", this.factoryAddress),
-      account
-    );
-  }
-  _collection(address, account) {
-    return newContract(
-      IPCollection1155ABI,
-      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,
-      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 = uint256.bnToUint256(BigInt(params.quoteFundAmount));
-    calls.push({
-      contractAddress: params.quoteToken,
-      entrypoint: "transfer",
-      calldata: [getStarknetCoordinates("STARKNET").creatorCoinFactory, amt.low, amt.high]
-    });
-  }
-  calls.push(factoryContract().populate("launch_on_ekubo", [launchParameters, ekuboParameters]));
-  return calls;
-}
-var CREATOR_COIN_CREATED_SELECTOR = hash.getSelectorFromName("CreatorCoinCreated");
-function parseCreatorCoinCreated(receipt) {
-  const factory = normalizeAddress("STARKNET", getStarknetCoordinates("STARKNET").creatorCoinFactory);
-  for (const ev of receipt?.events ?? []) {
-    let from;
-    try {
-      from = normalizeAddress("STARKNET", ev.from_address ?? "");
-    } catch {
-      continue;
-    }
-    if (from !== factory) continue;
-    const k0 = ev.keys?.[0];
-    if (!k0 || normalizeAddress("STARKNET", k0) !== normalizeAddress("STARKNET", CREATOR_COIN_CREATED_SELECTOR)) continue;
-    const data = ev.data ?? [];
-    if (data.length < 1) continue;
-    return 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 = 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 = 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, normalizeAddress("STARKNET", address), account);
-  }
-  _collection(address, account) {
-    return newContract(IPTicketCollectionABI, 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 CairoOption(CairoOptionVariant.Some, params.startTime) : new CairoOption(CairoOptionVariant.None);
-    const endTime = params.endTime != null ? new CairoOption(CairoOptionVariant.Some, params.endTime) : new CairoOption(CairoOptionVariant.None);
-    const call = this._collection(params.collection, account).populate("create_ticket", [
-      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,
-      cairo.uint256(params.tokenId),
-      cairo.uint256(params.amount)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-var ClubService = class {
-  constructor(config) {
-    this.factoryAddress = 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, normalizeAddress("STARKNET", address), account);
-  }
-  _collection(address, account) {
-    return newContract(IPClubCollectionABI, 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 CairoOption(CairoOptionVariant.Some, params.startTime) : new CairoOption(CairoOptionVariant.None);
-    const endTime = params.endTime != null ? new CairoOption(CairoOptionVariant.Some, params.endTime) : new CairoOption(CairoOptionVariant.None);
-    const call = this._collection(params.collection, account).populate("create_membership", [
-      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,
-      cairo.uint256(params.tokenId),
-      cairo.uint256(params.amount)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-var SponsorshipService = class {
-  constructor(config) {
-    this.sponsorshipAddress = 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, normalizeAddress("STARKNET", resolved), account);
-  }
-  async createOffer(account, params) {
-    const specificSponsor = params.specificSponsor ? new CairoOption(CairoOptionVariant.Some, params.specificSponsor) : new CairoOption(CairoOptionVariant.None);
-    const call = this._contract(account, params.sponsorshipAddress).populate("create_offer", [
-      params.nftContract,
-      cairo.uint256(params.tokenId),
-      cairo.uint256(params.minAmount),
-      params.duration,
-      params.paymentToken,
-      params.licenseTermsUri,
-      params.transferable,
-      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", [
-      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 = cairo.uint256(params.amount);
-    const approveCall = {
-      contractAddress: params.paymentToken,
-      entrypoint: "approve",
-      calldata: [normalizeAddress("STARKNET", sponsorshipAddress), amount.low.toString(), amount.high.toString()]
-    };
-    const bidCall = this._contract(account, sponsorshipAddress).populate("place_bid", [
-      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", [
-      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", [
-      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,
-      cairo.uint256(params.tokenId),
-      cairo.uint256(params.amount),
-      params.duration,
-      params.validUntil ?? 0,
-      params.paymentToken,
-      params.licenseTermsUri,
-      params.transferable,
-      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", [
-      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", [
-      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", [
-      cairo.uint256(params.proposalId)
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-function createChainProvider(backendUrl, apiKey) {
-  return new 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 = 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 ApiClient("https://medialane-sdk-no-backend.invalid", this.config.apiKey);
-      const apiMethodNames = new Set(
-        Object.getOwnPropertyNames(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 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: 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
-  };
+function buildFeeCall(p, cfg) {
+  const fee = feeAmount(p.grossAmount, feeBps(p.surface, cfg));
+  if (fee <= 0n) return null;
+  const u = cairo.uint256(fee.toString());
+  return {
+    contractAddress: p.token,
+    entrypoint: "transfer",
+    calldata: [cfg.fundAddress, u.low.toString(), u.high.toString()]
+  };
 }
 
 // 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",
@@ -11365,7 +10538,7 @@ function buildListingOrder(i, cfg) {
 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",
@@ -11405,7 +10578,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(
@@ -11526,15 +10699,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);
@@ -11557,7 +10730,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;
@@ -11619,7 +10792,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 {
@@ -11628,7 +10801,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 };
@@ -11817,13 +10990,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);
@@ -11842,32 +11009,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 };
@@ -11875,7 +11042,7 @@ 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;
@@ -11892,8 +11059,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;
@@ -11929,8 +11096,8 @@ 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;
   }
@@ -11965,727 +11132,584 @@ var DEPLOY_EVENTS = {
 var IP_MINTED_SELECTOR = BigInt(hash.getSelectorFromName("IPMinted"));
 var TRANSFER_SELECTOR = BigInt(hash.getSelectorFromName("Transfer"));
 function sameFelt(a, b) {
-  if (a === void 0) return false;
-  try {
-    return BigInt(a) === BigInt(b);
-  } catch {
-    return false;
-  }
-}
-function u2563(low, high) {
-  return (BigInt(low ?? 0) + (BigInt(high ?? 0) << 128n)).toString();
-}
-function deployedCollectionFromReceipt(receipt, service) {
-  const factory = getService(service)?.onchain?.STARKNET?.factoryAddress;
-  const { event, address } = DEPLOY_EVENTS[service];
-  const selector = BigInt(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 normalizeAddress("STARKNET", value);
-  }
-  return null;
-}
-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]);
-  }
-  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 };
-}
-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(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,
-    num.toHex(pendingVal),
-    remaining.length.toString()
-  ];
-}
-var STARK_ORDER = 3618502788666131213697322783095070105526743751716087489154079457884512865583n;
-function deriveOwnerKeyPair(secret, recipientId) {
-  const prk = extract(sha256, secret);
-  const okm = expand(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 = num.toHex(scalar);
-  const publicKey = ec.starkCurve.getStarkKey(privateKey);
-  return { privateKey, publicKey };
-}
-var STARKNET_SIGNER_TYPE = "0x537461726b6e6574205369676e6572";
-var OPTION_NONE = "0x1";
-var SIGNER_STARKNET = "0x0";
-function computeOwnerGuid(ownerPubkey) {
-  return hash.computePoseidonHash(STARKNET_SIGNER_TYPE, num.toHex(ownerPubkey));
+  if (a === void 0) return false;
+  try {
+    return BigInt(a) === BigInt(b);
+  } catch {
+    return false;
+  }
 }
-function changeOwners(accountAddress, guidsToRemove, pubkeysToAdd) {
-  return {
-    contractAddress: accountAddress,
-    entrypoint: "change_owners",
-    calldata: [
-      num.toHex(guidsToRemove.length),
-      ...guidsToRemove,
-      num.toHex(pubkeysToAdd.length),
-      ...pubkeysToAdd.flatMap((p) => [SIGNER_STARKNET, num.toHex(p)]),
-      OPTION_NONE
-    ]
-  };
+function u256(low, high) {
+  return (BigInt(low ?? 0) + (BigInt(high ?? 0) << 128n)).toString();
 }
-function buildAddOwnerCall(accountAddress, addOwnerPubkey) {
-  return changeOwners(accountAddress, [], [addOwnerPubkey]);
+function deployedCollectionFromReceipt(receipt, service) {
+  const factory = getService(service)?.onchain?.STARKNET?.factoryAddress;
+  const { event, address } = DEPLOY_EVENTS[service];
+  const selector = BigInt(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 normalizeAddress("STARKNET", value);
+  }
+  return null;
 }
-function buildRemoveOwnerCall(accountAddress, removeOwnerPubkey) {
-  return changeOwners(accountAddress, [computeOwnerGuid(removeOwnerPubkey)], []);
+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 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;
 }
-function buildRemoveOwnerByGuidCall(accountAddress, ownerGuid) {
-  return changeOwners(accountAddress, [num.toHex(ownerGuid)], []);
+var FRAGMENT_KEY = "pop-proof";
+var toHex = (x) => "0x" + x.toString(16).padStart(64, "0");
+var poseidon = (xs) => BigInt(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 buildDeployAccountParams(ownerPubkey, salt = 0) {
+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 {
-    classHash: STARKNET_MEDIAWALLET_CLASS_HASH,
-    constructorCalldata: ownerConstructorCalldata(ownerPubkey),
-    addressSalt: num.toHex(salt),
-    contractAddress: computeAccountAddress(ownerPubkey, salt)
+    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;
+    }
   };
 }
-var norm = (address) => normalizeAddress("STARKNET", address);
-var SIGNER_TYPE_NAMES = ["Starknet", "Secp256k1", "Secp256r1"];
-function encodeFeltArray(items) {
-  return [num.toHex(items.length), ...items];
-}
-function encodeStarknetSigner(pubkey) {
-  return ["0x0", num.toHex(pubkey)];
-}
-function encodeStarknetSignerArray(pubkeys) {
-  return [num.toHex(pubkeys.length), ...pubkeys.flatMap(encodeStarknetSigner)];
+function buildPopAllowlist(addresses) {
+  const unique = [...new Set(addresses.map((a) => 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 buildSetFirstGuardianCall(address, guardianPubkey) {
-  return {
-    contractAddress: norm(address),
-    entrypoint: "change_guardians",
-    calldata: [...encodeFeltArray([]), ...encodeStarknetSignerArray([guardianPubkey])]
-  };
+function verifyPopProof(root, address, proof) {
+  let computed = popLeafHash(address);
+  for (const sibling of proof) computed = nodeHash(computed, BigInt(sibling));
+  return computed === BigInt(root);
 }
-function buildTriggerEscapeOwnerCall(targetAddress, newOwnerPubkey) {
-  return {
-    contractAddress: norm(targetAddress),
-    entrypoint: "trigger_escape_owner",
-    calldata: encodeStarknetSigner(newOwnerPubkey)
-  };
+function encodePopClaimFragment(proof) {
+  return `#${FRAGMENT_KEY}=${proof.join(",")}`;
 }
-function buildCompleteEscapeOwnerCall(targetAddress) {
-  return { contractAddress: norm(targetAddress), entrypoint: "escape_owner", calldata: [] };
+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 buildCancelEscapeCall(address) {
-  return { contractAddress: norm(address), entrypoint: "cancel_escape", calldata: [] };
+function popClaimLinks(origin, collection, list) {
+  const base = `${origin}${collectionHref("STARKNET", collection)}`;
+  return Object.entries(list.proofs).map(([address, proof]) => ({
+    address,
+    url: `${base}${encodePopClaimFragment(proof)}`
+  }));
 }
-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 popClaimLinksCsv(links) {
+  return ["address,claim_link", ...links.map((l) => `${l.address},${l.url}`)].join("\n");
 }
-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 };
+async function popClaimInfo(provider, collection) {
+  const contractAddress = 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 getGuardians(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_guardians_info",
-    calldata: []
-  });
-  return decodeGuardiansInfo(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 getOwners(provider, address) {
+var addr = (a) => normalizeAddress("STARKNET", a);
+var byteArrayFelts = (s) => CallData.compile([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 = 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_owners_info",
-    calldata: []
+    contractAddress: normalizeAddress("STARKNET", collection),
+    entrypoint: "has_claimed",
+    calldata: [normalizeAddress("STARKNET", address)]
   });
-  return decodeGuardiansInfo(res);
+  return BigInt(res[0] ?? "0x0") !== 0n;
 }
-async function getEscape(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_escape_and_status",
-    calldata: []
-  });
-  return decodeEscapeAndStatus(res);
+var DROP_MAX_CLAIM_QUANTITY = 50n;
+var addr2 = (a) => normalizeAddress("STARKNET", a);
+var factoryData = new CallData(DropFactoryABI);
+var collectionData = new CallData(DropCollectionABI);
+function toContractTerms(t) {
+  const price = BigInt(t.price);
+  return {
+    start_time: t.startTime,
+    end_time: t.endTime,
+    price: cairo.uint256(price),
+    payment_token: price === 0n ? "0x0" : addr2(t.paymentToken),
+    max_per_wallet: cairo.uint256(BigInt(t.maxPerWallet))
+  };
 }
-async function getEscapeSecurityPeriod(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_escape_security_period",
-    calldata: []
-  });
-  return Number(res[0]);
+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: 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: CallData.compile([addr2(collection), cairo.uint256(total)])
+      });
+    }
+    calls.push({
+      contractAddress: addr2(collection),
+      entrypoint: "claim",
+      calldata: collectionData.compile("claim", { quantity: 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: 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/wallet/store.ts
-function createOwnerStore(config) {
-  const { storeKey, changeEvent } = config;
-  const announce = () => {
-    if (typeof window === "undefined") return;
-    window.dispatchEvent(new Event(changeEvent));
-  };
+// src/starknet/drop-state.ts
+var hex = (v) => 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 {
-    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);
-    }
+    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])
   };
 }
-
-// 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";
-  }
-};
-function normalisePublicKey(input) {
-  if (typeof input !== "string" || !/^0x[0-9a-fA-F]+$/.test(input)) {
-    throw new InvalidPairingPayloadError("That device key is not valid.");
+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;
+}
+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 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");
   }
-  const value = BigInt(input);
-  if (value === 0n || value >= STARK_PRIME) {
-    throw new InvalidPairingPayloadError("That device key is not valid.");
+  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 `0x${value.toString(16)}`;
-}
-function sanitiseLabel(input) {
-  const raw = typeof input === "string" ? input : "";
-  return raw.replace(/\s+/g, " ").trim().slice(0, LABEL_MAX);
-}
-function encodePairingPayload(payload) {
-  return JSON.stringify({
-    scheme: SCHEME,
-    version: VERSION,
-    publicKey: normalisePublicKey(payload.publicKey),
-    label: sanitiseLabel(payload.label)
-  });
+  return { state: "ready", maxQuantity: max };
 }
-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)
-  };
+function dropClaimLinks(origin, collection, list) {
+  const base = `${origin}${dropHref(collection)}`;
+  return Object.entries(list.proofs).map(([address, proof]) => ({
+    address,
+    url: `${base}${encodePopClaimFragment(proof)}`
+  }));
 }
-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.");
-  }
-  if (BigInt(trimmed) === 0n) {
-    throw new InvalidPairingPayloadError("That does not look like an account address.");
-  }
-  return trimmed;
+function populateCall(abi, contractAddress, entrypoint, args) {
+  return { contractAddress, entrypoint, calldata: new CallData(abi).compile(entrypoint, args) };
 }
-
-// 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";
-  }
+var addr3 = (address) => normalizeAddress("STARKNET", address);
+var optionOf = (value) => value != null ? new CairoOption(CairoOptionVariant.Some, value) : new CairoOption(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 starkKeyPairFromPrivateKey(privateKey);
-  } catch {
-    throw new InvalidRecoveryKeyError();
-  }
+var ticketCalls = {
+  deployCollection: (factory, p) => deployCollectionCall(IPTicketCollectionFactoryABI, factory, p),
+  createTicket: (p) => populateCall(IPTicketCollectionABI, addr3(p.collection), "create_ticket", [
+    cairo.uint256(p.maxSupply),
+    optionOf(p.startTime),
+    optionOf(p.endTime),
+    p.royaltyBps,
+    p.metadataUri
+  ]),
+  mint: (p) => populateCall(IPTicketCollectionABI, addr3(p.collection), "mint", [
+    p.to,
+    cairo.uint256(p.tokenId),
+    cairo.uint256(p.amount)
+  ])
+};
+var clubCalls = {
+  deployCollection: (factory, p) => deployCollectionCall(IPClubFactoryABI, factory, p),
+  createMembership: (p) => populateCall(IPClubCollectionABI, addr3(p.collection), "create_membership", [
+    cairo.uint256(p.maxSupply),
+    optionOf(p.startTime),
+    optionOf(p.endTime),
+    p.royaltyBps,
+    p.metadataUri
+  ]),
+  mint: (p) => populateCall(IPClubCollectionABI, addr3(p.collection), "mint", [
+    p.to,
+    cairo.uint256(p.tokenId),
+    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,
+    cairo.uint256(p.tokenId),
+    cairo.uint256(p.minAmount),
+    p.duration,
+    p.paymentToken,
+    p.licenseTermsUri,
+    p.transferable,
+    cairo.uint256(p.royaltyBps),
+    p.specificSponsor ? new CairoOption(CairoOptionVariant.Some, p.specificSponsor) : new CairoOption(CairoOptionVariant.None)
+  ]),
+  setOfferOpen: (contract, p) => sponsorship(contract, "set_offer_open", [cairo.uint256(p.offerId), p.open]),
+  placeBid: (contract, p) => {
+    const amount = cairo.uint256(p.amount);
+    return [
+      {
+        contractAddress: p.paymentToken,
+        entrypoint: "approve",
+        calldata: [addr3(contract), amount.low.toString(), amount.high.toString()]
+      },
+      sponsorship(contract, "place_bid", [cairo.uint256(p.offerId), amount])
+    ];
+  },
+  retractBid: (contract, p) => sponsorship(contract, "retract_bid", [cairo.uint256(p.offerId)]),
+  acceptBid: (contract, p) => sponsorship(contract, "accept_bid", [cairo.uint256(p.offerId), p.sponsor]),
+  propose: (contract, p) => sponsorship(contract, "propose_sponsorship", [
+    p.nftContract,
+    cairo.uint256(p.tokenId),
+    cairo.uint256(p.amount),
+    p.duration,
+    p.validUntil ?? 0,
+    p.paymentToken,
+    p.licenseTermsUri,
+    p.transferable,
+    cairo.uint256(p.royaltyBps)
+  ]),
+  withdrawProposal: (contract, p) => sponsorship(contract, "withdraw_proposal", [cairo.uint256(p.proposalId)]),
+  acceptProposal: (contract, p) => sponsorship(contract, "accept_proposal", [cairo.uint256(p.proposalId)]),
+  rejectProposal: (contract, p) => sponsorship(contract, "reject_proposal", [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: 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 normalizeWalletAddress(address) {
-  return normalizeAddress("STARKNET", address);
+function teamCoinsRaw(supplyRaw, pct) {
+  const bps = BigInt(Math.round(pct * 100));
+  return supplyRaw * bps / 10000n;
 }
-function isValidStarknetAddress(address) {
-  try {
-    validateAndParseAddress(address.trim());
-    return true;
-  } catch {
-    return false;
-  }
+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));
 }
-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;
-  }
+function fdvHuman(supplyHuman, price) {
+  return supplyHuman * price;
 }
 
-// src/wallet/self-fund-consent.ts
-function createSelfFundConsent(estimateFee) {
-  let handler = null;
+// 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 {
-    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);
-    }
+    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 accountFor(provider, address, privateKeyHex) {
-  return new Account({ provider, address, signer: privateKeyHex, cairoVersion: "1" });
-}
-async function estimateSelfFundedFee(provider, address, calls) {
-  const account = new 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 = getTokenBySymbol(unit === "FRI" ? "STRK" : "ETH");
-  if (!token) throw new Error(`No fee token for unit ${unit}`);
-  return erc20Balance(provider, token.address, address);
+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;
 }
-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 };
-    }
-  };
+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);
 }
-function sponsoredExecutor(deps) {
-  const fallback = deps.fallback ?? selfFundedExecutor(deps);
+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 {
-    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) => signWithPrivateKey(privateKeyHex, 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);
-    }
+    isLaunched,
+    launchedAtBlock,
+    totalSupplyRaw: totalSupply.toString(),
+    teamAllocationRaw: teamAllocation.toString(),
+    teamAllocationPercent,
+    liquidityPositionId
   };
 }
-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 Account({
-    provider: input.provider,
-    address: input.ownerAddress,
-    signer: input.privateKeyHex,
-    cairoVersion: "1"
-  });
-  const signature = 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 = getCoordinates("STARKNET").mediaWalletClassHash;
-  if (!classHash) throw new Error("Media Wallet class hash is not configured");
-  const account = new Account({
-    provider: input.provider,
-    address: input.ownerAddress,
-    signer: input.privateKeyHex,
-    cairoVersion: "1"
-  });
-  const { transaction_hash } = await account.deployAccount({
-    classHash,
-    constructorCalldata: ownerConstructorCalldata(input.ownerPubKey),
-    addressSalt: 0,
-    contractAddress: input.ownerAddress
-  });
-  return { transactionHash: transaction_hash };
+var factoryAddress = () => 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)
+  ]);
 }
-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);
+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 = 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 = hash.getSelectorFromName("CreatorCoinCreated");
+function parseCreatorCoinCreated(receipt) {
+  const factory = normalizeAddress("STARKNET", 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 = 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 || normalizeAddress("STARKNET", k0) !== normalizeAddress("STARKNET", CREATOR_COIN_CREATED_SELECTOR)) continue;
+    const data = ev.data ?? [];
+    if (data.length < 1) continue;
+    return 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 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 signWithPrivateKey(privateKeyHex, 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(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,
+    num.toHex(pendingVal),
+    remaining.length.toString()
+  ];
 }
 
-export { MAX_SUPPLY as COIN_MAX_SUPPLY, MIN_SUPPLY as COIN_MIN_SUPPLY, ClubService, CreatorCoinFactoryABI, CreatorCoinService, DROP_MAX_CLAIM_QUANTITY, DropCollectionABI, DropFactoryABI, DropService, ERC1155CollectionService, FundingTransferNotSentError, IPClubCollectionABI, IPClubFactoryABI, IPCollection1155ABI, IPCollection1155FactoryABI, IPCollectionABI, IPGenesisABI, IPMarketplaceABI, IPNftABI, IPSponsorshipABI, IPTicketCollectionABI, IPTicketCollectionFactoryABI, InvalidPairingPayloadError, InvalidRecoveryKeyError, MAX_HOLDERS_AT_LAUNCH, MAX_TEAM_ALLOCATION_PERCENT, Medialane1155ABI, MedialaneClient, MedialaneError, POPCollectionABI, POPFactoryABI, PopService, SUGGESTED_DEFAULT_PRICE, SponsoredCallRejectedError, SponsorshipService, StarknetVenue, TicketService, VALIDATED_EKUBO_PARAMS, accountFor, allowsFallbackFunding, apiKeyConfirmationTypedData, assertTransactionSucceeded, build1155CancellationTypedData, build1155OrderTypedData, buildAddOwnerCall, buildCancelEscapeCall, buildCancellationTypedData, buildCompleteEscapeOwnerCall, buildCreateCreatorCoinCall, buildDeployAccountParams, buildFeeCall, buildFundingTransferCall, buildLaunchOnEkuboCalls, buildOrderTypedData, buildPopAllowlist, buildRemoveOwnerByGuidCall, buildRemoveOwnerCall, buildSetFirstGuardianCall, buildTriggerEscapeOwnerCall, buybackQuoteRaw, canRemoveDevice, claimSessionWallet, toRaw as coinToRaw, completeDeployment, computeOwnerGuid, confirmIntentBestEffort, createChainProvider, createDeploymentCoordinator, createMediaWallet, createOwnerStore, createSelfFundConsent, decodeEscapeAndStatus, decodeGuardiansInfo, decodePopClaimFragment, deploySelfFunded, deploySponsored, deployedCollectionFromReceipt, deriveOwnerKeyPair, describeDevices, describeGuardianStatus, describeRecoveryAction, dropCalls, dropClaimLinks, dropClaimedBy, dropMintCost, dropMintState, encodeByteArray, encodePairingPayload, encodePopClaimFragment, encodeRecoveryKey, erc20Balance, estimateSelfFundedFee, executeIntent, executeIntents, executeSponsored, fdvHuman, feeAmount, feeBps, fundWithChainTransfer, fundingApiFor, getCreatorCoinGuarantees, getEscape, getEscapeSecurityPeriod, getGuardians, getOwners, getSiwsStorageKey, getStoredSiwsToken, isDeployed, isSiwsTokenValid, isValidStarknetAddress, mintedTokenIdFromReceipt, normalizeSiwsSignature, normalizeWalletAddress, parseAccountAddress, parseCreatorCoinCreated, parsePairingPayload, parseRecoveryKey, popCalls, popClaimInfo, popClaimLinks, popClaimLinksCsv, popClaimState, popHasClaimed, priceToEkuboParams, readDrop, requestSiwsToken, selfFundedExecutor, signInWithWallet, sponsoredExecutor, storeSiwsToken, syncTransactionBestEffort, teamCoinsRaw, toContractTerms as toDropContractTerms, validateName as validateCoinName, validateSupply as validateCoinSupply, validateSymbol as validateCoinSymbol, validatePrice, verifyPopProof, waitUntilDeployed };
+export { MAX_SUPPLY as COIN_MAX_SUPPLY, MIN_SUPPLY as COIN_MIN_SUPPLY, CreatorCoinFactoryABI, DROP_MAX_CLAIM_QUANTITY, DropCollectionABI, DropFactoryABI, FundingTransferNotSentError, IPClubCollectionABI, IPClubFactoryABI, IPCollection1155ABI, IPCollection1155FactoryABI, IPCollectionABI, IPGenesisABI, IPMarketplaceABI, IPNftABI, IPSponsorshipABI, IPTicketCollectionABI, IPTicketCollectionFactoryABI, MAX_HOLDERS_AT_LAUNCH, MAX_TEAM_ALLOCATION_PERCENT, Medialane1155ABI, MedialaneClient, POPCollectionABI, POPFactoryABI, SUGGESTED_DEFAULT_PRICE, StarknetVenue, VALIDATED_EKUBO_PARAMS, apiKeyConfirmationTypedData, assertTransactionSucceeded, build1155CancellationTypedData, build1155OrderTypedData, buildCancellationTypedData, buildCreateCreatorCoinCall, buildDropClaimCalls, buildFeeCall, buildFundingTransferCall, buildLaunchOnEkuboCalls, buildOrderTypedData, buildPopAllowlist, buybackQuoteRaw, clubCalls, toRaw as coinToRaw, confirmIntentBestEffort, createChainProvider, decodePopClaimFragment, deployedCollectionFromReceipt, dropCalls, dropClaimLinks, dropClaimedBy, dropMintCost, dropMintState, editionCalls, encodeByteArray, encodePopClaimFragment, executeIntent, executeIntents, fdvHuman, feeAmount, feeBps, fundWithChainTransfer, fundingApiFor, getCreatorCoinGuarantees, getSiwsStorageKey, getStoredSiwsToken, isCreatorCoin, isSiwsTokenValid, mintedTokenIdFromReceipt, normalizeSiwsSignature, parseCreatorCoinCreated, popCalls, popClaimInfo, popClaimLinks, popClaimLinksCsv, popClaimState, popFactoryCalls, popHasClaimed, populateCall, priceToEkuboParams, readDrop, requestSiwsToken, signInWithWallet, sponsorshipCalls, storeSiwsToken, syncTransactionBestEffort, teamCoinsRaw, ticketCalls, toContractTerms as toDropContractTerms, validateName as validateCoinName, validateSupply as validateCoinSupply, validateSymbol as validateCoinSymbol, validatePrice, verifyPopProof };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map