From a test key to a verified webhook.

TypeScript

import { createServer } from "node:http";
import { verifyWebhook, WebhookSignatureError } from "@ravelo/sdk";

const secret = process.env.RAVELO_WEBHOOK_SECRET!;
const handled = new Set<string>(); // keep this in your database; deliveries can repeat

createServer(async (req, res) => {
  if (req.method !== "POST" || req.url !== "/webhooks/ravelo") {
    res.writeHead(404).end();
    return;
  }
  // Verify the bytes exactly as they arrived; parsing and re-serialising the JSON would break the signature.
  const chunks: Buffer[] = [];
  for await (const chunk of req) chunks.push(chunk as Buffer);
  try {
    const event = await verifyWebhook(Buffer.concat(chunks), req.headers["ravelo-signature"] as string | undefined, secret);
    if (!handled.has(event.id)) {
      handled.add(event.id);
      console.log("verified", event.type, event.id);
      if (event.type === "payment_intent.succeeded") console.log("paid:", event.data.id);
    }
    res.writeHead(200).end();
  } catch (err) {
    console.error("rejected:", err instanceof Error ? err.message : err);
    res.writeHead(err instanceof WebhookSignatureError ? 400 : 500).end();
  }
}).listen(3000, () => console.log("listening on http://localhost:3000/webhooks/ravelo"));

Python

import os
from http.server import BaseHTTPRequestHandler, HTTPServer

from ravelo import SIGNATURE_HEADER, WebhookSignatureError, verify_webhook

SECRET = os.environ["RAVELO_WEBHOOK_SECRET"]
handled = set()  # keep this in your database; deliveries can repeat


class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        if self.path != "/webhooks/ravelo":
            self.send_response(404)
            self.end_headers()
            return
        # Verify the bytes exactly as they arrived; parsing and re-serialising the JSON would break the signature.
        raw = self.rfile.read(int(self.headers.get("Content-Length", 0)))
        try:
            event = verify_webhook(raw, self.headers.get(SIGNATURE_HEADER), SECRET)
        except WebhookSignatureError as err:
            print("rejected:", err)
            self.send_response(400)
            self.end_headers()
            return
        if event["id"] not in handled:
            handled.add(event["id"])
            print("verified", event["type"], event["id"])
            if event["type"] == "payment_intent.succeeded":
                print("paid:", event["data"]["id"])
        self.send_response(200)
        self.end_headers()


print("listening on http://localhost:3000/webhooks/ravelo")
HTTPServer(("", 3000), Handler).serve_forever()

curl

curl -sS "$RAVELO_API/v1/webhook-endpoints" \
  -H "Authorization: Bearer $RAVELO_TEST_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://YOUR-TUNNEL.example/webhooks/ravelo",
    "description": "Quickstart"
  }'

curl

curl -sS -X POST "$RAVELO_API/v1/webhook-endpoints/$ENDPOINT_ID/test" \
  -H "Authorization: Bearer $RAVELO_TEST_KEY" \
  -H "Idempotency-Key: $(uuidgen)"

curl

curl -sS "$RAVELO_API/v1/payment-intents" \
  -H "Authorization: Bearer $RAVELO_TEST_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "order_ref": "quickstart-1",
    "asset_id": "usdt-tron",
    "amount": "25000000",
    "description": "Quickstart order"
  }'

# Copy "id" from the response:
export INTENT_ID=...

# Play the customer:
curl -sS "$RAVELO_API/v1/sandbox/payment-intents/$INTENT_ID/simulate-funding" \
  -H "Authorization: Bearer $RAVELO_TEST_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{}'

# Look at the payment; it succeeds a moment later:
curl -sS "$RAVELO_API/v1/payment-intents/$INTENT_ID" \
  -H "Authorization: Bearer $RAVELO_TEST_KEY"

TypeScript

import { Ravelo, isTestKey } from "@ravelo/sdk";

const apiKey = process.env.RAVELO_TEST_KEY!;
if (!isTestKey(apiKey)) throw new Error("The quickstart needs a test key (rvk_test_...)");

const ravelo = new Ravelo({ apiKey, baseUrl: process.env.RAVELO_API! });

// 25 USDT on TRON, in base units (6 decimals).
const intent = await ravelo.paymentIntents.create({
  order_ref: `quickstart-${Date.now()}`,
  asset_id: "usdt-tron",
  amount: "25000000",
  description: "Quickstart order",
});
console.log("created", intent.id, intent.status, intent.instructions.address);

// Plays the customer: sends what is due to the intent's test address.
const funding = await ravelo.sandbox.simulateFunding(intent.id);
console.log("simulated", funding.amount, funding.asset_id, funding.tx_hash);

// The payment succeeds a moment later. Your webhook endpoint is told; here we also poll.
for (let i = 0; i < 30; i++) {
  const current = await ravelo.paymentIntents.get(intent.id);
  if (current.status === "succeeded") {
    console.log("succeeded", current.amount_received, current.succeeded_at);
    break;
  }
  await new Promise((resolve) => setTimeout(resolve, 1000));
}

Python

import os
import time

from ravelo import Ravelo, is_test_key

api_key = os.environ["RAVELO_TEST_KEY"]
if not is_test_key(api_key):
    raise SystemExit("The quickstart needs a test key (rvk_test_...)")

ravelo = Ravelo(api_key, os.environ["RAVELO_API"])

# 25 USDT on TRON, in base units (6 decimals).
intent = ravelo.payment_intents.create(
    order_ref=f"quickstart-{int(time.time())}",
    asset_id="usdt-tron",
    amount="25000000",
    description="Quickstart order",
)
print("created", intent["id"], intent["status"], intent["instructions"]["address"])

# Plays the customer: sends what is due to the intent's test address.
funding = ravelo.sandbox.simulate_funding(intent["id"])
print("simulated", funding["amount"], funding["asset_id"], funding["tx_hash"])

# The payment succeeds a moment later. Your webhook endpoint is told; here we also poll.
for _ in range(30):
    current = ravelo.payment_intents.get(intent["id"])
    if current["status"] == "succeeded":
        print("succeeded", current["amount_received"], current["succeeded_at"])
        break
    time.sleep(1)

curl

curl -sS "$RAVELO_API/v1/events?limit=10" \
  -H "Authorization: Bearer $RAVELO_TEST_KEY"