@medialane/sdk 0.62.0 → 0.64.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { base58, base32 } from '@scure/base';
-import { hash, num, cairo, Contract, uint256, RpcProvider, CairoOption, CairoOptionVariant, ec, encode, TypedDataRevision, shortString, constants } from 'starknet';
+import { hash, Contract, cairo, uint256, RpcProvider, CairoOption, CairoOptionVariant, num, ec, encode, TypedDataRevision, constants, shortString } from 'starknet';
 
 // src/config.ts
 
@@ -35,9 +35,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,
@@ -1294,124 +1294,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: 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(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()
-  ];
-}
 
 // src/starknet/abis/ipMarketplace.ts
 var IPMarketplaceABI = [
@@ -11442,13 +11324,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 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 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) {
@@ -11464,856 +11404,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 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 = 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 Contract(DropCollectionABI, normalizeAddress("STARKNET", address), account);
   }
-  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 _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 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 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: shortString.encodeShortString(orderParams.offer.item_type)
-      },
-      consideration: {
-        ...orderParams.consideration,
-        item_type: shortString.encodeShortString(orderParams.consideration.item_type)
-      }
-    },
-    signature: signatureArray
-  });
-  const tokenIdUint256 = 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: shortString.encodeShortString(orderParams.offer.item_type)
-      },
-      consideration: {
-        ...orderParams.consideration,
-        item_type: shortString.encodeShortString(orderParams.consideration.item_type)
-      }
-    },
-    signature: signatureArray
-  });
-  const amountUint256 = 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 = 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 = 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 = 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 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: shortString.encodeShortString(orderParams.offer.item_type)
-      },
-      consideration: {
-        ...orderParams.consideration,
-        item_type: 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 = 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: shortString.encodeShortString(orderParams.offer.item_type)
-      },
-      consideration: {
-        ...orderParams.consideration,
-        item_type: shortString.encodeShortString(orderParams.consideration.item_type)
-      }
-    },
-    signature: signatureArray
-  });
-  const totalWei = BigInt(priceWei) * BigInt(amount);
-  const amountU256 = 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 = 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 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 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 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", [
@@ -12939,8 +12062,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),
@@ -12983,99 +12104,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 = Contract;
+  return C.length === 1 ? new Contract({ abi, address, providerOrAccount }) : new 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 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 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: 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: shortString.encodeShortString(orderParams.offer.item_type) },
+      consideration: {
+        ...orderParams.consideration,
+        item_type: 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 = 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: shortString.encodeShortString(orderParams.offer.item_type) },
+      consideration: {
+        ...orderParams.consideration,
+        item_type: 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 = 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 = 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 = 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. */
@@ -13348,7 +12882,31 @@ 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(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 { ADMIN_HEADERS, ADMIN_SCOPE, ApiClient, CHAINS, MAX_SUPPLY as COIN_MAX_SUPPLY, MIN_SUPPLY as COIN_MIN_SUPPLY, ClubService, CreatorCoinFactoryABI, CreatorCoinService, DEFAULT_CHAIN, DEFAULT_CURRENCY, DropCollectionABI, DropFactoryABI, DropService, ERC1155CollectionService, FeeConfigSchema, IPClubABI, IPClubCollectionABI, IPClubFactoryABI, IPClubNFTABI, IPCollection1155ABI, IPCollection1155FactoryABI, IPCollectionABI, IPGenesisABI, IPMarketplaceABI, IPNftABI, IPSponsorshipABI, IPSponsorshipLicenseABI, IPTicketCollectionABI, IPTicketCollectionFactoryABI, LAUNCH_PRICE_QUOTE_PER_COIN, MarketplaceModule, Medialane1155ABI, Medialane1155Module, MedialaneApiError, MedialaneClient, MedialaneError, OPEN_LICENSES, POPCollectionABI, POPFactoryABI, PUBLIC_RPC_FALLBACKS, PopService, STARKNET_COLLECTION_1155_CLASS_HASH, STARKNET_COLLECTION_1155_CONTRACT, STARKNET_COLLECTION_1155_FACTORY_CLASS_HASH, STARKNET_COLLECTION_1155_START_BLOCK, STARKNET_COLLECTION_721_CONTRACT, STARKNET_COLLECTION_721_START_BLOCK, STARKNET_CREATOR_COIN_CLASS_HASH, STARKNET_CREATOR_COIN_EKUBO_LAUNCHER, STARKNET_CREATOR_COIN_FACTORY_CLASS_HASH, STARKNET_CREATOR_COIN_FACTORY_CONTRACT, STARKNET_CREATOR_COIN_START_BLOCK, STARKNET_DROP_COLLECTION_CLASS_HASH, STARKNET_DROP_FACTORY_CONTRACT, STARKNET_EKUBO_CORE, STARKNET_IPCOLLECTION_CLASS_HASH, STARKNET_IPNFT_CLASS_HASH, STARKNET_IP_CLUB_COLLECTION_CLASS_HASH, STARKNET_IP_CLUB_FACTORY_CONTRACT, STARKNET_IP_CLUB_NFT_CLASS_HASH, STARKNET_IP_CLUB_REGISTRY_CONTRACT, STARKNET_IP_SPONSORSHIP_CONTRACT, STARKNET_IP_SPONSORSHIP_LICENSE_CONTRACT, STARKNET_IP_TICKETS_FACTORY_CONTRACT, STARKNET_IP_TICKET_COLLECTION_CLASS_HASH, STARKNET_MARKETPLACE_1155_CLASS_HASH, STARKNET_MARKETPLACE_1155_CONTRACT, STARKNET_MARKETPLACE_1155_START_BLOCK, STARKNET_MARKETPLACE_721_CLASS_HASH, STARKNET_MARKETPLACE_721_CONTRACT, STARKNET_MARKETPLACE_721_START_BLOCK, STARKNET_NFTCOMMENTS_CONTRACT, STARKNET_POP_COLLECTION_CLASS_HASH, STARKNET_POP_FACTORY_CONTRACT, SUPPORTED_TOKENS, SponsorshipService, StarknetVenue, TicketService, VALIDATED_EKUBO_PARAMS, adminRequestDigest, build1155CancellationTypedData, build1155OrderTypedData, buildAdminSessionTypedData, buildCancellationTypedData, buildCreateCreatorCoinCall, buildFeeCall, buildLaunchOnEkuboCalls, buildOrderTypedData, buybackQuoteRaw, toRaw as coinToRaw, createAdminSessionGrant, createFailoverFetch, encodeAdminHeaders, encodeByteArray, fdvHuman, formatAmount, getCoordinates, getCreatorCoinPrice, getListableTokens, getService, getServicesByCapability, getSiwsStorageKey, getStarknetCoordinates, getStoredSiwsToken, getTokenByAddress, getTokenBySymbol, hasCapability, isServiceId, isSiwsTokenValid, isTransientRpcError, listServices, normalizeAddress, normalizeHash, normalizeSiwsSignature, parseAdminHeaders, parseAmount, parseCreatorCoinCreated, randomNonce, requestSiwsToken, resolveConfig, resolveFeeConfig, sessionKeyHashOf, shortenAddress, signAdminRequest, storeSiwsToken, stringifyBigInts, teamCoinsRaw, u256ToBigInt, validateName as validateCoinName, validateSupply as validateCoinSupply, validateSymbol as validateCoinSymbol, verifyAdminRequestSig };
+export { ADMIN_HEADERS, ADMIN_SCOPE, ApiClient, CHAINS, MAX_SUPPLY as COIN_MAX_SUPPLY, MIN_SUPPLY as COIN_MIN_SUPPLY, ClubService, CreatorCoinFactoryABI, CreatorCoinService, DEFAULT_CHAIN, DEFAULT_CURRENCY, DropCollectionABI, DropFactoryABI, DropService, ERC1155CollectionService, FeeConfigSchema, IPClubABI, IPClubCollectionABI, IPClubFactoryABI, IPClubNFTABI, IPCollection1155ABI, IPCollection1155FactoryABI, IPCollectionABI, IPGenesisABI, IPMarketplaceABI, IPNftABI, IPSponsorshipABI, IPSponsorshipLicenseABI, IPTicketCollectionABI, IPTicketCollectionFactoryABI, LAUNCH_PRICE_QUOTE_PER_COIN, Medialane1155ABI, MedialaneApiError, MedialaneClient, MedialaneError, OPEN_LICENSES, POPCollectionABI, POPFactoryABI, PUBLIC_RPC_FALLBACKS, PopService, STARKNET_COLLECTION_1155_CLASS_HASH, STARKNET_COLLECTION_1155_CONTRACT, STARKNET_COLLECTION_1155_FACTORY_CLASS_HASH, STARKNET_COLLECTION_1155_START_BLOCK, STARKNET_COLLECTION_721_CONTRACT, STARKNET_COLLECTION_721_START_BLOCK, STARKNET_CREATOR_COIN_CLASS_HASH, STARKNET_CREATOR_COIN_EKUBO_LAUNCHER, STARKNET_CREATOR_COIN_FACTORY_CLASS_HASH, STARKNET_CREATOR_COIN_FACTORY_CONTRACT, STARKNET_CREATOR_COIN_START_BLOCK, STARKNET_DROP_COLLECTION_CLASS_HASH, STARKNET_DROP_FACTORY_CONTRACT, STARKNET_EKUBO_CORE, STARKNET_IPCOLLECTION_CLASS_HASH, STARKNET_IPNFT_CLASS_HASH, STARKNET_IP_CLUB_COLLECTION_CLASS_HASH, STARKNET_IP_CLUB_FACTORY_CONTRACT, STARKNET_IP_CLUB_NFT_CLASS_HASH, STARKNET_IP_CLUB_REGISTRY_CONTRACT, STARKNET_IP_SPONSORSHIP_CONTRACT, STARKNET_IP_SPONSORSHIP_LICENSE_CONTRACT, STARKNET_IP_TICKETS_FACTORY_CONTRACT, STARKNET_IP_TICKET_COLLECTION_CLASS_HASH, STARKNET_MARKETPLACE_1155_CLASS_HASH, STARKNET_MARKETPLACE_1155_CONTRACT, STARKNET_MARKETPLACE_1155_START_BLOCK, STARKNET_MARKETPLACE_721_CLASS_HASH, STARKNET_MARKETPLACE_721_CONTRACT, STARKNET_MARKETPLACE_721_START_BLOCK, STARKNET_NFTCOMMENTS_CONTRACT, STARKNET_POP_COLLECTION_CLASS_HASH, STARKNET_POP_FACTORY_CONTRACT, SUPPORTED_TOKENS, SponsorshipService, StarknetVenue, TicketService, VALIDATED_EKUBO_PARAMS, adminRequestDigest, build1155CancellationTypedData, build1155OrderTypedData, buildAdminSessionTypedData, buildCancellationTypedData, buildCreateCreatorCoinCall, buildFeeCall, buildLaunchOnEkuboCalls, buildOrderTypedData, buybackQuoteRaw, toRaw as coinToRaw, createAdminSessionGrant, createFailoverFetch, encodeAdminHeaders, encodeByteArray, fdvHuman, formatAmount, getCoordinates, getCounter, getCounter1155, getCreatorCoinPrice, getListableTokens, getOrderDetails, getOrderDetails1155, getService, getServicesByCapability, getSiwsStorageKey, getStarknetCoordinates, getStoredSiwsToken, getTokenByAddress, getTokenBySymbol, hasCapability, isServiceId, isSiwsTokenValid, isTransientRpcError, listServices, normalizeAddress, normalizeHash, normalizeSiwsSignature, parseAdminHeaders, parseAmount, parseCreatorCoinCreated, randomNonce, requestSiwsToken, resolveConfig, resolveFeeConfig, sessionKeyHashOf, shortenAddress, signAdminRequest, storeSiwsToken, stringifyBigInts, teamCoinsRaw, u256ToBigInt, validateName as validateCoinName, validateSupply as validateCoinSupply, validateSymbol as validateCoinSymbol, verifyAdminRequestSig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map