@medialane/sdk 0.62.0 → 0.64.0

package/dist/index.cjs

@@ -37,9 +37,9 @@ var COORDINATES = {
     creatorCoinFactoryClassHash: "0x51765926b1344c9a20b8cd4b5abe7b7d47375ae97cf6804db3ea5d4b05a9b55",
     creatorCoinStartBlock: 10474544,
     ekuboCore: "0x00000005dd3d2f4429af886cd1a3b08289dbcea99a294197e9eb43b0e0325b4b",
-    ipTicketsFactory: "0x0664c2d6a4da9ee3ff053ceeba7579c01f2fedfd9d2b57b4c07af3734bd4acab",
-    ipTicketCollectionClassHash: "0x086f59c416e365e2bee4ceff9f1dcb96198f2342d50ba4621f60b831863adb6",
-    ipTicketsStartBlock: 11404656,
+    ipTicketsFactory: "0x03ffef4162fe2c44e17d6be2aad3553cab0ac2274cd0b1bb3fafb12fd66695c1",
+    ipTicketCollectionClassHash: "0x036393fb4241ed55bd12d8b328ed877d08100fadf9150a650e2b84cbab95e1d4",
+    ipTicketsStartBlock: 11689800,
     ipClubRegistry: "0x00e189c619b6bb07d78973a149641c59c37eb0716f8584d7520bce12d303eede",
     ipClubNftClassHash: "0x02bc9b20cca21b04245e9215bf7121f4d7295b195890e449b472b573017fb889",
     ipClubStartBlock: 11404776,
@@ -1296,124 +1296,6 @@ function createFailoverFetch(urls, options = {}) {
   };
   return failover;
 }
-var STARKNET_DOMAIN = [
-  { name: "name", type: "shortstring" },
-  { name: "version", type: "shortstring" },
-  { name: "chainId", type: "shortstring" },
-  { name: "revision", type: "shortstring" }
-];
-var OFFER_ITEM = [
-  { name: "item_type", type: "shortstring" },
-  { name: "token", type: "ContractAddress" },
-  { name: "identifier_or_criteria", type: "felt" },
-  { name: "amount", type: "felt" }
-];
-var CONSIDERATION_ITEM = [
-  { name: "item_type", type: "shortstring" },
-  { name: "token", type: "ContractAddress" },
-  { name: "identifier_or_criteria", type: "felt" },
-  { name: "amount", type: "felt" },
-  { name: "recipient", type: "ContractAddress" }
-];
-var ORDER_PARAMETERS = [
-  { name: "offerer", type: "ContractAddress" },
-  { name: "marketplace", type: "ContractAddress" },
-  { name: "offer", type: "OfferItem" },
-  { name: "consideration", type: "ConsiderationItem" },
-  { name: "royalty_max_bps", type: "felt" },
-  { name: "start_time", type: "felt" },
-  { name: "end_time", type: "felt" },
-  { name: "salt", type: "felt" },
-  { name: "counter", type: "felt" }
-];
-var ORDER_CANCELLATION = [
-  { name: "order_hash", type: "felt" },
-  { name: "offerer", type: "ContractAddress" }
-];
-var DOMAIN_VERSION = {
-  erc721: "5",
-  erc1155: "4"
-};
-function buildDomain(standard, chainId) {
-  return {
-    name: "Medialane",
-    version: DOMAIN_VERSION[standard],
-    chainId,
-    revision: starknet.TypedDataRevision.ACTIVE
-  };
-}
-function buildOrderTypedData(message, chainId) {
-  return {
-    domain: buildDomain("erc721", chainId),
-    primaryType: "OrderParameters",
-    types: {
-      StarknetDomain: STARKNET_DOMAIN,
-      OrderParameters: ORDER_PARAMETERS,
-      OfferItem: OFFER_ITEM,
-      ConsiderationItem: CONSIDERATION_ITEM
-    },
-    message
-  };
-}
-function build1155OrderTypedData(message, chainId) {
-  return {
-    domain: buildDomain("erc1155", chainId),
-    primaryType: "OrderParameters",
-    types: {
-      StarknetDomain: STARKNET_DOMAIN,
-      OrderParameters: ORDER_PARAMETERS,
-      OfferItem: OFFER_ITEM,
-      ConsiderationItem: CONSIDERATION_ITEM
-    },
-    message
-  };
-}
-function buildCancellationTypedData(message, chainId) {
-  return {
-    domain: buildDomain("erc721", chainId),
-    primaryType: "OrderCancellation",
-    types: {
-      StarknetDomain: STARKNET_DOMAIN,
-      OrderCancellation: ORDER_CANCELLATION
-    },
-    message
-  };
-}
-function build1155CancellationTypedData(message, chainId) {
-  return {
-    domain: buildDomain("erc1155", chainId),
-    primaryType: "OrderCancellation",
-    types: {
-      StarknetDomain: STARKNET_DOMAIN,
-      OrderCancellation: ORDER_CANCELLATION
-    },
-    message
-  };
-}
-function encodeByteArray(str) {
-  const bytes = new TextEncoder().encode(str);
-  const fullChunks = [];
-  let i = 0;
-  while (i + 31 <= bytes.length) {
-    let val = 0n;
-    for (const b of bytes.slice(i, i + 31)) {
-      val = val << 8n | BigInt(b);
-    }
-    fullChunks.push(starknet.num.toHex(val));
-    i += 31;
-  }
-  const remaining = bytes.slice(i);
-  let pendingVal = 0n;
-  for (const b of remaining) {
-    pendingVal = pendingVal << 8n | BigInt(b);
-  }
-  return [
-    fullChunks.length.toString(),
-    ...fullChunks,
-    starknet.num.toHex(pendingVal),
-    remaining.length.toString()
-  ];
-}
 
 // src/starknet/abis/ipMarketplace.ts
 var IPMarketplaceABI = [
@@ -11444,13 +11326,71 @@ var IPGenesisABI = [
   }
 ];
 
-// 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/services/pop.ts
+var PopService = class {
+  constructor(config) {
+    this.factoryAddress = getStarknetCoordinates(config.chain).popFactory;
+  }
+  _collection(address, account) {
+    return new starknet.Contract(POPCollectionABI, normalizeAddress("STARKNET", address), account);
+  }
+  async claim(account, collectionAddress) {
+    const call = this._collection(collectionAddress, account).populate("claim", []);
+    const res = await account.execute([call]);
+    return { txHash: res.transaction_hash };
+  }
+  async adminMint(account, params) {
+    const call = this._collection(params.collection, account).populate("admin_mint", [
+      params.recipient,
+      params.customUri ?? ""
+    ]);
+    const res = await account.execute([call]);
+    return { txHash: res.transaction_hash };
+  }
+  async addToAllowlist(account, params) {
+    const call = this._collection(params.collection, account).populate("add_to_allowlist", [params.address]);
+    const res = await account.execute([call]);
+    return { txHash: res.transaction_hash };
+  }
+  async batchAddToAllowlist(account, params) {
+    const collection = this._collection(params.collection, account);
+    const CHUNK = 200;
+    const calls = [];
+    for (let i = 0; i < params.addresses.length; i += CHUNK) {
+      calls.push(collection.populate("batch_add_to_allowlist", [params.addresses.slice(i, i + CHUNK)]));
+    }
+    const res = await account.execute(calls);
+    return { txHash: res.transaction_hash };
+  }
+  async removeFromAllowlist(account, params) {
+    const call = this._collection(params.collection, account).populate("remove_from_allowlist", [params.address]);
+    const res = await account.execute([call]);
+    return { txHash: res.transaction_hash };
+  }
+  async setTokenUri(account, params) {
+    const call = this._collection(params.collection, account).populate("set_token_uri", [
+      BigInt(params.tokenId),
+      params.uri
+    ]);
+    const res = await account.execute([call]);
+    return { txHash: res.transaction_hash };
+  }
+  async setPaused(account, params) {
+    const call = this._collection(params.collection, account).populate("set_paused", [params.paused]);
+    const res = await account.execute([call]);
+    return { txHash: res.transaction_hash };
+  }
+  async createCollection(account, params) {
+    const factory = new starknet.Contract(POPFactoryABI, this.factoryAddress, account);
+    const call = factory.populate("create_collection", [
+      params.name,
+      params.symbol,
+      params.baseUri,
+      params.claimEndTime,
+      { [params.eventType]: {} }
+    ]);
+    const res = await account.execute([call]);
+    return { txHash: res.transaction_hash };
   }
 };
 function buildFeeCall(p, cfg) {
@@ -11466,856 +11406,39 @@ function buildFeeCall(p, cfg) {
     calldata: [cfg.fundAddress, u.low.toString(), u.high.toString()]
   };
 }
