Vito-API und Käufe

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) {
  // Noch keine Wallet-PIN, also kann keine Belastung bestätigt werden.
}

const confirmation = await vito.payments.deduct({
  discordId: '123456789012345678',
  guildId: '987654321098765432',
  amount: 250,
  reason: 'Legendäres Schwert',
  merchantRef: 'order_10423',
  metadata: { sku: 'sword-legendary' },
  product: {
    type: 'virtual_item',
    name: 'Legendäres Schwert',
    description: 'Verursacht 120 Schaden.',
    imageUrl: 'https://cdn.example.com/sword.png',
  },
});

console.log(confirmation.confirmUrl); // hierhin den Nutzer schicken
console.log(confirmation.expiresAt);  // Unix-ms, in 10 Minuten

const credit = await vito.payments.credit(
  {
    discordId: '123456789012345678',
    amount: 250,
    reason: 'Erstattung für order_10423',
    merchantRef: 'refund_10423',
  },
  // Leitest du den Key aus deinem eigenen Datensatz ab, ist ein erneuter Lauf aus
  // einer Job-Queue sicher: eine Wiederholung liefert das Originalergebnis,
  // statt ein zweites Mal auszuzahlen.
  { idempotencyKey: 'refund_10423' },
);

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

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

// Ein async Generator, der Seiten bei Bedarf holt — keine manuelle Blätterschleife.
for await (const tx of vito.transactions.iterate({ limit: 100 })) {
  if (tx.date < since) break; // neueste zuerst
  // tx.type ist die Richtung relativ zu tx.discordId: 1 = eingehend, 0 = ausgehend.
}

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

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

try {
  const event = Webhooks.constructEvent({
    payload: rawRequestBody, // der Raw Body — siehe Warnung unten
    signature: req.header('x-vito-signature') ?? '',
    secret: process.env.VITO_WEBHOOK_SECRET,
  });

  if (event.eventType === 'confirmation.completed') {
    // Der Typ von data wird anhand von eventType automatisch eingegrenzt.
    await fulfil(event.data.merchantRef);
  }
} catch (error) {
  if (error instanceof VitoSignatureVerificationError) {
    // Auslieferung mit 400 ablehnen — gefälscht, veraltet oder neu serialisiert.
  }
}

export const runtime = 'nodejs'; // die Prüfung nutzt 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
}