Vito API et achats

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) {
  // Pas encore de code PIN de portefeuille : aucun débit ne peut être confirmé.
}

const confirmation = await vito.payments.deduct({
  discordId: '123456789012345678',
  guildId: '987654321098765432',
  amount: 250,
  reason: 'Épée légendaire',
  merchantRef: 'order_10423',
  metadata: { sku: 'sword-legendary' },
  product: {
    type: 'virtual_item',
    name: 'Épée légendaire',
    description: 'Inflige 120 points de dégâts.',
    imageUrl: 'https://cdn.example.com/sword.png',
  },
});

console.log(confirmation.confirmUrl); // envoyez l'utilisateur ici
console.log(confirmation.expiresAt);  // unix ms, dans 10 minutes

const credit = await vito.payments.credit(
  {
    discordId: '123456789012345678',
    amount: 250,
    reason: 'Remboursement de la commande order_10423',
    merchantRef: 'refund_10423',
  },
  // Dériver la clé de votre propre enregistrement rend l'opération rejouable depuis
  // une file de tâches : une répétition renvoie le résultat d'origine au lieu de
  // payer une seconde fois.
  { idempotencyKey: 'refund_10423' },
);

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

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

// Un générateur asynchrone qui récupère les pages à la demande — sans boucle manuelle.
for await (const tx of vito.transactions.iterate({ limit: 100 })) {
  if (tx.date < since) break; // les plus récentes d'abord
  // tx.type est le sens par rapport à tx.discordId : 1 = entrée, 0 = sortie.
}

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

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

try {
  const event = Webhooks.constructEvent({
    payload: rawRequestBody, // le corps brut — voir l'avertissement ci-dessous
    signature: req.header('x-vito-signature') ?? '',
    secret: process.env.VITO_WEBHOOK_SECRET,
  });

  if (event.eventType === 'confirmation.completed') {
    // Le type de data est affiné automatiquement selon eventType.
    await fulfil(event.data.merchantRef);
  }
} catch (error) {
  if (error instanceof VitoSignatureVerificationError) {
    // Rejetez la livraison avec un 400 : falsifiée, périmée ou corps ré-encodé.
  }
}

export const runtime = 'nodejs'; // la vérification utilise 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
}