@medialane/sdk 0.8.3 → 0.9.1

package/dist/index.cjs

@@ -194,6 +194,30 @@ function buildCancellationTypedData(message, chainId) {
     message
   };
 }
+function encodeByteArray(str) {
+  const bytes = new TextEncoder().encode(str);
+  const fullChunks = [];
+  let i = 0;
+  while (i + 31 <= bytes.length) {
+    let val = 0n;
+    for (const b of bytes.slice(i, i + 31)) {
+      val = val << 8n | BigInt(b);
+    }
+    fullChunks.push(starknet.num.toHex(val));
+    i += 31;
+  }
+  const remaining = bytes.slice(i);
+  let pendingVal = 0n;
+  for (const b of remaining) {
+    pendingVal = pendingVal << 8n | BigInt(b);
+  }
+  return [
+    fullChunks.length.toString(),
+    ...fullChunks,
+    starknet.num.toHex(pendingVal),
+    remaining.length.toString()
+  ];
+}
 
 // src/abis.ts
 var IPMarketplaceABI = [
@@ -1679,7 +1703,7 @@ function getListableTokens() {
   return SUPPORTED_TOKENS.filter((t) => t.listable);
 }
 
-// src/marketplace/orders.ts
+// src/marketplace/errors.ts
 var MedialaneError = class extends Error {
   constructor(message, code = "UNKNOWN", cause) {
     super(message);
@@ -1688,6 +1712,7 @@ var MedialaneError = class extends Error {
     this.name = "MedialaneError";
   }
 };
+var START_TIME_BUFFER_SECS = 30;
 function toSignatureArray(sig) {
   if (Array.isArray(sig)) return sig;
   const s = sig;
@@ -1696,35 +1721,36 @@ function toSignatureArray(sig) {
 function getChainId(_config) {
   return starknet.constants.StarknetChainId.SN_MAIN;
 }
-var _contractCache = /* @__PURE__ */ new WeakMap();
+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 provider = _providerCache.get(config);
-  if (!provider) {
-    provider = new starknet.RpcProvider({ nodeUrl: config.rpcUrl });
-    _providerCache.set(config, provider);
+  let p = _providerCache.get(config);
+  if (!p) {
+    p = new starknet.RpcProvider({ nodeUrl: config.rpcUrl });
+    _providerCache.set(config, p);
   }
-  return provider;
+  return p;
 }
+
+// src/marketplace/orders.ts
+var _contractCache = /* @__PURE__ */ new WeakMap();
 function makeContract(config) {
   const cached = _contractCache.get(config);
-  if (cached) return cached;
   const provider = getProvider(config);
+  if (cached) return { ...cached, provider };
   const contract = new starknet.Contract(
     IPMarketplaceABI,
     config.marketplaceContract,
     provider
   );
-  const result = { contract, provider };
-  _contractCache.set(config, result);
-  return result;
-}
-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;
+  _contractCache.set(config, { contract });
+  return { contract, provider };
 }
 async function createListing(account, params, config) {
   const { nftContract, tokenId, price, currency = DEFAULT_CURRENCY, durationSeconds } = params;
@@ -1732,7 +1758,7 @@ async function createListing(account, params, config) {
   const token = resolveToken(currency);
   const priceWei = parseAmount(price, token.decimals);
   const now = Math.floor(Date.now() / 1e3);
-  const startTime = now + 300;
+  const startTime = now + START_TIME_BUFFER_SECS;
   const endTime = now + durationSeconds;
   const saltBytes = new Uint8Array(4);
   crypto.getRandomValues(saltBytes);
@@ -1816,7 +1842,7 @@ async function makeOffer(account, params, config) {
   const token = resolveToken(currency);
   const priceWei = parseAmount(price, token.decimals);
   const now = Math.floor(Date.now() / 1e3);
-  const startTime = now + 300;
+  const startTime = now + START_TIME_BUFFER_SECS;
   const endTime = now + durationSeconds;
   const saltBytes = new Uint8Array(4);
   crypto.getRandomValues(saltBytes);
@@ -1882,7 +1908,7 @@ async function makeOffer(account, params, config) {
   }
 }
 async function fulfillOrder(account, params, config) {
-  const { orderHash } = params;
+  const { orderHash, paymentToken, totalPrice } = params;
   const { contract, provider } = makeContract(config);
   const currentNonce = await contract.nonces(account.address);
   const chainId = getChainId();
@@ -1900,9 +1926,19 @@ async function fulfillOrder(account, params, config) {
     fulfillment: fulfillmentParams,
     signature: signatureArray
   });
-  const call = contract.populate("fulfill_order", [fulfillPayload]);
+  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", [fulfillPayload]);
   try {
-    const tx = await account.execute(call);
+    const tx = await account.execute([approveCall, fulfillCall]);
     await provider.waitForTransaction(tx.transaction_hash);
     return { txHash: tx.transaction_hash };
   } catch (err) {
@@ -1937,15 +1973,6 @@ async function cancelOrder(account, params, config) {
     throw new MedialaneError("Failed to cancel order", "TRANSACTION_FAILED", err);
   }
 }
-function encodeByteArray(str) {
-  const ba = starknet.byteArray.byteArrayFromString(str);
-  return [
-    ba.data.length.toString(),
-    ...ba.data.map((d) => starknet.num.toHex(d)),
-    starknet.num.toHex(ba.pending_word),
-    ba.pending_word_len.toString()
-  ];
-}
 async function mint(account, params, config) {
   const { collectionId, recipient, tokenUri, collectionContract } = params;
   const provider = getProvider(config);
@@ -2028,6 +2055,14 @@ async function checkoutCart(account, items, config) {
     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 getNonce(address, config) {
+  const { contract } = makeContract(config);
+  return BigInt((await contract.nonces(address)).toString());
+}
 
 // src/marketplace/index.ts
 var MarketplaceModule = class {
@@ -2056,6 +2091,13 @@ var MarketplaceModule = class {
   createCollection(account, params) {
     return createCollection(account, params, this.config);
   }
+  // ─── View calls ───────────────────────────────────────────────────────────
+  getOrderDetails(orderHash) {
+    return getOrderDetails(orderHash, this.config);
+  }
+  getNonce(address) {
+    return getNonce(address, this.config);
+  }
   // ─── Typed data builders (for ChipiPay / custom signing flows) ───────────
   buildListingTypedData(params, chainId) {
     return buildOrderTypedData(params, chainId);
@@ -2146,28 +2188,11 @@ function build1155CancellationTypedData(message, chainId) {
     message
   };
 }
-function toSignatureArray2(sig) {
-  if (Array.isArray(sig)) return sig;
-  const s = sig;
-  return [s.r.toString(), s.s.toString()];
-}
-function getChainId2(_config) {
-  return starknet.constants.StarknetChainId.SN_MAIN;
-}
-var _providerCache2 = /* @__PURE__ */ new WeakMap();
 var _contractCache2 = /* @__PURE__ */ new WeakMap();
-function getProvider2(config) {
-  let p = _providerCache2.get(config);
-  if (!p) {
-    p = new starknet.RpcProvider({ nodeUrl: config.rpcUrl });
-    _providerCache2.set(config, p);
-  }
-  return p;
-}
 function getContract(config) {
   let c = _contractCache2.get(config);
   if (!c) {
-    const provider = getProvider2(config);
+    const provider = getProvider(config);
     c = new starknet.Contract(
       Medialane1155ABI,
       config.marketplace1155Contract,
@@ -2177,13 +2202,6 @@ function getContract(config) {
   }
   return c;
 }
-function resolveToken2(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;
-}
 async function createListing1155(account, params, config) {
   const {
     nftContract,
@@ -2194,8 +2212,8 @@ async function createListing1155(account, params, config) {
     durationSeconds
   } = params;
   const contract = getContract(config);
-  const provider = getProvider2(config);
-  const token = resolveToken2(currency);
+  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;
@@ -2203,7 +2221,7 @@ async function createListing1155(account, params, config) {
   crypto.getRandomValues(saltBytes);
   const salt = new DataView(saltBytes.buffer).getUint32(0).toString();
   const currentNonce = await contract.nonces(account.address);
-  const chainId = getChainId2();
+  const chainId = getChainId();
   const orderParams = {
     offerer: account.address,
     offer: {
@@ -2221,7 +2239,7 @@ async function createListing1155(account, params, config) {
       end_amount: priceWei,
       recipient: account.address
     },
-    start_time: now.toString(),
+    start_time: (now + START_TIME_BUFFER_SECS).toString(),
     end_time: endTime.toString(),
     salt,
     nonce: currentNonce.toString()
@@ -2230,9 +2248,19 @@ async function createListing1155(account, params, config) {
     build1155OrderTypedData(orderParams, chainId)
   );
   const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray2(signature);
+  const signatureArray = toSignatureArray(signature);
   const orderPayload = stringifyBigInts({
-    parameters: orderParams,
+    parameters: {
+      ...orderParams,
+      offer: {
+        ...orderParams.offer,
+        item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type)
+      },
+      consideration: {
+        ...orderParams.consideration,
+        item_type: starknet.shortString.encodeShortString(orderParams.consideration.item_type)
+      }
+    },
     signature: signatureArray
   });
   let isApproved = false;
@@ -2265,8 +2293,8 @@ 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 = getProvider2(config);
-  const chainId = getChainId2();
+  const provider = getProvider(config);
+  const chainId = getChainId();
   const currentNonce = await contract.nonces(account.address);
   const fulfillmentParams = {
     order_hash: orderHash,
@@ -2278,7 +2306,7 @@ async function fulfillOrder1155(account, params, config) {
     build1155FulfillmentTypedData(fulfillmentParams, chainId)
   );
   const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray2(signature);
+  const signatureArray = toSignatureArray(signature);
   const fulfillPayload = stringifyBigInts({
     fulfillment: fulfillmentParams,
     signature: signatureArray
@@ -2305,8 +2333,8 @@ async function fulfillOrder1155(account, params, config) {
 async function cancelOrder1155(account, params, config) {
   const { orderHash } = params;
   const contract = getContract(config);
-  const provider = getProvider2(config);
-  const chainId = getChainId2();
+  const provider = getProvider(config);
+  const chainId = getChainId();
   const currentNonce = await contract.nonces(account.address);
   const cancelParams = {
     order_hash: orderHash,
@@ -2317,7 +2345,7 @@ async function cancelOrder1155(account, params, config) {
     build1155CancellationTypedData(cancelParams, chainId)
   );
   const signature = await account.signMessage(typedData);
-  const signatureArray = toSignatureArray2(signature);
+  const signatureArray = toSignatureArray(signature);
   const cancelPayload = stringifyBigInts({
     cancelation: cancelParams,
     signature: signatureArray
@@ -2331,6 +2359,148 @@ async function cancelOrder1155(account, params, config) {
     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();
+  const token = resolveToken(currency);
+  const priceWei = parseAmount(price, token.decimals);
+  const now = Math.floor(Date.now() / 1e3);
+  const endTime = now + durationSeconds;
+  const saltBytes = new Uint8Array(4);
+  crypto.getRandomValues(saltBytes);
+  const salt = new DataView(saltBytes.buffer).getUint32(0).toString();
+  const currentNonce = await contract.nonces(account.address);
+  const orderParams = {
+    offerer: account.address,
+    offer: {
+      item_type: "ERC20",
+      token: token.address,
+      identifier_or_criteria: "0",
+      start_amount: priceWei,
+      end_amount: priceWei
+    },
+    consideration: {
+      item_type: "ERC1155",
+      token: nftContract,
+      identifier_or_criteria: tokenId,
+      start_amount: amount,
+      end_amount: amount,
+      recipient: account.address
+    },
+    start_time: (now + START_TIME_BUFFER_SECS).toString(),
+    end_time: endTime.toString(),
+    salt,
+    nonce: currentNonce.toString()
+  };
+  const typedData = stringifyBigInts(
+    build1155OrderTypedData(orderParams, chainId)
+  );
+  const signature = await account.signMessage(typedData);
+  const signatureArray = toSignatureArray(signature);
+  const registerPayload = stringifyBigInts({
+    parameters: {
+      ...orderParams,
+      offer: {
+        ...orderParams.offer,
+        item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type)
+      },
+      consideration: {
+        ...orderParams.consideration,
+        item_type: starknet.shortString.encodeShortString(orderParams.consideration.item_type)
+      }
+    },
+    signature: signatureArray
+  });
+  const amountU256 = starknet.cairo.uint256(priceWei);
+  const approveCall = {
+    contractAddress: token.address,
+    entrypoint: "approve",
+    calldata: [
+      config.marketplace1155Contract,
+      amountU256.low.toString(),
+      amountU256.high.toString()
+    ]
+  };
+  const registerCall = contract.populate("register_order", [registerPayload]);
+  try {
+    const tx = await account.execute([approveCall, registerCall]);
+    await provider.waitForTransaction(tx.transaction_hash);
+    return { txHash: tx.transaction_hash };
+  } catch (err) {
+    throw new MedialaneError("Failed to make ERC-1155 offer", "TRANSACTION_FAILED", err);
+  }
+}
+async function checkoutCart1155(account, items, config) {
+  if (items.length === 0) throw new MedialaneError("Cart is empty", "INVALID_PARAMS");
+  const contract = getContract(config);
+  const provider = getProvider(config);
+  const tokenTotals = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const prev = tokenTotals.get(item.considerationToken) ?? 0n;
+    tokenTotals.set(item.considerationToken, prev + BigInt(item.considerationAmount));
+  }
+  const approveCalls = Array.from(tokenTotals.entries()).map(([tokenAddr, totalWei]) => {
+    const amount = starknet.cairo.uint256(totalWei.toString());
+    return {
+      contractAddress: tokenAddr,
+      entrypoint: "approve",
+      calldata: [
+        config.marketplace1155Contract,
+        amount.low.toString(),
+        amount.high.toString()
+      ]
+    };
+  });
+  const currentNonce = await contract.nonces(account.address);
+  const baseNonce = BigInt(currentNonce.toString());
+  const chainId = getChainId();
+  const fulfillCalls = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const nonce = (baseNonce + BigInt(i)).toString();
+    const quantity = item.quantity ?? "1";
+    const fulfillmentParams = {
+      order_hash: item.orderHash,
+      fulfiller: account.address,
+      quantity,
+      nonce
+    };
+    const typedData = stringifyBigInts(
+      build1155FulfillmentTypedData(fulfillmentParams, chainId)
+    );
+    const signature = await account.signMessage(typedData);
+    const signatureArray = toSignatureArray(signature);
+    const fulfillPayload = stringifyBigInts({
+      fulfillment: fulfillmentParams,
+      signature: signatureArray
+    });
+    fulfillCalls.push(contract.populate("fulfill_order", [fulfillPayload]));
+  }
+  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 getNonce1155(address, config) {
+  const contract = getContract(config);
+  return BigInt((await contract.nonces(address)).toString());
+}
 
 // src/marketplace1155/index.ts
 var Medialane1155Module = class {
@@ -2345,6 +2515,13 @@ var Medialane1155Module = class {
   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.
@@ -2358,6 +2535,20 @@ var Medialane1155Module = class {
   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);
+  }
+  // ─── View calls ───────────────────────────────────────────────────────────
+  getOrderDetails(orderHash) {
+    return getOrderDetails1155(orderHash, this.config);
+  }
+  getNonce(address) {
+    return getNonce1155(address, this.config);
+  }
   // ─── Typed data builders (for ChipiPay / custom signing flows) ───────────
   buildListingTypedData(params, chainId) {
     return build1155OrderTypedData(params, chainId);
@@ -3065,44 +3256,6 @@ var DropService = class {
     return { txHash: res.transaction_hash };
   }
 };
-
-// src/client.ts
-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)
-    };
-    if (!this.config.backendUrl) {
-      this.api = new Proxy({}, {
-        get(_target, prop) {
-          return () => {
-            throw new Error(
-              `backendUrl not configured. Pass backendUrl to MedialaneClient to use .api.${String(prop)}()`
-            );
-          };
-        }
-      });
-    } else {
-      this.api = new ApiClient(this.config.backendUrl, this.config.apiKey, this.config.retryOptions);
-    }
-  }
-  get network() {
-    return this.config.network;
-  }
-  get rpcUrl() {
-    return this.config.rpcUrl;
-  }
-  get marketplaceContract() {
-    return this.config.marketplaceContract;
-  }
-};
-
-// src/types/api.ts
-var OPEN_LICENSES = ["CC0", "CC BY", "CC BY-SA", "CC BY-NC"];
 var ERC1155CollectionService = class {
   constructor(config) {
     this.factoryAddress = config.collection1155Contract ?? COLLECTION_1155_CONTRACT_MAINNET;
@@ -3211,6 +3364,45 @@ var ERC1155CollectionService = class {
   }
 };
 
+// src/client.ts
+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),
+      erc1155Collection: new ERC1155CollectionService(this.config)
+    };
+    if (!this.config.backendUrl) {
+      this.api = new Proxy({}, {
+        get(_target, prop) {
+          return () => {
+            throw new Error(
+              `backendUrl not configured. Pass backendUrl to MedialaneClient to use .api.${String(prop)}()`
+            );
+          };
+        }
+      });
+    } else {
+      this.api = new ApiClient(this.config.backendUrl, this.config.apiKey, this.config.retryOptions);
+    }
+  }
+  get network() {
+    return this.config.network;
+  }
+  get rpcUrl() {
+    return this.config.rpcUrl;
+  }
+  get marketplaceContract() {
+    return this.config.marketplaceContract;
+  }
+};
+
+// src/types/api.ts
+var OPEN_LICENSES = ["CC0", "CC BY", "CC BY-SA", "CC BY-NC"];
+
 exports.ApiClient = ApiClient;
 exports.COLLECTION_1155_CLASS_HASH_MAINNET = COLLECTION_1155_CLASS_HASH_MAINNET;
 exports.COLLECTION_1155_CONTRACT_MAINNET = COLLECTION_1155_CONTRACT_MAINNET;
@@ -3260,6 +3452,7 @@ exports.build1155OrderTypedData = build1155OrderTypedData;
 exports.buildCancellationTypedData = buildCancellationTypedData;
 exports.buildFulfillmentTypedData = buildFulfillmentTypedData;
 exports.buildOrderTypedData = buildOrderTypedData;
+exports.encodeByteArray = encodeByteArray;
 exports.formatAmount = formatAmount;
 exports.getListableTokens = getListableTokens;
 exports.getTokenByAddress = getTokenByAddress;