-var START_TIME_BUFFER_SECS = 30;
-function generateSalt() {
-  const bytes = new Uint8Array(31);
-  crypto.getRandomValues(bytes);
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-  return starknet.num.toHex(BigInt("0x" + hex));
+
+// src/starknet/services/drop.ts
+function toContractConditions(c) {
+  return {
+    start_time: c.startTime,
+    end_time: c.endTime,
+    price: BigInt(c.price),
+    payment_token: c.paymentToken,
+    max_quantity_per_wallet: BigInt(c.maxQuantityPerWallet)
+  };
 }
-async function resolveRoyaltyMaxBps(provider, nft, tokenId, override) {
-  if (override !== void 0) return override;
-  try {
-    const id = starknet.cairo.uint256(tokenId);
-    const res = await provider.callContract({
-      contractAddress: nft,
-      entrypoint: "royalty_info",
-      calldata: [id.low.toString(), id.high.toString(), "10000", "0"]
-    });
-    return BigInt(res[1] ?? "0").toString();
-  } catch {
-    return "0";
+var DropService = class {
+  constructor(config) {
+    this.factoryAddress = getStarknetCoordinates(config.chain).dropFactory;
+    this.config = config;
   }
-}
-function toSignatureArray(sig) {
-  if (Array.isArray(sig)) return sig;
-  const s = sig;
-  return [s.r.toString(), s.s.toString()];
-}
-function getChainId(config) {
-  if (config.chain !== "STARKNET") {
-    throw new Error(`SNIP-12 signing is Starknet-only; got chain "${config.chain}"`);
+  _collection(address, account) {
+    return new starknet.Contract(DropCollectionABI, normalizeAddress("STARKNET", address), account);
   }
-  return starknet.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 _providerCache = /* @__PURE__ */ new WeakMap();
-function getProvider(config) {
-  let p = _providerCache.get(config);
-  if (!p) {
-    const urls = Array.from(/* @__PURE__ */ new Set([config.rpcUrl, ...PUBLIC_RPC_FALLBACKS]));
-    p = new starknet.RpcProvider({ nodeUrl: urls[0], baseFetch: createFailoverFetch(urls) });
-    _providerCache.set(config, p);
-  }
-  return p;
-}
-
-// src/starknet/marketplace/orders.ts
-var _contractCache = /* @__PURE__ */ new WeakMap();
-function makeContract(config) {
-  const cached = _contractCache.get(config);
-  const provider = getProvider(config);
-  if (cached) return { ...cached, provider };
-  const contract = new starknet.Contract(
-    IPMarketplaceABI,
-    config.marketplaceContract,
-    provider
-  );
-  _contractCache.set(config, { contract });
-  return { contract, provider };
-}
-async function createListing(account, params, config) {
-  const { nftContract, tokenId, price, currency = DEFAULT_CURRENCY, durationSeconds } = params;
-  const { contract, provider } = makeContract(config);
-  const token = resolveToken(currency);
-  const priceWei = parseAmount(price, token.decimals);
-  const now = Math.floor(Date.now() / 1e3);
-  const startTime = now + START_TIME_BUFFER_SECS;
-  const endTime = now + durationSeconds;
-  const counter = (await contract.get_counter(account.address)).toString();
-  const royaltyMaxBps = await resolveRoyaltyMaxBps(provider, nftContract, tokenId, params.royaltyMaxBps);
-  const orderParams = {
-    offerer: account.address,
-    marketplace: config.marketplaceContract,
-    offer: {
-      item_type: "ERC721",
-      token: nftContract,
-      identifier_or_criteria: tokenId,
-      amount: "1"
-    },
-    consideration: {
-      item_type: "ERC20",
-      token: token.address,
-      identifier_or_criteria: "0",
-      amount: priceWei,
-      recipient: account.address
-    },
-    royalty_max_bps: royaltyMaxBps,
-    start_time: startTime.toString(),
-    end_time: endTime.toString(),
-    salt: generateSalt(),
-    counter
-  };
-  const chainId = getChainId(config);
-  const typedData = stringifyBigInts(buildOrderTypedData(orderParams, chainId));
-  const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray(signature);
-  const registerPayload = stringifyBigInts({
-    parameters: {
-      ...orderParams,
-      offer: {
-        ...orderParams.offer,
-        item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type)
-      },
-      consideration: {
-        ...orderParams.consideration,
-        item_type: starknet.shortString.encodeShortString(orderParams.consideration.item_type)
-      }
-    },
-    signature: signatureArray
-  });
-  const tokenIdUint256 = starknet.cairo.uint256(tokenId);
-  let isAlreadyApproved = false;
-  try {
-    const result = await provider.callContract({
-      contractAddress: nftContract,
-      entrypoint: "get_approved",
-      calldata: [tokenIdUint256.low.toString(), tokenIdUint256.high.toString()]
-    });
-    isAlreadyApproved = BigInt(result[0]).toString() === BigInt(config.marketplaceContract).toString();
-  } catch {
-  }
-  const registerCall = contract.populate("register_order", [registerPayload]);
-  const calls = isAlreadyApproved ? [registerCall] : [
-    {
-      contractAddress: nftContract,
-      entrypoint: "approve",
-      calldata: [
-        config.marketplaceContract,
-        tokenIdUint256.low.toString(),
-        tokenIdUint256.high.toString()
-      ]
-    },
-    registerCall
-  ];
-  try {
-    const tx = await account.execute(calls);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to create listing", "TRANSACTION_FAILED", err);
-  }
-}
-async function makeOffer(account, params, config) {
-  const { nftContract, tokenId, price, currency = DEFAULT_CURRENCY, durationSeconds } = params;
-  const { contract, provider } = makeContract(config);
-  const token = resolveToken(currency);
-  const priceWei = parseAmount(price, token.decimals);
-  const now = Math.floor(Date.now() / 1e3);
-  const startTime = now + START_TIME_BUFFER_SECS;
-  const endTime = now + durationSeconds;
-  const counter = (await contract.get_counter(account.address)).toString();
-  const royaltyMaxBps = await resolveRoyaltyMaxBps(provider, nftContract, tokenId, params.royaltyMaxBps);
-  const orderParams = {
-    offerer: account.address,
-    marketplace: config.marketplaceContract,
-    offer: {
-      item_type: "ERC20",
-      token: token.address,
-      identifier_or_criteria: "0",
-      amount: priceWei
-    },
-    consideration: {
-      item_type: "ERC721",
-      token: nftContract,
-      identifier_or_criteria: tokenId,
-      amount: "1",
-      recipient: account.address
-    },
-    royalty_max_bps: royaltyMaxBps,
-    start_time: startTime.toString(),
-    end_time: endTime.toString(),
-    salt: generateSalt(),
-    counter
-  };
-  const chainId = getChainId(config);
-  const typedData = stringifyBigInts(buildOrderTypedData(orderParams, chainId));
-  const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray(signature);
-  const registerPayload = stringifyBigInts({
-    parameters: {
-      ...orderParams,
-      offer: {
-        ...orderParams.offer,
-        item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type)
-      },
-      consideration: {
-        ...orderParams.consideration,
-        item_type: starknet.shortString.encodeShortString(orderParams.consideration.item_type)
-      }
-    },
-    signature: signatureArray
-  });
-  const amountUint256 = starknet.cairo.uint256(priceWei);
-  const approveCall = {
-    contractAddress: token.address,
-    entrypoint: "approve",
-    calldata: [
-      config.marketplaceContract,
-      amountUint256.low.toString(),
-      amountUint256.high.toString()
-    ]
-  };
-  const registerCall = contract.populate("register_order", [registerPayload]);
-  try {
-    const tx = await account.execute([approveCall, registerCall]);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to make offer", "TRANSACTION_FAILED", err);
-  }
-}
-async function fulfillOrder(account, params, config) {
-  const { orderHash, paymentToken, totalPrice } = params;
-  const { contract, provider } = makeContract(config);
-  const totalPriceU256 = starknet.cairo.uint256(totalPrice);
-  const approveCall = {
-    contractAddress: paymentToken,
-    entrypoint: "approve",
-    calldata: [
-      config.marketplaceContract,
-      totalPriceU256.low.toString(),
-      totalPriceU256.high.toString()
-    ]
-  };
-  const fulfillCall = contract.populate("fulfill_order", [orderHash]);
-  const feeCall = buildFeeCall(
-    { surface: "marketplace", token: paymentToken, grossAmount: BigInt(totalPrice) },
-    config.feeConfig
-  );
-  const calls = feeCall ? [approveCall, fulfillCall, feeCall] : [approveCall, fulfillCall];
-  try {
-    const tx = await account.execute(calls);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to fulfill order", "TRANSACTION_FAILED", err);
-  }
-}
-async function cancelOrder(account, params, config) {
-  const { orderHash } = params;
-  const { contract, provider } = makeContract(config);
-  const chainId = getChainId(config);
-  const cancelParams = {
-    order_hash: orderHash,
-    offerer: account.address
-  };
-  const typedData = stringifyBigInts(
-    buildCancellationTypedData(cancelParams, chainId)
-  );
-  const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray(signature);
-  const cancelRequest = stringifyBigInts({
-    cancelation: cancelParams,
-    signature: signatureArray
-  });
-  const call = contract.populate("cancel_order", [cancelRequest]);
-  try {
-    const tx = await account.execute(call);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to cancel order", "TRANSACTION_FAILED", err);
-  }
-}
-async function mint(account, params, config) {
-  const { collectionId, recipient, tokenUri, royaltyBps, collectionContract } = params;
-  const provider = getProvider(config);
-  const contractAddress = collectionContract ?? config.collectionContract;
-  const id = starknet.cairo.uint256(collectionId);
-  const calldata = [
-    id.low.toString(),
-    id.high.toString(),
-    recipient,
-    ...encodeByteArray(tokenUri),
-    royaltyBps.toString()
-  ];
-  try {
-    const tx = await account.execute([{ contractAddress, entrypoint: "mint", calldata }]);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to mint NFT", "TRANSACTION_FAILED", err);
-  }
-}
-async function createCollection(account, params, config) {
-  const { name, symbol, baseUri, collectionContract } = params;
-  const provider = getProvider(config);
-  const contractAddress = collectionContract ?? config.collectionContract;
-  const calldata = [
-    ...encodeByteArray(name),
-    ...encodeByteArray(symbol),
-    ...encodeByteArray(baseUri)
-  ];
-  try {
-    const tx = await account.execute([{ contractAddress, entrypoint: "create_collection", calldata }]);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to create collection", "TRANSACTION_FAILED", err);
-  }
-}
-async function checkoutCart(account, items, config) {
-  if (items.length === 0) throw new MedialaneError("Cart is empty", "INVALID_PARAMS");
-  const { contract, provider } = makeContract(config);
-  const tokenTotals = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const prev = tokenTotals.get(item.considerationToken) ?? 0n;
-    tokenTotals.set(item.considerationToken, prev + BigInt(item.considerationAmount));
-  }
-  const approveCalls = Array.from(tokenTotals.entries()).map(([tokenAddr, totalWei]) => {
-    const amount = starknet.cairo.uint256(totalWei.toString());
-    return {
-      contractAddress: tokenAddr,
-      entrypoint: "approve",
-      calldata: [
-        config.marketplaceContract,
-        amount.low.toString(),
-        amount.high.toString()
-      ]
-    };
-  });
-  const fulfillCalls = items.map(
-    (item) => contract.populate("fulfill_order", [item.orderHash])
-  );
-  const feeCalls = Array.from(tokenTotals.entries()).map(
-    ([tokenAddr, totalWei]) => buildFeeCall(
-      { surface: "marketplace", token: tokenAddr, grossAmount: totalWei },
-      config.feeConfig
-    )
-  ).filter((c) => c !== null);
-  try {
-    const tx = await account.execute([...approveCalls, ...fulfillCalls, ...feeCalls]);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Cart checkout failed", "TRANSACTION_FAILED", err);
-  }
-}
-async function getOrderDetails(orderHash, config) {
-  const { contract } = makeContract(config);
-  return contract.get_order_details(orderHash);
-}
-async function getCounter(address, config) {
-  const { contract } = makeContract(config);
-  return BigInt((await contract.get_counter(address)).toString());
-}
-async function incrementCounter(account, config) {
-  const { contract, provider } = makeContract(config);
-  const call = contract.populate("increment_counter", []);
-  try {
-    const tx = await account.execute(call);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to increment counter", "TRANSACTION_FAILED", err);
-  }
-}
-
-// src/starknet/marketplace/index.ts
-var MarketplaceModule = class {
-  constructor(config) {
-    this.config = config;
-  }
-  // ─── Writes ───────────────────────────────────────────────────────────────
-  createListing(account, params) {
-    return createListing(account, params, this.config);
-  }
-  makeOffer(account, params) {
-    return makeOffer(account, params, this.config);
-  }
-  fulfillOrder(account, params) {
-    return fulfillOrder(account, params, this.config);
-  }
-  cancelOrder(account, params) {
-    return cancelOrder(account, params, this.config);
-  }
-  checkoutCart(account, items) {
-    return checkoutCart(account, items, this.config);
-  }
-  mint(account, params) {
-    return mint(account, params, this.config);
-  }
-  createCollection(account, params) {
-    return createCollection(account, params, this.config);
-  }
-  /** Bulk-cancel: bump the caller's counter, invalidating all their open orders. */
-  incrementCounter(account) {
-    return incrementCounter(account, this.config);
-  }
-  // ─── View calls ───────────────────────────────────────────────────────────
-  getOrderDetails(orderHash) {
-    return getOrderDetails(orderHash, this.config);
-  }
-  getCounter(address) {
-    return getCounter(address, this.config);
-  }
-  // ─── Typed data builders (for ChipiPay / custom signing flows) ───────────
-  buildListingTypedData(params, chainId) {
-    return buildOrderTypedData(params, chainId);
-  }
-  buildCancellationTypedData(params, chainId) {
-    return buildCancellationTypedData(params, chainId);
-  }
-};
-var _contractCache2 = /* @__PURE__ */ new WeakMap();
-function getContract(config) {
-  let c = _contractCache2.get(config);
-  if (!c) {
-    const provider = getProvider(config);
-    c = new starknet.Contract(
-      Medialane1155ABI,
-      config.marketplace1155Contract,
-      provider
-    );
-    _contractCache2.set(config, c);
-  }
-  return c;
-}
-async function createListing1155(account, params, config) {
-  const {
-    nftContract,
-    tokenId,
-    amount,
-    pricePerUnit,
-    currency = DEFAULT_CURRENCY,
-    durationSeconds
-  } = params;
-  const contract = getContract(config);
-  const provider = getProvider(config);
-  const token = resolveToken(currency);
-  const priceWei = parseAmount(pricePerUnit, token.decimals);
-  const now = Math.floor(Date.now() / 1e3);
-  const endTime = now + durationSeconds;
-  const chainId = getChainId(config);
-  const counter = (await contract.get_counter(account.address)).toString();
-  const royaltyMaxBps = await resolveRoyaltyMaxBps(provider, nftContract, tokenId, params.royaltyMaxBps);
-  const orderParams = {
-    offerer: account.address,
-    marketplace: config.marketplace1155Contract,
-    offer: {
-      item_type: "ERC1155",
-      token: nftContract,
-      identifier_or_criteria: tokenId,
-      amount
-      // ERC-1155 leg amount = unit quantity
-    },
-    consideration: {
-      item_type: "ERC20",
-      token: token.address,
-      identifier_or_criteria: "0",
-      amount: priceWei,
-      // payment leg amount = price PER UNIT
-      recipient: account.address
-    },
-    royalty_max_bps: royaltyMaxBps,
-    start_time: (now + START_TIME_BUFFER_SECS).toString(),
-    end_time: endTime.toString(),
-    salt: generateSalt(),
-    counter
-  };
-  const typedData = stringifyBigInts(
-    build1155OrderTypedData(orderParams, chainId)
-  );
-  const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray(signature);
-  const orderPayload = stringifyBigInts({
-    parameters: {
-      ...orderParams,
-      offer: {
-        ...orderParams.offer,
-        item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type)
-      },
-      consideration: {
-        ...orderParams.consideration,
-        item_type: starknet.shortString.encodeShortString(orderParams.consideration.item_type)
-      }
-    },
-    signature: signatureArray
-  });
-  let isApproved = false;
-  try {
-    const result = await provider.callContract({
-      contractAddress: nftContract,
-      entrypoint: "is_approved_for_all",
-      calldata: [account.address, config.marketplace1155Contract]
-    });
-    isApproved = BigInt(result[0]) === 1n;
-  } catch {
-  }
-  const registerCall = contract.populate("register_order", [orderPayload]);
-  const calls = isApproved ? [registerCall] : [
-    {
-      contractAddress: nftContract,
-      entrypoint: "set_approval_for_all",
-      calldata: [config.marketplace1155Contract, "1"]
-    },
-    registerCall
-  ];
-  try {
-    const tx = await account.execute(calls);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to create ERC-1155 listing", "TRANSACTION_FAILED", err);
-  }
-}
-async function fulfillOrder1155(account, params, config) {
-  const { orderHash, paymentToken, totalPrice, quantity = "1" } = params;
-  const contract = getContract(config);
-  const provider = getProvider(config);
-  const totalPriceU256 = starknet.cairo.uint256(totalPrice);
-  const approveCall = {
-    contractAddress: paymentToken,
-    entrypoint: "approve",
-    calldata: [
-      config.marketplace1155Contract,
-      totalPriceU256.low.toString(),
-      totalPriceU256.high.toString()
-    ]
-  };
-  const fulfillCall = contract.populate("fulfill_order", [orderHash, quantity]);
-  try {
-    const tx = await account.execute([approveCall, fulfillCall]);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to fulfill ERC-1155 order", "TRANSACTION_FAILED", err);
-  }
-}
-async function cancelOrder1155(account, params, config) {
-  const { orderHash } = params;
-  const contract = getContract(config);
-  const provider = getProvider(config);
-  const chainId = getChainId(config);
-  const cancelParams = {
-    order_hash: orderHash,
-    offerer: account.address
-  };
-  const typedData = stringifyBigInts(
-    build1155CancellationTypedData(cancelParams, chainId)
-  );
-  const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray(signature);
-  const cancelPayload = stringifyBigInts({
-    cancelation: cancelParams,
-    signature: signatureArray
-  });
-  const cancelCall = contract.populate("cancel_order", [cancelPayload]);
-  try {
-    const tx = await account.execute(cancelCall);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to cancel ERC-1155 order", "TRANSACTION_FAILED", err);
-  }
-}
-async function makeOffer1155(account, params, config) {
-  const {
-    nftContract,
-    tokenId,
-    amount,
-    price,
-    currency = DEFAULT_CURRENCY,
-    durationSeconds
-  } = params;
-  const contract = getContract(config);
-  const provider = getProvider(config);
-  const chainId = getChainId(config);
-  const token = resolveToken(currency);
-  const priceWei = parseAmount(price, token.decimals);
-  const now = Math.floor(Date.now() / 1e3);
-  const endTime = now + durationSeconds;
-  const counter = (await contract.get_counter(account.address)).toString();
-  const royaltyMaxBps = await resolveRoyaltyMaxBps(provider, nftContract, tokenId, params.royaltyMaxBps);
-  const orderParams = {
-    offerer: account.address,
-    marketplace: config.marketplace1155Contract,
-    offer: {
-      item_type: "ERC20",
-      token: token.address,
-      identifier_or_criteria: "0",
-      amount: priceWei
-      // price PER UNIT
-    },
-    consideration: {
-      item_type: "ERC1155",
-      token: nftContract,
-      identifier_or_criteria: tokenId,
-      amount,
-      // unit quantity
-      recipient: account.address
-    },
-    royalty_max_bps: royaltyMaxBps,
-    start_time: (now + START_TIME_BUFFER_SECS).toString(),
-    end_time: endTime.toString(),
-    salt: generateSalt(),
-    counter
-  };
-  const typedData = stringifyBigInts(
-    build1155OrderTypedData(orderParams, chainId)
-  );
-  const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray(signature);
-  const registerPayload = stringifyBigInts({
-    parameters: {
-      ...orderParams,
-      offer: {
-        ...orderParams.offer,
-        item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type)
-      },
-      consideration: {
-        ...orderParams.consideration,
-        item_type: starknet.shortString.encodeShortString(orderParams.consideration.item_type)
-      }
-    },
-    signature: signatureArray
-  });
-  const totalWei = BigInt(priceWei) * BigInt(amount);
-  const amountU256 = starknet.cairo.uint256(totalWei.toString());
-  const approveCall = {
-    contractAddress: token.address,
-    entrypoint: "approve",
-    calldata: [
-      config.marketplace1155Contract,
-      amountU256.low.toString(),
-      amountU256.high.toString()
-    ]
-  };
-  const registerCall = contract.populate("register_order", [registerPayload]);
-  try {
-    const tx = await account.execute([approveCall, registerCall]);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to make ERC-1155 offer", "TRANSACTION_FAILED", err);
-  }
-}
-async function checkoutCart1155(account, items, config) {
-  if (items.length === 0) throw new MedialaneError("Cart is empty", "INVALID_PARAMS");
-  const contract = getContract(config);
-  const provider = getProvider(config);
-  const tokenTotals = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const prev = tokenTotals.get(item.considerationToken) ?? 0n;
-    tokenTotals.set(item.considerationToken, prev + BigInt(item.considerationAmount));
-  }
-  const approveCalls = Array.from(tokenTotals.entries()).map(([tokenAddr, totalWei]) => {
-    const amount = starknet.cairo.uint256(totalWei.toString());
-    return {
-      contractAddress: tokenAddr,
-      entrypoint: "approve",
-      calldata: [
-        config.marketplace1155Contract,
-        amount.low.toString(),
-        amount.high.toString()
-      ]
-    };
-  });
-  const fulfillCalls = items.map(
-    (item) => contract.populate("fulfill_order", [item.orderHash, item.quantity ?? "1"])
-  );
-  try {
-    const tx = await account.execute([...approveCalls, ...fulfillCalls]);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("ERC-1155 cart checkout failed", "TRANSACTION_FAILED", err);
-  }
-}
-async function getOrderDetails1155(orderHash, config) {
-  const contract = getContract(config);
-  return contract.get_order_details(orderHash);
-}
-async function getCounter1155(address, config) {
-  const contract = getContract(config);
-  return BigInt((await contract.get_counter(address)).toString());
-}
-async function incrementCounter1155(account, config) {
-  const contract = getContract(config);
-  const provider = getProvider(config);
-  const call = contract.populate("increment_counter", []);
-  try {
-    const tx = await account.execute(call);
-    await provider.waitForTransaction(tx.transaction_hash);
-    return { txHash: tx.transaction_hash };
-  } catch (err) {
-    throw new MedialaneError("Failed to increment counter (1155)", "TRANSACTION_FAILED", err);
-  }
-}
-
-// src/starknet/marketplace1155/index.ts
-var Medialane1155Module = class {
-  constructor(config) {
-    this.config = config;
-  }
-  // ─── Writes ───────────────────────────────────────────────────────────────
-  /**
-   * Create an ERC-1155 sell listing.
-   * Optionally grants `set_approval_for_all` if not already approved.
-   */
-  createListing(account, params) {
-    return createListing1155(account, params, this.config);
-  }
-  /**
-   * Make an offer (bid) on an ERC-1155 token.
-   * Approves the ERC-20 spend then calls `register_order` atomically.
-   */
-  makeOffer(account, params) {
-    return makeOffer1155(account, params, this.config);
-  }
-  /**
-   * Fulfill (buy) an ERC-1155 listing.
-   * Approves the payment token then calls `fulfill_order` atomically.
-   */
-  fulfillOrder(account, params) {
-    return fulfillOrder1155(account, params, this.config);
-  }
-  /**
-   * Cancel an ERC-1155 listing (offerer only).
-   */
-  cancelOrder(account, params) {
-    return cancelOrder1155(account, params, this.config);
-  }
-  /**
-   * Checkout a cart of ERC-1155 orders atomically.
-   * Signs one fulfillment per item (with quantity), sums ERC-20 approvals by token.
-   */
-  checkoutCart(account, items) {
-    return checkoutCart1155(account, items, this.config);
-  }
-  /** Bulk-cancel on the 1155 venue: bump the caller's counter. */
-  incrementCounter(account) {
-    return incrementCounter1155(account, this.config);
-  }
-  // ─── View calls ───────────────────────────────────────────────────────────
-  getOrderDetails(orderHash) {
-    return getOrderDetails1155(orderHash, this.config);
-  }
-  getCounter(address) {
-    return getCounter1155(address, this.config);
-  }
-  // ─── Typed data builders (for ChipiPay / custom signing flows) ───────────
-  buildListingTypedData(params, chainId) {
-    return build1155OrderTypedData(params, chainId);
-  }
-  buildCancellationTypedData(params, chainId) {
-    return build1155CancellationTypedData(params, chainId);
-  }
-};
-var PopService = class {
-  constructor(config) {
-    this.factoryAddress = getStarknetCoordinates(config.chain).popFactory;
-  }
-  _collection(address, account) {
-    return new starknet.Contract(POPCollectionABI, normalizeAddress("STARKNET", address), account);
-  }
-  async claim(account, collectionAddress) {
-    const call = this._collection(collectionAddress, account).populate("claim", []);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async adminMint(account, params) {
-    const call = this._collection(params.collection, account).populate("admin_mint", [
-      params.recipient,
-      params.customUri ?? ""
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async addToAllowlist(account, params) {
-    const call = this._collection(params.collection, account).populate("add_to_allowlist", [params.address]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async batchAddToAllowlist(account, params) {
-    const collection = this._collection(params.collection, account);
-    const CHUNK = 200;
-    const calls = [];
-    for (let i = 0; i < params.addresses.length; i += CHUNK) {
-      calls.push(collection.populate("batch_add_to_allowlist", [params.addresses.slice(i, i + CHUNK)]));
-    }
-    const res = await account.execute(calls);
-    return { txHash: res.transaction_hash };
-  }
-  async removeFromAllowlist(account, params) {
-    const call = this._collection(params.collection, account).populate("remove_from_allowlist", [params.address]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async setTokenUri(account, params) {
-    const call = this._collection(params.collection, account).populate("set_token_uri", [
-      BigInt(params.tokenId),
-      params.uri
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async setPaused(account, params) {
-    const call = this._collection(params.collection, account).populate("set_paused", [params.paused]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-  async createCollection(account, params) {
-    const factory = new starknet.Contract(POPFactoryABI, this.factoryAddress, account);
-    const call = factory.populate("create_collection", [
-      params.name,
-      params.symbol,
-      params.baseUri,
-      params.claimEndTime,
-      { [params.eventType]: {} }
-    ]);
-    const res = await account.execute([call]);
-    return { txHash: res.transaction_hash };
-  }
-};
-function toContractConditions(c) {
-  return {
-    start_time: c.startTime,
-    end_time: c.endTime,
-    price: BigInt(c.price),
-    payment_token: c.paymentToken,
-    max_quantity_per_wallet: BigInt(c.maxQuantityPerWallet)
-  };
-}
-var DropService = class {
-  constructor(config) {
-    this.factoryAddress = getStarknetCoordinates(config.chain).dropFactory;
-    this.config = config;
-  }
-  _collection(address, account) {
-    return new starknet.Contract(DropCollectionABI, normalizeAddress("STARKNET", address), account);
-  }
-  async claim(account, collectionAddress, quantity = 1) {
-    const collection = this._collection(collectionAddress, account);
-    const qty = BigInt(quantity);
-    const claimCall = collection.populate("claim", [qty]);
-    const conditions = await collection.get_claim_conditions();
-    const price = BigInt(conditions.price);
-    const paymentToken = typeof conditions.payment_token === "bigint" ? "0x" + conditions.payment_token.toString(16) : conditions.payment_token;
-    const feeCall = price > 0n ? buildFeeCall(
-      { surface: "launchpad", token: paymentToken, grossAmount: price * qty },
-      this.config.feeConfig
-    ) : null;
-    const calls = feeCall ? [claimCall, feeCall] : [claimCall];
-    const res = await account.execute(calls);
-    return { txHash: res.transaction_hash };
+  async claim(account, collectionAddress, quantity = 1) {
+    const collection = this._collection(collectionAddress, account);
+    const qty = BigInt(quantity);
+    const claimCall = collection.populate("claim", [qty]);
+    const conditions = await collection.get_claim_conditions();
+    const price = BigInt(conditions.price);
+    const paymentToken = typeof conditions.payment_token === "bigint" ? "0x" + conditions.payment_token.toString(16) : conditions.payment_token;
+    const feeCall = price > 0n ? buildFeeCall(
+      { surface: "launchpad", token: paymentToken, grossAmount: price * qty },
+      this.config.feeConfig
+    ) : null;
+    const calls = feeCall ? [claimCall, feeCall] : [claimCall];
+    const res = await account.execute(calls);
+    return { txHash: res.transaction_hash };
   }
   async adminMint(account, params) {
     const call = this._collection(params.collection, account).populate("admin_mint", [
@@ -12941,8 +12064,6 @@ var SponsorshipService = class {
 var MedialaneClient = class {
   constructor(rawConfig = {}) {
     this.config = resolveConfig(rawConfig);
-    this.marketplace = new MarketplaceModule(this.config);
-    this.marketplace1155 = new Medialane1155Module(this.config);
     this.services = {
       pop: new PopService(this.config),
       drop: new DropService(this.config),
@@ -12985,99 +12106,512 @@ var MedialaneClient = class {
     return this.config.marketplaceContract;
   }
 };
+
+// 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";
+  }
+};
+var START_TIME_BUFFER_SECS = 30;
+function newContract(abi, address, providerOrAccount) {
+  const C = starknet.Contract;
+  return C.length === 1 ? new starknet.Contract({ abi, address, providerOrAccount }) : new starknet.Contract(
+    abi,
+    address,
+    providerOrAccount
+  );
+}
+function getChainId(config) {
+  if (config.chain !== "STARKNET") {
+    throw new Error(`SNIP-12 signing is Starknet-only; got chain "${config.chain}"`);
+  }
+  return starknet.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 _providerCache = /* @__PURE__ */ new WeakMap();
+function getProvider(config) {
+  let p = _providerCache.get(config);
+  if (!p) {
+    const urls = Array.from(/* @__PURE__ */ new Set([config.rpcUrl, ...PUBLIC_RPC_FALLBACKS]));
+    p = new starknet.RpcProvider({ nodeUrl: urls[0], baseFetch: createFailoverFetch(urls) });
+    _providerCache.set(config, p);
+  }
+  return p;
+}
+
+// src/starknet/marketplace/orders.ts
+var _contractCache = /* @__PURE__ */ new WeakMap();
+function makeContract(config) {
+  const cached = _contractCache.get(config);
+  if (cached) return cached;
+  const contract = newContract(
+    IPMarketplaceABI,
+    config.marketplaceContract,
+    getProvider(config)
+  );
+  const entry = { contract };
+  _contractCache.set(config, entry);
+  return entry;
+}
+async function getOrderDetails(orderHash, config) {
+  const { contract } = makeContract(config);
+  return contract.get_order_details(orderHash);
+}
+async function getCounter(address, config) {
+  const { contract } = makeContract(config);
+  return BigInt((await contract.get_counter(address)).toString());
+}
+
+// src/starknet/marketplace1155/orders.ts
+var _contractCache2 = /* @__PURE__ */ new WeakMap();
+function getContract(config) {
+  let c = _contractCache2.get(config);
+  if (!c) {
+    c = newContract(Medialane1155ABI, config.marketplace1155Contract, getProvider(config));
+    _contractCache2.set(config, c);
+  }
+  return c;
+}
+async function getOrderDetails1155(orderHash, config) {
+  const contract = getContract(config);
+  return contract.get_order_details(orderHash);
+}
+async function getCounter1155(address, config) {
+  const contract = getContract(config);
+  return BigInt((await contract.get_counter(address)).toString());
+}
+var STARKNET_DOMAIN = [
+  { name: "name", type: "shortstring" },
+  { name: "version", type: "shortstring" },
+  { name: "chainId", type: "shortstring" },
+  { name: "revision", type: "shortstring" }
+];
+var OFFER_ITEM = [
+  { name: "item_type", type: "shortstring" },
+  { name: "token", type: "ContractAddress" },
+  { name: "identifier_or_criteria", type: "felt" },
+  { name: "amount", type: "felt" }
+];
+var CONSIDERATION_ITEM = [
+  { name: "item_type", type: "shortstring" },
+  { name: "token", type: "ContractAddress" },
+  { name: "identifier_or_criteria", type: "felt" },
+  { name: "amount", type: "felt" },
+  { name: "recipient", type: "ContractAddress" }
+];
+var ORDER_PARAMETERS = [
+  { name: "offerer", type: "ContractAddress" },
+  { name: "marketplace", type: "ContractAddress" },
+  { name: "offer", type: "OfferItem" },
+  { name: "consideration", type: "ConsiderationItem" },
+  { name: "royalty_max_bps", type: "felt" },
+  { name: "start_time", type: "felt" },
+  { name: "end_time", type: "felt" },
+  { name: "salt", type: "felt" },
+  { name: "counter", type: "felt" }
+];
+var ORDER_CANCELLATION = [
+  { name: "order_hash", type: "felt" },
+  { name: "offerer", type: "ContractAddress" }
+];
+var DOMAIN_VERSION = {
+  erc721: "5",
+  erc1155: "4"
+};
+function buildDomain(standard, chainId) {
+  return {
+    name: "Medialane",
+    version: DOMAIN_VERSION[standard],
+    chainId,
+    revision: starknet.TypedDataRevision.ACTIVE
+  };
+}
+function buildOrderTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc721", chainId),
+    primaryType: "OrderParameters",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderParameters: ORDER_PARAMETERS,
+      OfferItem: OFFER_ITEM,
+      ConsiderationItem: CONSIDERATION_ITEM
+    },
+    message
+  };
+}
+function build1155OrderTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc1155", chainId),
+    primaryType: "OrderParameters",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderParameters: ORDER_PARAMETERS,
+      OfferItem: OFFER_ITEM,
+      ConsiderationItem: CONSIDERATION_ITEM
+    },
+    message
+  };
+}
+function buildCancellationTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc721", chainId),
+    primaryType: "OrderCancellation",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderCancellation: ORDER_CANCELLATION
+    },
+    message
+  };
+}
+function build1155CancellationTypedData(message, chainId) {
+  return {
+    domain: buildDomain("erc1155", chainId),
+    primaryType: "OrderCancellation",
+    types: {
+      StarknetDomain: STARKNET_DOMAIN,
+      OrderCancellation: ORDER_CANCELLATION
+    },
+    message
+  };
+}
+
+// src/starknet/marketplace/build.ts
+function contractFor(cfg) {
+  return newContract(IPMarketplaceABI, cfg.marketplaceContract, getProvider(cfg));
+}
+function buildListingOrder(i, cfg) {
+  const orderParams = {
+    offerer: i.offerer,
+    marketplace: cfg.marketplaceContract,
+    offer: { item_type: "ERC721", token: i.nftContract, identifier_or_criteria: i.tokenId, amount: "1" },
+    consideration: {
+      item_type: "ERC20",
+      token: i.paymentTokenAddress,
+      identifier_or_criteria: "0",
+      amount: i.priceWei,
+      recipient: i.offerer
+    },
+    royalty_max_bps: i.royaltyMaxBps,
+    start_time: String(i.startTime),
+    end_time: String(i.endTime),
+    salt: i.salt,
+    counter: i.counter
+  };
+  const typedData = stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
+  return { orderParams, typedData };
+}
+function buildOfferOrder(i, cfg) {
+  const orderParams = {
+    offerer: i.offerer,
+    marketplace: cfg.marketplaceContract,
+    offer: { item_type: "ERC20", token: i.paymentTokenAddress, identifier_or_criteria: "0", amount: i.priceWei },
+    consideration: {
+      item_type: "ERC721",
+      token: i.nftContract,
+      identifier_or_criteria: i.tokenId,
+      amount: "1",
+      recipient: i.offerer
+    },
+    royalty_max_bps: i.royaltyMaxBps,
+    start_time: String(i.startTime),
+    end_time: String(i.endTime),
+    salt: i.salt,
+    counter: i.counter
+  };
+  const typedData = stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
+  return { orderParams, typedData };
+}
+function registerPayload(orderParams, signature) {
+  return stringifyBigInts({
+    parameters: {
+      ...orderParams,
+      offer: { ...orderParams.offer, item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type) },
+      consideration: {
+        ...orderParams.consideration,
+        item_type: starknet.shortString.encodeShortString(orderParams.consideration.item_type)
+      }
+    },
+    signature
+  });
+}
+function buildRegisterCalls(a, cfg) {
+  const registerCall = contractFor(cfg).populate("register_order", [registerPayload(a.orderParams, a.signature)]);
+  return a.approvalNeeded ? [a.approve, registerCall] : [registerCall];
+}
+function buildFulfillCalls(a, cfg) {
+  const u = starknet.cairo.uint256(a.totalPrice);
+  const approve = {
+    contractAddress: a.paymentToken,
+    entrypoint: "approve",
+    calldata: [cfg.marketplaceContract, u.low.toString(), u.high.toString()]
+  };
+  const fulfill = contractFor(cfg).populate("fulfill_order", [a.orderHash]);
+  const fee = buildFeeCall(
+    { surface: "marketplace", token: a.paymentToken, grossAmount: BigInt(a.totalPrice) },
+    cfg.feeConfig
+  );
+  return fee ? [approve, fulfill, fee] : [approve, fulfill];
+}
+function buildCancelCalls(a, cfg) {
+  const cancelRequest = stringifyBigInts({
+    cancelation: { order_hash: a.orderHash, offerer: a.offerer },
+    signature: a.signature
+  });
+  return [contractFor(cfg).populate("cancel_order", [cancelRequest])];
+}
+function buildCancelTypedData(orderHash, offerer, cfg) {
+  return stringifyBigInts(buildCancellationTypedData({ order_hash: orderHash, offerer }, getChainId(cfg)));
+}
+function contractFor2(cfg) {
+  return newContract(Medialane1155ABI, cfg.marketplace1155Contract, getProvider(cfg));
+}
+function buildListing1155Order(i, cfg) {
+  const orderParams = {
+    offerer: i.offerer,
+    marketplace: cfg.marketplace1155Contract,
+    offer: { item_type: "ERC1155", token: i.nftContract, identifier_or_criteria: i.tokenId, amount: i.quantity },
+    consideration: {
+      item_type: "ERC20",
+      token: i.paymentTokenAddress,
+      identifier_or_criteria: "0",
+      amount: i.priceWeiPerUnit,
+      recipient: i.offerer
+    },
+    royalty_max_bps: i.royaltyMaxBps,
+    start_time: String(i.startTime),
+    end_time: String(i.endTime),
+    salt: i.salt,
+    counter: i.counter
+  };
+  const typedData = stringifyBigInts(
+    build1155OrderTypedData(orderParams, getChainId(cfg))
+  );
+  return { orderParams, typedData };
+}
+function buildOffer1155Order(i, cfg) {
+  const orderParams = {
+    offerer: i.offerer,
+    marketplace: cfg.marketplace1155Contract,
+    offer: { item_type: "ERC20", token: i.paymentTokenAddress, identifier_or_criteria: "0", amount: i.priceWeiPerUnit },
+    consideration: {
+      item_type: "ERC1155",
+      token: i.nftContract,
+      identifier_or_criteria: i.tokenId,
+      amount: i.quantity,
+      recipient: i.offerer
+    },
+    royalty_max_bps: i.royaltyMaxBps,
+    start_time: String(i.startTime),
+    end_time: String(i.endTime),
+    salt: i.salt,
+    counter: i.counter
+  };
+  const typedData = stringifyBigInts(
+    build1155OrderTypedData(orderParams, getChainId(cfg))
+  );
+  return { orderParams, typedData };
+}
+function registerPayload2(orderParams, signature) {
+  return stringifyBigInts({
+    parameters: {
+      ...orderParams,
+      offer: { ...orderParams.offer, item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type) },
+      consideration: {
+        ...orderParams.consideration,
+        item_type: starknet.shortString.encodeShortString(orderParams.consideration.item_type)
+      }
+    },
+    signature
+  });
+}
+function buildRegister1155Calls(a, cfg) {
+  const registerCall = contractFor2(cfg).populate("register_order", [registerPayload2(a.orderParams, a.signature)]);
+  return a.approvalNeeded ? [a.approve, registerCall] : [registerCall];
+}
+function buildFulfill1155Calls(a, cfg) {
+  const u = starknet.cairo.uint256(a.totalPrice);
+  const approve = {
+    contractAddress: a.paymentToken,
+    entrypoint: "approve",
+    calldata: [cfg.marketplace1155Contract, u.low.toString(), u.high.toString()]
+  };
+  const fulfill = contractFor2(cfg).populate("fulfill_order", [a.orderHash, a.quantity]);
+  const fee = buildFeeCall(
+    { surface: "marketplace", token: a.paymentToken, grossAmount: BigInt(a.totalPrice) },
+    cfg.feeConfig
+  );
+  return fee ? [approve, fulfill, fee] : [approve, fulfill];
+}
+function buildCancel1155Calls(a, cfg) {
+  const cancelPayload = stringifyBigInts({
+    cancelation: { order_hash: a.orderHash, offerer: a.offerer },
+    signature: a.signature
+  });
+  return [contractFor2(cfg).populate("cancel_order", [cancelPayload])];
+}
+function buildCancel1155TypedData(orderHash, offerer, cfg) {
+  return stringifyBigInts(
+    build1155CancellationTypedData({ order_hash: orderHash, offerer }, getChainId(cfg))
+  );
+}
+
+// src/starknet/venue.ts
 var NO_EXPIRY_SECONDS = 100 * 365 * 24 * 3600;
 var StarknetVenue = class {
   constructor(deps) {
     this.deps = deps;
     this.chain = "STARKNET";
-    this.m721 = new MarketplaceModule(deps.config);
-    this.m1155 = new Medialane1155Module(deps.config);
   }
-  incrementCounter(signer) {
-    return this.m721.incrementCounter(signer);
+  async incrementCounter(signer) {
+    return signer.execute([
+      { contractAddress: this.deps.config.marketplaceContract, entrypoint: "increment_counter", calldata: [] }
+    ]);
   }
   getOrderDetails(orderRef) {
-    return this.m721.getOrderDetails(orderRef);
+    return getOrderDetails(orderRef, this.deps.config);
   }
-  getCounter(address) {
-    return this.m721.getCounter(address);
+  async getCounter(address) {
+    return this.readCounter(this.deps.config.marketplaceContract, address);
   }
   async fulfillOrder(signer, orderRef, opts) {
     const o = await this.deps.resolveOrder(orderRef);
     const quantity = opts?.quantity ?? "1";
     const totalPrice = (BigInt(o.unitPrice) * BigInt(quantity)).toString();
-    if (o.standard === "ERC1155") {
-      return this.m1155.fulfillOrder(signer, {
-        orderHash: orderRef,
-        paymentToken: o.paymentToken,
-        totalPrice,
-        quantity
-      });
-    }
-    return this.m721.fulfillOrder(signer, {
-      orderHash: orderRef,
-      paymentToken: o.paymentToken,
-      totalPrice
-    });
+    const calls = o.standard === "ERC1155" ? buildFulfill1155Calls({ orderHash: orderRef, paymentToken: o.paymentToken, totalPrice, quantity }, this.deps.config) : buildFulfillCalls({ orderHash: orderRef, paymentToken: o.paymentToken, totalPrice }, this.deps.config);
+    return signer.execute(calls);
   }
   async cancelOrder(signer, orderRef) {
     const o = await this.deps.resolveOrder(orderRef);
-    if (o.standard === "ERC1155") {
-      return this.m1155.cancelOrder(signer, { orderHash: orderRef });
-    }
-    return this.m721.cancelOrder(signer, { orderHash: orderRef });
+    const typedData = o.standard === "ERC1155" ? buildCancel1155TypedData(orderRef, signer.address, this.deps.config) : buildCancelTypedData(orderRef, signer.address, this.deps.config);
+    const signature = await signer.signTypedData(typedData);
+    const calls = o.standard === "ERC1155" ? buildCancel1155Calls({ orderHash: orderRef, offerer: signer.address, signature }, this.deps.config) : buildCancelCalls({ orderHash: orderRef, offerer: signer.address, signature }, this.deps.config);
+    return signer.execute(calls);
   }
   async registerOrder(signer, p) {
     const standard = await this.deps.resolveStandard(p.asset.contract);
-    const token = resolveToken(p.paymentToken);
-    const humanPrice = formatAmount(p.amount, token.decimals);
-    const durationSeconds = this.durationSeconds(p.endTime);
+    const paymentTokenAddress = resolveToken(p.paymentToken).address;
     const royaltyMaxBps = String(p.royaltyMaxBps);
+    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";
-    let txHash;
+    const marketplace = standard === "ERC1155" ? this.deps.config.marketplace1155Contract : this.deps.config.marketplaceContract;
+    const counter = String(await this.readCounter(marketplace, signer.address));
+    let typedData;
+    let buildCalls;
     if (standard === "ERC1155") {
-      if (p.side === "listing") {
-        const res = await this.m1155.createListing(signer, {
+      const built = (p.side === "listing" ? buildListing1155Order : buildOffer1155Order)(
+        {
+          offerer: signer.address,
           nftContract: p.asset.contract,
           tokenId: p.asset.tokenId,
-          amount: quantity,
-          pricePerUnit: humanPrice,
-          currency: p.paymentToken,
-          durationSeconds,
-          royaltyMaxBps
-        });
-        txHash = res.txHash;
-      } else {
-        const totalHuman = formatAmount((BigInt(p.amount) * BigInt(quantity)).toString(), token.decimals);
-        const res = await this.m1155.makeOffer(signer, {
+          quantity,
+          priceWeiPerUnit: p.amount,
+          paymentTokenAddress,
+          royaltyMaxBps,
+          startTime,
+          endTime,
+          salt: p.salt,
+          counter
+        },
+        this.deps.config
+      );
+      typedData = built.typedData;
+      const approval = p.side === "listing" ? await this.approval1155ForListing(signer.address, p.asset.contract) : this.approvalForErc20(paymentTokenAddress, (BigInt(p.amount) * BigInt(quantity)).toString(), marketplace);
+      buildCalls = (sig) => buildRegister1155Calls({ orderParams: built.orderParams, signature: sig, ...approval }, this.deps.config);
+    } else {
+      const built = (p.side === "listing" ? buildListingOrder : buildOfferOrder)(
+        {
+          offerer: signer.address,
           nftContract: p.asset.contract,
           tokenId: p.asset.tokenId,
-          amount: quantity,
-          price: totalHuman,
-          currency: p.paymentToken,
-          durationSeconds,
-          royaltyMaxBps
-        });
-        txHash = res.txHash;
-      }
-    } else {
-      const params = {
-        nftContract: p.asset.contract,
-        tokenId: p.asset.tokenId,
-        price: humanPrice,
-        currency: p.paymentToken,
-        durationSeconds,
-        royaltyMaxBps
-      };
-      const res = p.side === "listing" ? await this.m721.createListing(signer, params) : await this.m721.makeOffer(signer, params);
-      txHash = res.txHash;
+          priceWei: p.amount,
+          paymentTokenAddress,
+          royaltyMaxBps,
+          startTime,
+          endTime,
+          salt: p.salt,
+          counter
+        },
+        this.deps.config
+      );
+      typedData = built.typedData;
+      const approval = p.side === "listing" ? await this.approval721ForListing(signer.address, p.asset.contract, p.asset.tokenId) : this.approvalForErc20(paymentTokenAddress, p.amount, marketplace);
+      buildCalls = (sig) => buildRegisterCalls({ orderParams: built.orderParams, signature: sig, ...approval }, this.deps.config);
     }
+    const signature = await signer.signTypedData(typedData);
+    const { txHash } = await signer.execute(buildCalls(signature));
     const orderRef = await this.orderRefFromReceipt(txHash);
     return { txHash, orderRef };
   }
-  durationSeconds(endTime) {
-    if (!endTime) return NO_EXPIRY_SECONDS;
-    return Math.max(1, endTime - Math.floor(Date.now() / 1e3));
+  // ─── reads (all on deps.provider) ─────────────────────────────────────────
+  async readCounter(marketplace, address) {
+    const res = await this.deps.provider.callContract({
+      contractAddress: marketplace,
+      entrypoint: "get_counter",
+      calldata: [address]
+    });
+    return BigInt(res[0] ?? "0");
+  }
+  /** 721 listing approval: `get_approved(tokenId) == marketplace` ⇒ no approve. */
+  async approval721ForListing(_owner, nftContract, tokenId) {
+    const id = starknet.cairo.uint256(tokenId);
+    const approve = {
+      contractAddress: nftContract,
+      entrypoint: "approve",
+      calldata: [this.deps.config.marketplaceContract, id.low.toString(), id.high.toString()]
+    };
+    let approved = false;
+    try {
+      const res = await this.deps.provider.callContract({
+        contractAddress: nftContract,
+        entrypoint: "get_approved",
+        calldata: [id.low.toString(), id.high.toString()]
+      });
+      approved = BigInt(res[0]).toString() === BigInt(this.deps.config.marketplaceContract).toString();
+    } catch {
+    }
+    return { approvalNeeded: !approved, approve };
+  }
+  /** 1155 listing approval: `is_approved_for_all(owner, marketplace)`. */
+  async approval1155ForListing(owner, nftContract) {
+    const approve = {
+      contractAddress: nftContract,
+      entrypoint: "set_approval_for_all",
+      calldata: [this.deps.config.marketplace1155Contract, "1"]
+    };
+    let approved = false;
+    try {
+      const res = await this.deps.provider.callContract({
+        contractAddress: nftContract,
+        entrypoint: "is_approved_for_all",
+        calldata: [owner, this.deps.config.marketplace1155Contract]
+      });
+      approved = BigInt(res[0]) === 1n;
+    } catch {
+    }
+    return { approvalNeeded: !approved, approve };
+  }
+  /** Offers always approve the ERC-20 spend (no read). */
+  approvalForErc20(token, amountWei, marketplace) {
+    const u = starknet.cairo.uint256(amountWei);
+    return {
+      approvalNeeded: true,
+      approve: {
+        contractAddress: token,
+        entrypoint: "approve",
+        calldata: [marketplace, u.low.toString(), u.high.toString()]
+      }
+    };
   }
   /** The canonical Starknet order id = the contract-emitted `OrderCreated`
    *  hash (`keys[1]`), which is exactly what the indexer stores. */
@@ -13350,6 +12884,30 @@ function buybackQuoteRaw(teamCoinsRawValue, quoteDecimals) {
 function fdvHuman(supplyHuman) {
   return supplyHuman * LAUNCH_PRICE_QUOTE_PER_COIN;
 }
+function encodeByteArray(str) {
+  const bytes = new TextEncoder().encode(str);
+  const fullChunks = [];
+  let i = 0;
+  while (i + 31 <= bytes.length) {
+    let val = 0n;
+    for (const b of bytes.slice(i, i + 31)) {
+      val = val << 8n | BigInt(b);
+    }
+    fullChunks.push(starknet.num.toHex(val));
+    i += 31;
+  }
+  const remaining = bytes.slice(i);
+  let pendingVal = 0n;
+  for (const b of remaining) {
+    pendingVal = pendingVal << 8n | BigInt(b);
+  }
+  return [
+    fullChunks.length.toString(),
+    ...fullChunks,
+    starknet.num.toHex(pendingVal),
+    remaining.length.toString()
+  ];
+}
 
 exports.ADMIN_HEADERS = ADMIN_HEADERS;
 exports.ADMIN_SCOPE = ADMIN_SCOPE;
@@ -13382,9 +12940,7 @@ exports.IPSponsorshipLicenseABI = IPSponsorshipLicenseABI;
 exports.IPTicketCollectionABI = IPTicketCollectionABI;
 exports.IPTicketCollectionFactoryABI = IPTicketCollectionFactoryABI;
 exports.LAUNCH_PRICE_QUOTE_PER_COIN = LAUNCH_PRICE_QUOTE_PER_COIN;
-exports.MarketplaceModule = MarketplaceModule;
 exports.Medialane1155ABI = Medialane1155ABI;
-exports.Medialane1155Module = Medialane1155Module;
 exports.MedialaneApiError = MedialaneApiError;
 exports.MedialaneClient = MedialaneClient;
 exports.MedialaneError = MedialaneError;
@@ -13449,8 +13005,12 @@ exports.encodeByteArray = encodeByteArray;
 exports.fdvHuman = fdvHuman;
 exports.formatAmount = formatAmount;
 exports.getCoordinates = getCoordinates;
+exports.getCounter = getCounter;
+exports.getCounter1155 = getCounter1155;
 exports.getCreatorCoinPrice = getCreatorCoinPrice;
 exports.getListableTokens = getListableTokens;
+exports.getOrderDetails = getOrderDetails;
+exports.getOrderDetails1155 = getOrderDetails1155;
 exports.getService = getService;
 exports.getServicesByCapability = getServicesByCapability;
 exports.getSiwsStorageKey = getSiwsStorageKey;