Build with HelaMesh

curl -X POST https://api.helamesh.com/v1/merchant/invoices \
  -H "x-api-key: hm_test_YOUR_KEY" \
  -H "content-type: application/json" \
  -d '{
    "clientId": "YOUR_CLIENT_ID",
    "amount": 25.00,
    "metadata": { "orderId": "1234" }
  }'

{
  "id": "65f8a1b2c3d4e5f6a7b8c9d0",
  "amount": "25.000000",
  "token": "USDT",
  "network": "TRON",
  "status": "PENDING",
  "paymentAddress": "TUEZSdKsoDHQMeZwihtdoBiN46zxhGWYdH",
  "expiresAt": "2026-04-10T18:30:00.000Z",
  "txHash": null,
  "confirmations": 0,
  "metadata": { "orderId": "1234" }
}

{
  "statusCode": 409,
  "message": "An open invoice for the same address and amount already exists. Wait for it to complete/expire, or use a different amount.",
  "error": "Conflict"
}

x-api-key: hm_test_…
content-type: application/json

const res = await fetch('https://api.helamesh.com/v1/merchant/invoices', {
  method: 'POST',
  headers: {
    'x-api-key': process.env.HELAMESH_API_KEY,
    'content-type': 'application/json',
  },
  body: JSON.stringify({
    clientId: process.env.HELAMESH_CLIENT_ID,
    amount: 25.00,
    metadata: { orderId: '1234', customer: 'alice@example.com' },
  }),
});

const invoice = await res.json();
console.log('Pay here:', `https://pay.helamesh.com/pay/${invoice.id}`);

curl https://api.helamesh.com/v1/invoices/65f8a1b2c3d4e5f6a7b8c9d0

PENDING → DETECTED → CONFIRMING → CONFIRMED → COMPLETED
   │
   └─→ EXPIRED  (terminal, only from PENDING)

{
  "event": "payment.confirmed",
  "invoiceId": "65f8a1b2c3d4e5f6a7b8c9d0",
  "timestamp": "2026-04-10T18:32:14.000Z",
  "amount": "25.000000",
  "token": "USDT",
  "network": "TRON",
  "txHash": "abc123…",
  "confirmations": 20
}

Content-Type: application/json
User-Agent: HelaMesh-Webhooks/1.0
X-HelaMesh-Signature: t=1700000000,v1=<hex>

import { createHmac, timingSafeEqual } from 'crypto';

const SECRET = process.env.HELAMESH_WEBHOOK_SECRET;
const TOLERANCE_SECONDS = 300; // 5 minutes

function verifySignature(header, rawBody) {
  const parts = Object.fromEntries(
    header.split(',').map((kv) => kv.split('=')),
  );
  const t = Number(parts.t);
  const v1 = parts.v1;
  if (!t || !v1) return false;

  // Reject signatures outside the tolerance window
  if (Math.abs(Math.floor(Date.now() / 1000) - t) > TOLERANCE_SECONDS) return false;

  const expected = createHmac('sha256', SECRET)
    .update(`${t}.${rawBody}`)
    .digest('hex');

  return expected.length === v1.length &&
    timingSafeEqual(Buffer.from(expected, 'hex'), Buffer.from(v1, 'hex'));
}

// Express handler — note rawBody is required, not parsed JSON
app.post('/webhooks/helamesh', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.header('X-HelaMesh-Signature');
  if (!sig || !verifySignature(sig, req.body.toString())) {
    return res.status(401).send('Invalid signature');
  }
  const event = JSON.parse(req.body.toString());
  // Mark the order paid in your database
  await markOrderPaid(event.invoiceId, event.txHash);
  res.status(200).send('ok');
});

Attempt 1 — immediately
Attempt 2 — 2 seconds later
Attempt 3 — 4 seconds later
Attempt 4 — 8 seconds later
…
Attempt 8 — 256 seconds later
After 8 attempts → marked FAILED

<!-- Load the SDK -->
<script src="https://pay.helamesh.com/sdk/v1.js"></script>

