@medialane/sdk 0.55.0 → 0.57.0

package/dist/starknet/index.cjs

@@ -8592,39 +8592,12 @@ var SUPPORTED_TOKENS = [
 ];
 var DEFAULT_CURRENCY = "USDC";
 
-// src/utils/bigint.ts
-function stringifyBigInts(obj) {
-  if (typeof obj === "bigint") {
-    return obj.toString();
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(stringifyBigInts);
-  }
-  if (obj !== null && typeof obj === "object") {
-    return Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => [
-        key,
-        stringifyBigInts(value)
-      ])
-    );
-  }
-  return obj;
-}
-
 // src/utils/token.ts
 function parseAmount(human, decimals) {
   const [whole, frac = ""] = human.split(".");
   const fracPadded = frac.padEnd(decimals, "0").slice(0, decimals);
   return (BigInt(whole) * BigInt(10) ** BigInt(decimals) + BigInt(fracPadded)).toString();
 }
-function formatAmount(raw, decimals) {
-  const value = BigInt(raw);
-  const factor = BigInt(Math.pow(10, decimals));
-  const whole = value / factor;
-  const remainder = value % factor;
-  const fractional = remainder.toString().padStart(decimals, "0");
-  return `${whole}.${fractional}`;
-}
 function getTokenByAddress(address) {
   const lower = address.toLowerCase();
   return SUPPORTED_TOKENS.find((t) => t.address.toLowerCase() === lower);
@@ -8653,6 +8626,25 @@ function buildFeeCall(p, cfg) {
   };
 }
 
+// src/utils/bigint.ts
+function stringifyBigInts(obj) {
+  if (typeof obj === "bigint") {
+    return obj.toString();
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(stringifyBigInts);
+  }
+  if (obj !== null && typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        stringifyBigInts(value)
+      ])
+    );
+  }
+  return obj;
+}
+
 // src/utils/rpc.ts
 var PUBLIC_RPC_FALLBACKS = [
   "https://rpc.starknet.lava.build"
@@ -8757,6 +8749,94 @@ function getProvider(config) {
   return p;
 }
 
+// src/starknet/marketplace/build.ts
+function contractFor(cfg) {
+  return new starknet.Contract(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)));
+}
+
 // src/starknet/marketplace/orders.ts
 var _contractCache = /* @__PURE__ */ new WeakMap();
 function makeContract(config) {
@@ -8781,46 +8861,22 @@ async function createListing(account, params, config) {
   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)
-      }
+  const { orderParams, typedData } = buildListingOrder(
+    {
+      offerer: account.address,
+      nftContract,
+      tokenId,
+      priceWei,
+      paymentTokenAddress: token.address,
+      royaltyMaxBps,
+      startTime,
+      endTime,
+      salt: generateSalt(),
+      counter
     },
-    signature: signatureArray
-  });
+    config
+  );
+  const signatureArray = toSignatureArray(await account.signMessage(typedData));
   const tokenIdUint256 = starknet.cairo.uint256(tokenId);
   let isAlreadyApproved = false;
   try {
@@ -8832,19 +8888,19 @@ async function createListing(account, params, config) {
     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
-  ];
+  const approve = {
+    contractAddress: nftContract,
+    entrypoint: "approve",
+    calldata: [
+      config.marketplaceContract,
+      tokenIdUint256.low.toString(),
+      tokenIdUint256.high.toString()
+    ]
+  };
+  const calls = buildRegisterCalls(
+    { orderParams, signature: signatureArray, approvalNeeded: !isAlreadyApproved, approve },
+    config
+  );
   try {
     const tx = await account.execute(calls);
     await provider.waitForTransaction(tx.transaction_hash);
@@ -8863,46 +8919,22 @@ async function makeOffer(account, params, config) {
   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)
-      }
+  const { orderParams, typedData } = buildOfferOrder(
+    {
+      offerer: account.address,
+      nftContract,
+      tokenId,
+      priceWei,
+      paymentTokenAddress: token.address,
+      royaltyMaxBps,
+      startTime,
+      endTime,
+      salt: generateSalt(),
+      counter
     },
-    signature: signatureArray
-  });
+    config
+  );
+  const signatureArray = toSignatureArray(await account.signMessage(typedData));
   const amountUint256 = starknet.cairo.uint256(priceWei);
   const approveCall = {
     contractAddress: token.address,
@@ -8913,9 +8945,12 @@ async function makeOffer(account, params, config) {
       amountUint256.high.toString()
     ]
   };
-  const registerCall = contract.populate("register_order", [registerPayload]);
+  const calls = buildRegisterCalls(
+    { orderParams, signature: signatureArray, approvalNeeded: true, approve: approveCall },
+    config
+  );
   try {
-    const tx = await account.execute([approveCall, registerCall]);
+    const tx = await account.execute(calls);
     await provider.waitForTransaction(tx.transaction_hash);
     return { txHash: tx.transaction_hash };
   } catch (err) {
@@ -8924,23 +8959,8 @@ async function makeOffer(account, params, config) {
 }
 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];
+  const { provider } = makeContract(config);
+  const calls = buildFulfillCalls({ orderHash, paymentToken, totalPrice }, config);
   try {
     const tx = await account.execute(calls);
     await provider.waitForTransaction(tx.transaction_hash);
@@ -8951,24 +8971,12 @@ async function fulfillOrder(account, params, config) {
 }
 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]);
