Primary Sales

app.post('/quote', async (req, res) => {
  const { recipient_address, products } = req.body;

  // Validate products exist and are in stock
  const validatedProducts = await validateProducts(products);

  // Calculate pricing (can be dynamic based on user, time, etc.)
  // amount must be a number; include a row for every currency
  // configured in Hub, in both pricing and totals
  const pricing = await calculatePricing(validatedProducts);

  res.json({
    products: pricing.products, // [{ product_id, quantity, pricing: [{ currency, currency_type, amount }] }]
    totals: pricing.totals,     // [{ currency, currency_type, amount }] — one per configured currency
  });
});

app.post('/authorize', async (req, res) => {
  const { spender_address, recipient_address, currency, products } = req.body;

  try {
    // Generate a reference (max 32 chars) and reserve inventory / token IDs.
    // Return one detail entry per token to mint (detail.length === quantity);
    // each detail.amount is the per-token price, summed into the order total.
    const reference = createReference(); // e.g. "order-123"
    const authorizedProducts = await reserveInventory(reference, products);

    // Store the order for later confirmation
    await createPendingOrder({
      reference,
      recipient_address,
      spender_address,
      currency,
      products: authorizedProducts,
      status: 'pending',
    });

    // Return the reserved token detail and pricing
    res.json({
      reference,
      currency, // must match the requested currency
      products: authorizedProducts, // [{ product_id, collection_address, contract_type, detail: [{ token_id, amount }] }]
    });
  } catch (error) {
    // Reject with a 4xx and an error body
    res.status(400).json({ code: 'INSUFFICIENT_STOCK', message: error.message });
  }
});

app.post('/confirm', async (req, res) => {
  const { reference, recipient_address, tx_hash, order } = req.body;

  try {
    // Verify the transaction on-chain
    const tx = await provider.getTransaction(tx_hash);
    if (!tx || tx.to !== PRIMARY_SALES_CONTRACT) {
      throw new Error('Invalid transaction');
    }
    await tx.wait(1);

    // Mint NFTs via Minting API (token IDs come from order.products[].detail)
    for (const product of order.products) {
      for (const { token_id } of product.detail) {
        await mintNFT({
          recipient: recipient_address,
          contractAddress: product.collection_address,
          tokenId: token_id,
          metadata: await getMetadata(product.product_id),
        });
      }
    }

    // Update order status
    await updateOrderStatus(reference, 'completed');

    // Status code is what matters — 2xx confirms the order
    res.status(200).json({ reference, confirmed: true });
  } catch (error) {
    // Non-2xx (here 500) signals failure; 5xx is retried
    res.status(500).json({ reference, confirmed: false, reason: error.message });
  }
});

app.post('/expired', async (req, res) => {
  const { reference } = req.body;

  // Look up the order by reference, then release its reserved inventory
  const order = await getOrderByReference(reference);
  await releaseInventory(reference, order.products);

  // Update order status
  await updateOrderStatus(reference, 'expired');

  // Status code is what matters — 2xx acknowledges the expiry
  res.status(200).json({ reference, expired: true });
});