Accept crypto payments in your Telegram bot

import { Bot, InlineKeyboard } from 'grammy'
 
const INZI_KEY = process.env.INZI_API_KEY // sk_test_... or sk_live_...
 
bot.command('pay', async (ctx) => {
  const amount = ctx.match || '10.00'
  const userId = String(ctx.from.id)
 
  // Create Inzi checkout
  const res = await fetch('https://api.inzilink.com/api/v1/checkouts', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${INZI_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      amount,
      currency: 'USD',
      description: `Top-up $${amount}`,
      metadata: {
        user_id: userId,
        type: 'topup',
        telegram_chat_id: String(ctx.chat.id),
      },
      webhook_url: 'https://yourbot.com/webhooks/inzi',
      expires_in: 1800,
    }),
  })
 
  const { checkout_url } = await res.json()
 
  // Send payment button
  const keyboard = new InlineKeyboard()
    .url('Pay now', checkout_url)
 
  await ctx.reply(`Pay $${amount} with crypto:`, {
    reply_markup: keyboard,
  })
})

import httpx
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
from telegram.ext import CommandHandler, ContextTypes
 
INZI_KEY = "sk_test_..."  # or sk_live_...
 
async def pay_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    amount = context.args[0] if context.args else "10.00"
    user_id = str(update.effective_user.id)
 
    # Create Inzi checkout
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            "https://api.inzilink.com/api/v1/checkouts",
            headers={"Authorization": f"Bearer {INZI_KEY}"},
            json={
                "amount": amount,
                "currency": "USD",
                "description": f"Top-up ${amount}",
                "metadata": {
                    "user_id": user_id,
                    "type": "topup",
                    "telegram_chat_id": str(update.effective_chat.id),
                },
                "webhook_url": "https://yourbot.com/webhooks/inzi",
                "expires_in": 1800,
            },
        )
        checkout_url = resp.json()["checkout_url"]
 
    # Send payment button
    keyboard = InlineKeyboardMarkup([[
        InlineKeyboardButton("Pay now", url=checkout_url)
    ]])
 
    await update.message.reply_text(
        f"Pay ${amount} with crypto:",
        reply_markup=keyboard,
    )

import express from 'express'
import crypto from 'crypto'
 
const app = express()
app.use('/webhooks/inzi', express.raw({ type: 'application/json' }))
 
const WEBHOOK_SECRET = process.env.INZI_WEBHOOK_SECRET
 
app.post('/webhooks/inzi', async (req, res) => {
  // Verify signature
  const timestamp = req.headers['x-inzi-timestamp']
  const signature = req.headers['x-inzi-signature'].replace('sha256=', '')
  const signedPayload = `${timestamp}.${req.body.toString()}`
  const expected = crypto
    .createHmac('sha256', WEBHOOK_SECRET)
    .update(signedPayload)
    .digest('hex')
 
  if (!crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature))) {
    return res.status(401).send('Invalid signature')
  }
 
  const event = JSON.parse(req.body.toString())
 
  if (event.event === 'checkout.completed') {
    const { user_id, telegram_chat_id } = event.data.metadata
    const amount = event.data.amount
 
    // Credit user balance in your database
    await creditBalance(user_id, parseFloat(amount))
 
    // Notify user in Telegram
    await bot.api.sendMessage(
      telegram_chat_id,
      `Payment of $${amount} received! Your balance has been updated.`
    )
  }
 
  res.json({ ok: true })
})

import hmac, hashlib, time, json
from fastapi import FastAPI, Request, HTTPException
 
app = FastAPI()
WEBHOOK_SECRET = "your_webhook_secret"
 
@app.post("/webhooks/inzi")
async def handle_webhook(request: Request):
    body = (await request.body()).decode()
    timestamp = request.headers.get("X-Inzi-Timestamp", "")
    signature = request.headers.get("X-Inzi-Signature", "").removeprefix("sha256=")
 
    # Verify signature
    signed_payload = f"{timestamp}.{body}"
    expected = hmac.new(
        WEBHOOK_SECRET.encode(), signed_payload.encode(), hashlib.sha256
    ).hexdigest()
 
    if not hmac.compare_digest(expected, signature):
        raise HTTPException(401, "Invalid signature")
 
    event = json.loads(body)
 
    if event["event"] == "checkout.completed":
        metadata = event["data"]["metadata"]
        user_id = metadata["user_id"]
        amount = float(event["data"]["amount"])
 
        # Credit balance
        await credit_balance(user_id, amount)
 
        # Notify via Telegram
        await bot.send_message(
            metadata["telegram_chat_id"],
            f"Payment of ${amount} received!"
        )
 
    return {"ok": True}