Vito API और खरीद

Authorization: Bearer vito_live_xxxxxxxxxxxxxxxx

npm install @vetox-bot/vito

import { VitoClient } from '@vetox-bot/vito';

const vito = new VitoClient({ apiKey: process.env.VITO_API_KEY });

const project = await vito.auth.verify();

console.log(project.status);    // "active"
console.log(project.scopes);    // ["balance:read", "deduct:create", …]
console.log(project.rateLimit); // { tier, requestsPerMinute, requestsPerHour }

const wallet = await vito.balance.retrieve('123456789012345678');

if (!wallet.hasPin) {
  // अभी वॉलेट PIN नहीं है, इसलिए कोई कटौती मंज़ूर नहीं की जा सकती।
}

const confirmation = await vito.payments.deduct({
  discordId: '123456789012345678',
  guildId: '987654321098765432',
  amount: 250,
  reason: 'पौराणिक तलवार',
  merchantRef: 'order_10423',
  metadata: { sku: 'sword-legendary' },
  product: {
    type: 'virtual_item',
    name: 'पौराणिक तलवार',
    description: '120 क्षति पहुँचाती है।',
    imageUrl: 'https://cdn.example.com/sword.png',
  },
});

console.log(confirmation.confirmUrl); // उपयोगकर्ता को यहाँ भेजें
console.log(confirmation.expiresAt);  // unix ms, 10 मिनट बाद

const credit = await vito.payments.credit(
  {
    discordId: '123456789012345678',
    amount: 250,
    reason: 'order_10423 की धनवापसी',
    merchantRef: 'refund_10423',
  },
  // कुंजी अपने ही रिकॉर्ड से बनाने पर इसे किसी जॉब क़तार से दोबारा चलाना सुरक्षित
  // हो जाता है: दोहराव मूल परिणाम लौटाता है, दूसरी बार भुगतान नहीं करता।
  { idempotencyKey: 'refund_10423' },
);

console.log(credit.transactionId, credit.ownerBalance, credit.recipientBalance);

const since = Date.now() - 24 * 60 * 60 * 1000;

// एक असिंक्रोनस जेनरेटर जो ज़रूरत पड़ने पर पृष्ठ लाता है — कोई मैनुअल लूप नहीं।
for await (const tx of vito.transactions.iterate({ limit: 100 })) {
  if (tx.date < since) break; // सबसे नए पहले
  // tx.type, tx.discordId के सापेक्ष दिशा है: 1 = आया, 0 = गया।
}

await vito.payments.credit(params, { idempotencyKey: `refund_${orderId}` });

import { Webhooks, VitoSignatureVerificationError } from '@vetox-bot/vito';

try {
  const event = Webhooks.constructEvent({
    payload: rawRequestBody, // कच्चा बॉडी — नीचे दी चेतावनी देखें
    signature: req.header('x-vito-signature') ?? '',
    secret: process.env.VITO_WEBHOOK_SECRET,
  });

  if (event.eventType === 'confirmation.completed') {
    // data फ़ील्ड का प्रकार eventType के अनुसार अपने आप सीमित हो जाता है।
    await fulfil(event.data.merchantRef);
  }
} catch (error) {
  if (error instanceof VitoSignatureVerificationError) {
    // डिलीवरी 400 के साथ अस्वीकार करें: जाली, पुरानी, या दोबारा क्रमबद्ध बॉडी।
  }
}

export const runtime = 'nodejs'; // सत्यापन node:crypto का उपयोग करता है

export async function POST(request: Request) {
  const event = await Webhooks.constructEventFromRequest(request, {
    secret: process.env.VITO_WEBHOOK_SECRET,
  });

  return Response.json({ received: true });
}

import { isVitoError, VitoInsufficientFundsError } from '@vetox-bot/vito';

try {
  await vito.payments.deduct(params);
} catch (error) {
  if (error instanceof VitoInsufficientFundsError) return notEnoughVito();

  if (isVitoError(error)) {
    logger.error({ code: error.code, requestId: error.requestId });
  }
  throw error;
}

const controller = new AbortController();
setTimeout(() => controller.abort(), 2000);

await vito.balance.retrieve(id, { signal: controller.signal });

X-Vito-Signature: ts=<unix>;h1=<hex>

const crypto = require('crypto');

function verify(rawBody, header, secret) {
  const parts = header.split(';');
  const ts = parts.find(p => p.startsWith('ts='))?.slice(3);
  const sigs = parts.filter(p => p.startsWith('h1=')).map(p => p.slice(3));
  if (!ts || sigs.length === 0) return false;

  // Reject anything older than ~5 minutes — replay protection.
  if (Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;

  const expected = Buffer.from(
    crypto.createHmac('sha256', secret).update(`${ts}:${rawBody}`).digest('hex'),
  );

  // Any matching signature is valid — a rotation emits several.
  return sigs.some(sig => {
    const actual = Buffer.from(sig);
    // timingSafeEqual throws when the lengths differ, so check first.
    return (
      actual.length === expected.length && crypto.timingSafeEqual(actual, expected)
    );
  });
}

{
  "success": false,
  "error": {
    "type": "Forbidden",
    "message": "API key lacks the required scope for this operation.",
    "code": "VITO_INSUFFICIENT_SCOPE"
  },
  "requestId": "…",
  "timestamp": 1735161600000
}