+  const { provider } = makeContract(config);
+  const typedData = buildCancelTypedData(orderHash, account.address, config);
+  const signatureArray = toSignatureArray(await account.signMessage(typedData));
+  const calls = buildCancelCalls({ orderHash, offerer: account.address, signature: signatureArray }, config);
   try {
-    const tx = await account.execute(call);
+    const tx = await account.execute(calls);
     await provider.waitForTransaction(tx.transaction_hash);
     return { txHash: tx.transaction_hash };
   } catch (err) {
@@ -9115,6 +9123,100 @@ var MarketplaceModule = class {
     return buildCancellationTypedData(params, chainId);
   }
 };
+function contractFor2(cfg) {
+  return new starknet.Contract(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/marketplace1155/orders.ts
 var _contractCache2 = /* @__PURE__ */ new WeakMap();
 function getContract(config) {
   let c = _contractCache2.get(config);
@@ -9143,53 +9245,27 @@ async function createListing1155(account, params, config) {
   const token = resolveToken(currency);
   const priceWei = parseAmount(pricePerUnit, token.decimals);
   const now = Math.floor(Date.now() / 1e3);
+  const startTime = now + START_TIME_BUFFER_SECS;
   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
+  const { orderParams, typedData } = buildListing1155Order(
+    {
+      offerer: account.address,
+      nftContract,
+      tokenId,
+      quantity: amount,
+      priceWeiPerUnit: priceWei,
+      paymentTokenAddress: token.address,
+      royaltyMaxBps,
+      startTime,
+      endTime,
+      salt: generateSalt(),
+      counter
     },
-    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)
+    config
   );
-  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
-  });
+  const signatureArray = toSignatureArray(await account.signMessage(typedData));
   let isApproved = false;
   try {
     const result = await provider.callContract({
@@ -9200,15 +9276,15 @@ async function createListing1155(account, params, config) {
     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
-  ];
+  const approve = {
+    contractAddress: nftContract,
+    entrypoint: "set_approval_for_all",
+    calldata: [config.marketplace1155Contract, "1"]
+  };
+  const calls = buildRegister1155Calls(
+    { orderParams, signature: signatureArray, approvalNeeded: !isApproved, approve },
+    config
+  );
   try {
     const tx = await account.execute(calls);
     await provider.waitForTransaction(tx.transaction_hash);
@@ -9219,21 +9295,10 @@ async function createListing1155(account, params, config) {
 }
 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]);
+  const calls = buildFulfill1155Calls({ orderHash, paymentToken, totalPrice, quantity }, config);
   try {
-    const tx = await account.execute([approveCall, fulfillCall]);
+    const tx = await account.execute(calls);
     await provider.waitForTransaction(tx.transaction_hash);
     return { txHash: tx.transaction_hash };
   } catch (err) {
@@ -9242,25 +9307,12 @@ async function fulfillOrder1155(account, params, config) {
 }
 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]);
+  const typedData = buildCancel1155TypedData(orderHash, account.address, config);
+  const signatureArray = toSignatureArray(await account.signMessage(typedData));
+  const calls = buildCancel1155Calls({ orderHash, offerer: account.address, signature: signatureArray }, config);
   try {
-    const tx = await account.execute(cancelCall);
+    const tx = await account.execute(calls);
     await provider.waitForTransaction(tx.transaction_hash);
     return { txHash: tx.transaction_hash };
   } catch (err) {
@@ -9278,56 +9330,30 @@ async function makeOffer1155(account, params, config) {
   } = 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 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.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
+  const { orderParams, typedData } = buildOffer1155Order(
+    {
+      offerer: account.address,
+      nftContract,
+      tokenId,
+      quantity: amount,
+      priceWeiPerUnit: priceWei,
+      paymentTokenAddress: token.address,
+      royaltyMaxBps,
+      startTime,
+      endTime,
+      salt: generateSalt(),
+      counter
     },
-    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)
+    config
   );
-  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 signatureArray = toSignatureArray(await account.signMessage(typedData));
   const totalWei = BigInt(priceWei) * BigInt(amount);
   const amountU256 = starknet.cairo.uint256(totalWei.toString());
   const approveCall = {
@@ -9339,9 +9365,12 @@ async function makeOffer1155(account, params, config) {
       amountU256.high.toString()
     ]
   };
-  const registerCall = contract.populate("register_order", [registerPayload]);
+  const calls = buildRegister1155Calls(
+    { orderParams, signature: signatureArray, approvalNeeded: true, approve: approveCall },
+    config
+  );
   try {
-    const tx = await account.execute([approveCall, registerCall]);
+    const tx = await account.execute(calls);
     await provider.waitForTransaction(tx.transaction_hash);
     return { txHash: tx.transaction_hash };
   } catch (err) {
@@ -10887,92 +10916,147 @@ 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);
-    if (o.standard === "ERC1155") {
-      return this.m1155.fulfillOrder(signer, {
-        orderHash: orderRef,
-        paymentToken: o.paymentToken,
-        totalPrice: o.totalPrice,
-        quantity: opts?.quantity ?? "1"
-      });
-    }
-    return this.m721.fulfillOrder(signer, {
-      orderHash: orderRef,
-      paymentToken: o.paymentToken,
-      totalPrice: o.totalPrice
-    });
+    const quantity = opts?.quantity ?? "1";
+    const totalPrice = (BigInt(o.unitPrice) * BigInt(quantity)).toString();
+    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. */