<!-- Where the checkout will render -->
<div id="helamesh-checkout"></div>

<script>
  HelaMesh.mount('#helamesh-checkout', {
    invoiceId: 'YOUR_INVOICE_ID',
    publishableKey: 'pk_test_YOUR_KEY',
    onPaid: (event) => {
      console.log('Payment received', event.invoice);
      window.location.href = '/order/success';
    },
    onExpired: () => {
      alert('Payment window expired. Please try again.');
    },
  });
</script>

import { useEffect, useRef } from 'react';

declare global {
  interface Window {
    HelaMesh?: { mount: (target: any, opts: any) => { destroy: () => void } };
  }
}

export function CheckoutWidget({ invoiceId }: { invoiceId: string }) {
  const ref = useRef<HTMLDivElement>(null);

  useEffect(() => {
    let instance: { destroy: () => void } | null = null;

    const tryMount = () => {
      if (!ref.current || !window.HelaMesh) return false;
      instance = window.HelaMesh.mount(ref.current, {
        invoiceId,
        publishableKey: process.env.NEXT_PUBLIC_HELAMESH_PK!,
        onPaid: (event) => {
          // Update your local state, redirect, fulfil order
          window.location.href = `/order/success?inv=${event.invoice.id}`;
        },
      });
      return true;
    };

    if (!tryMount()) {
      // SDK not loaded yet — wait for it
      const script = document.createElement('script');
      script.src = 'https://pay.helamesh.com/sdk/v1.js';
      script.async = true;
      script.onload = tryMount;
      document.body.appendChild(script);
    }

    return () => instance?.destroy();
  }, [invoiceId]);

  return <div ref={ref} />;
}

'use client';

import Script from 'next/script';
import { useEffect, useRef } from 'react';

export default function CheckoutPage({ params }: { params: { id: string } }) {
  const ref = useRef<HTMLDivElement>(null);

  useEffect(() => {
    const interval = setInterval(() => {
      // @ts-ignore — SDK attaches to window.HelaMesh
      if (!window.HelaMesh || !ref.current) return;
      clearInterval(interval);

      // @ts-ignore
      const instance = window.HelaMesh.mount(ref.current, {
        invoiceId: params.id,
        publishableKey: process.env.NEXT_PUBLIC_HELAMESH_PK!,
        onPaid: () => {
          window.location.href = '/order/success';
        },
      });

      return () => instance.destroy();
    }, 100);

    return () => clearInterval(interval);
  }, [params.id]);

  return (
    <>
      <Script
        src="https://pay.helamesh.com/sdk/v1.js"
        strategy="afterInteractive"
      />
      <div ref={ref} />
    </>
  );
}

HelaMesh.mount('#checkout', {
  invoiceId: 'abc123',
  publishableKey: 'pk_test_…',

  onReady: ({ invoice }) => {
    // Embed mounted, showing PENDING state
  },
  onStatusChange: ({ from, to, invoice }) => {
    // Fires for EVERY transition. Great for analytics.
    analytics.track('helamesh_status', { from, to });
  },
  onDetected: ({ invoice }) => {
    // Payment seen on chain (0+ confirmations)
  },
  onConfirming: ({ invoice }) => {
    // Accumulating confirmations
  },
  onConfirmed: ({ invoice }) => {
    // Enough confirmations, last step before COMPLETED
  },
  onPaid: ({ invoice }) => {
    // TERMINAL: invoice is COMPLETED. This is "done".
    window.location.href = '/order/success';
  },
  onExpired: ({ invoice }) => {
    // TERMINAL: payment window passed without payment
  },
  onError: ({ message }) => {
    console.error('HelaMesh embed error:', message);
  },
});

HelaMesh.mount('#checkout', {
  invoiceId: 'abc123',
  publishableKey: 'pk_test_…',
  theme: {
    accentColor: '#3b82f6',     // buttons, hover states, badge accents
    backgroundColor: '#0f172a', // card background
    textColor: '#f1f5f9',       // primary text
  },
});