Enviar dinero: P2P y Bre-B

import os
import time
from compense_gateway import CompenseClient

client = CompenseClient(api_key=os.environ["COMPENSE_API_KEY"], environment="sandbox")
DOC = "1000000001"

def resolver(llave: str, tipo: str):
    """Devuelve (riel, resolución, vence_en) o (None, None, None)."""
    r = client.wallet.p2p.resolve(document=DOC, alias=llave, key_type=tipo)
    if r.found and r.is_local is not False:
        return "p2p", r, time.monotonic() + r.expires_in
    r = client.wallet.breb.resolve(document=DOC, key_type=tipo, value=llave)
    if r.found:
        return "breb", r, time.monotonic() + r.expires_in
    return None, None, None

riel, r, vence_en = resolver("3109876543", "PHONE")
if riel:
    destino = r.display_name if riel == "p2p" else f"{r.display_name} · {r.institution_name} · {r.key_display}"
    print(f"¿Enviar a {destino}?")

import { CompenseClient, type Resolution } from "@compense/sdk";

const client = new CompenseClient({ apiKey: process.env.COMPENSE_API_KEY!, environment: "sandbox" });
const DOC = "1000000001";

async function resolver(llave: string, tipo: string): Promise<{ riel: "p2p" | "breb"; r: Resolution; venceEn: number } | null> {
  let r = await client.wallet.p2p.resolve({ document: DOC, alias: llave, keyType: tipo });
  if (r.found && r.isLocal !== false) return { riel: "p2p", r, venceEn: Date.now() + r.expiresIn * 1000 };
  r = await client.wallet.breb.resolve({ document: DOC, keyType: tipo, value: llave });
  if (r.found) return { riel: "breb", r, venceEn: Date.now() + r.expiresIn * 1000 };
  return null;
}

const destino = await resolver("3109876543", "PHONE");
if (destino) {
  const { r } = destino;
  console.log(`¿Enviar a ${r.displayName}${destino.riel === "breb" ? ` · ${r.institutionName} · ${r.keyDisplay}` : ""}?`);
}

<?php
require __DIR__ . '/vendor/autoload.php';

use Compense\Sdk\CompenseClient;

$client = new CompenseClient(apiKey: getenv('COMPENSE_API_KEY'), environment: 'sandbox');
$doc = '1000000001';

/** @return array{0: ?string, 1: ?\Compense\Sdk\Model\Resolution, 2: ?float} */
function resolver(CompenseClient $client, string $doc, string $llave, string $tipo): array
{
    $r = $client->wallet->p2p->resolve(document: $doc, alias: $llave, keyType: $tipo);
    if ($r->found && $r->isLocal !== false) {
        return ['p2p', $r, microtime(true) + $r->expiresIn];
    }
    $r = $client->wallet->breb->resolve(document: $doc, keyType: $tipo, value: $llave);
    if ($r->found) {
        return ['breb', $r, microtime(true) + $r->expiresIn];
    }
    return [null, null, null];
}

[$riel, $r, $venceEn] = resolver($client, $doc, '3109876543', 'PHONE');
if ($riel !== null) {
    echo '¿Enviar a ', $r->displayName, $riel === 'breb' ? " · {$r->institutionName} · {$r->keyDisplay}" : '', '?', PHP_EOL;
}

using Compense.Sdk;
using Compense.Sdk.Models;

using var client = new CompenseClient(
    Environment.GetEnvironmentVariable("COMPENSE_API_KEY")!, CompenseEnvironment.Sandbox);
const string Doc = "1000000001";

async Task<(string? Riel, Resolution? R, DateTimeOffset VenceEn)> Resolver(string llave, string tipo)
{
    Resolution r = await client.Wallet.P2P.ResolveAsync(Doc, llave, tipo);
    if (r.Found && r.IsLocal != false) return ("p2p", r, DateTimeOffset.UtcNow.AddSeconds(r.ExpiresIn));
    r = await client.Wallet.BreB.ResolveAsync(Doc, tipo, llave);
    if (r.Found) return ("breb", r, DateTimeOffset.UtcNow.AddSeconds(r.ExpiresIn));
    return (null, null, DateTimeOffset.MinValue);
}

var (riel, res, venceEn) = await Resolver("3109876543", "PHONE");
if (riel is not null)
    Console.WriteLine($"¿Enviar a {res!.DisplayName}{(riel == "breb" ? $" · {res.InstitutionName} · {res.KeyDisplay}" : "")}?");

const doc = "1000000001"

resolver := func(llave, tipo string) (string, *compense.Resolution, time.Time, error) {
	r, err := client.Wallet.P2P.Resolve(ctx, &compense.P2PResolveParams{Document: doc, Alias: llave, KeyType: tipo})
	if err != nil {
		return "", nil, time.Time{}, err
	}
	if r.Found && (r.IsLocal == nil || *r.IsLocal) {
		return "p2p", r, time.Now().Add(time.Duration(r.ExpiresIn) * time.Second), nil
	}
	r, err = client.Wallet.BreB.Resolve(ctx, &compense.BreBResolveParams{Document: doc, KeyType: tipo, Value: llave})
	if err != nil || !r.Found {
		return "", nil, time.Time{}, err
	}
	return "breb", r, time.Now().Add(time.Duration(r.ExpiresIn) * time.Second), nil
}

riel, r, venceEn, err := resolver("3109876543", "PHONE")
if err != nil {
	log.Fatal(err)
}
if riel != "" {
	fmt.Printf("¿Enviar a %s (%s %s)?\n", r.DisplayName, r.InstitutionName, r.KeyDisplay)
}

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/p2p/resolve/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "alias": "3109876543", "key_type": "PHONE"}'

# Si found es false o is_local es false:
curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/breb/resolve/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "key_type": "PHONE", "value": "3109876543"}'

monto = 150000
if riel == "breb":
    lim = client.wallet.breb.limits(DOC)
    if monto > lim["max_per_transaction"] or monto > (lim["available_today"] or 0):
        raise SystemExit(f"Supera tu límite: hoy puedes enviar hasta {lim['available_today']}")

const monto = 150000;
if (destino?.riel === "breb") {
  const lim = await client.wallet.breb.limits(DOC);
  if (monto > Number(lim.max_per_transaction) || monto > Number(lim.available_today ?? 0)) {
    throw new Error(`Supera tu límite: hoy puedes enviar hasta ${lim.available_today}`);
  }
}

$monto = 150000;
if ($riel === 'breb') {
    $lim = $client->wallet->breb->limits($doc);
    if ($monto > $lim['max_per_transaction'] || $monto > ($lim['available_today'] ?? 0)) {
        exit("Supera tu límite: hoy puedes enviar hasta {$lim['available_today']}\n");
    }
}

const decimal Monto = 150000m;
if (riel == "breb")
{
    var lim = await client.Wallet.BreB.LimitsAsync(Doc);
    decimal disponibleHoy = lim["available_today"]?.GetValue<decimal>() ?? 0m;
    if (Monto > lim["max_per_transaction"]!.GetValue<decimal>() || Monto > disponibleHoy)
        throw new InvalidOperationException($"Supera tu límite: hoy puedes enviar hasta {disponibleHoy}");
}

const monto = 150000.0
if riel == "breb" {
	lim, err := client.Wallet.BreB.Limits(ctx, doc)
	if err != nil {
		log.Fatal(err)
	}
	num := func(v any) float64 { n, _ := v.(json.Number); f, _ := n.Float64(); return f } // el SDK decodifica con UseNumber
	porEnvio, hoy := num(lim["max_per_transaction"]), num(lim["available_today"])
	if monto > porEnvio || monto > hoy {
		log.Fatalf("supera tu límite: hoy puedes enviar hasta %.0f", hoy)
	}
}

curl "https://sandbox.dev.compense.co/gw/v1/gateway/wallet/breb/limits/?document=1000000001" \
  -H "X-API-Key: $COMPENSE_API_KEY"
# {"tier": "TIER_1", "max_per_transaction": 2000000.0, "max_daily_amount": 3000000.0,
#  "max_monthly_amount": 10000000.0, "used_today": 0.0, "used_month": 20000.0, "available_today": 3000000.0}

from compense_gateway import ValidationError

if time.monotonic() >= vence_en - 15:                 # margen para la latencia
    riel, r, vence_en = resolver("3109876543", "PHONE")  # y vuelve a confirmar con el usuario

recurso = client.wallet.p2p if riel == "p2p" else client.wallet.breb
try:
    tx = recurso.transfer(
        document=DOC, resolution_token=r.resolution_token, amount=str(monto),
        description="Pago del almuerzo", idempotency_key="nova-envio-ENV-2026-004512",
    )
except ValidationError as e:                           # 422: no se movió dinero
    raise SystemExit(f"No se pudo enviar: {e.detail}")

print(tx.data["status"], tx.data["transaction_id"], tx.data.get("end_to_end_id"))

import { ValidationError } from "@compense/sdk";

let actual = destino!;
if (Date.now() >= actual.venceEn - 15_000) actual = (await resolver("3109876543", "PHONE"))!; // y reconfirma

const recurso = actual.riel === "p2p" ? client.wallet.p2p : client.wallet.breb;
let tx;
try {
  tx = await recurso.transfer({
    document: DOC,
    resolutionToken: actual.r.resolutionToken,
    amount: String(monto),
    description: "Pago del almuerzo",
    idempotencyKey: "nova-envio-ENV-2026-004512",
  });
} catch (err) {
  if (err instanceof ValidationError) throw new Error(`No se pudo enviar: ${err.detail}`); // 422: no se movió dinero
  throw err;
}
console.log(tx.data.status, tx.data.transaction_id, tx.data.end_to_end_id);

use Compense\Sdk\Exception\ValidationException;

if (microtime(true) >= $venceEn - 15) {
    [$riel, $r, $venceEn] = resolver($client, $doc, '3109876543', 'PHONE'); // y reconfirma
}

$recurso = $riel === 'p2p' ? $client->wallet->p2p : $client->wallet->breb;
try {
    $tx = $recurso->transfer(
        document: $doc,
        resolutionToken: $r->resolutionToken,
        amount: (string) $monto,
        description: 'Pago del almuerzo',
        idempotencyKey: 'nova-envio-ENV-2026-004512',
    );
} catch (ValidationException $e) { // 422: no se movió dinero
    exit('No se pudo enviar: ' . $e->detail . PHP_EOL);
}
echo $tx->data['status'], ' ', $tx->data['transaction_id'], PHP_EOL;

if (DateTimeOffset.UtcNow >= venceEn.AddSeconds(-15))
    (riel, res, venceEn) = await Resolver("3109876543", "PHONE"); // y reconfirma

Transaction tx;
try
{
    tx = riel == "p2p"
        ? await client.Wallet.P2P.TransferAsync(Doc, res!.ResolutionToken, Monto, "Pago del almuerzo",
            idempotencyKey: "nova-envio-ENV-2026-004512")
        : await client.Wallet.BreB.TransferAsync(Doc, res!.ResolutionToken, Monto, "Pago del almuerzo",
            idempotencyKey: "nova-envio-ENV-2026-004512");
}
catch (ValidationException e) // 422: no se movió dinero
{
    Console.WriteLine($"No se pudo enviar: {e.Detail}");
    return;
}
Console.WriteLine($"{tx.Data["status"]} {tx.Data["transaction_id"]}");

if time.Now().After(venceEn.Add(-15 * time.Second)) {
	if riel, r, venceEn, err = resolver("3109876543", "PHONE"); err != nil { // y reconfirma
		log.Fatal(err)
	}
}

params := &compense.WalletTransferParams{
	Document: doc, ResolutionToken: r.ResolutionToken,
	Amount: compense.AmountFromInt(int64(monto)), Description: "Pago del almuerzo",
}
llave := compense.WithIdempotencyKey("nova-envio-ENV-2026-004512")
var tx *compense.Transaction
if riel == "p2p" {
	tx, err = client.Wallet.P2P.Transfer(ctx, params, llave)
} else {
	tx, err = client.Wallet.BreB.Transfer(ctx, params, llave)
}
if compense.IsValidationError(err) { // 422: no se movió dinero
	log.Fatal("no se pudo enviar: ", err)
} else if err != nil {
	log.Fatal(err)
}
fmt.Println(tx.Data["status"], tx.Data["transaction_id"])

# Bre-B (para P2P cambia breb/transfers/ por p2p/transfers/ y usa el token de p2p/resolve/)
curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/breb/transfers/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: nova-envio-ENV-2026-004512" \
  -H "Content-Type: application/json" \
  -d '{"document": "1000000001", "resolution_token": "'"$TOKEN"'", "amount": "150000", "description": "Pago del almuerzo"}'

from compense_gateway.webhooks import verify_webhook, WebhookVerificationError

ESTADO = {"wallets.transfer.created": "ENVIADO", "wallets.transfer.settled": "ENTREGADO",
          "wallets.transfer.failed": "FALLIDO"}

def recibir(raw_body: bytes, headers) -> int:
    try:
        ev = verify_webhook(raw_body, headers, secret=os.environ["COMPENSE_WEBHOOK_SECRET"])
    except WebhookVerificationError:
        return 401
    if not ev.is_test and ev.event in ESTADO and not ya_procesado(ev.event_id):
        actualizar_envio(ev.resource["transaction_id"], ESTADO[ev.event], ev.resource.get("reason"))
        registrar_procesado(ev.event_id)
    return 200

import express from "express";
import { verifyWebhook, WebhookVerificationError } from "@compense/sdk/webhooks";

const ESTADO: Record<string, string> = {
  "wallets.transfer.created": "ENVIADO",
  "wallets.transfer.settled": "ENTREGADO",
  "wallets.transfer.failed": "FALLIDO",
};

const app = express();
app.post("/compense/webhooks", express.raw({ type: "*/*" }), (req, res) => {
  let ev;
  try {
    ev = verifyWebhook(req.body, req.headers, process.env.COMPENSE_WEBHOOK_SECRET!);
  } catch (err) {
    if (err instanceof WebhookVerificationError) return res.sendStatus(401);
    throw err;
  }
  if (!ev.isTest && ESTADO[ev.event] && !yaProcesado(ev.eventId)) {
    actualizarEnvio(ev.resource.transaction_id, ESTADO[ev.event], ev.resource.reason);
    registrarProcesado(ev.eventId);
  }
  res.sendStatus(200);
});

use Compense\Sdk\Webhook\Webhook;
use Compense\Sdk\Webhook\WebhookVerificationException;

$estado = [
    'wallets.transfer.created' => 'ENVIADO',
    'wallets.transfer.settled' => 'ENTREGADO',
    'wallets.transfer.failed' => 'FALLIDO',
];
try {
    $ev = Webhook::verify(file_get_contents('php://input'), getallheaders(), getenv('COMPENSE_WEBHOOK_SECRET'));
} catch (WebhookVerificationException) {
    http_response_code(401);
    exit;
}
if (!$ev->isTest() && isset($estado[$ev->event()]) && !yaProcesado($ev->eventId)) {
    $r = $ev->resource();
    actualizarEnvio($r['transaction_id'], $estado[$ev->event()], $r['reason'] ?? null);
    registrarProcesado($ev->eventId);
}
http_response_code(200);

using Compense.Sdk.Webhooks;

var estado = new Dictionary<string, string>
{
    ["wallets.transfer.created"] = "ENVIADO",
    ["wallets.transfer.settled"] = "ENTREGADO",
    ["wallets.transfer.failed"] = "FALLIDO",
};

app.MapPost("/compense/webhooks", async (HttpRequest req) =>
{
    using var cuerpo = new MemoryStream();
    await req.Body.CopyToAsync(cuerpo);
    WebhookEvent ev;
    try { ev = CompenseWebhooks.Verify(cuerpo.ToArray(), req.Headers, Environment.GetEnvironmentVariable("COMPENSE_WEBHOOK_SECRET")!); }
    catch (WebhookVerificationException) { return Results.Unauthorized(); }

    if (!ev.IsTest && estado.TryGetValue(ev.Event, out var nuevo) && !YaProcesado(ev.EventId))
    {
        ActualizarEnvio(ev.Resource["transaction_id"]!.GetValue<string>(), nuevo, ev.Resource["reason"]?.ToString());
        RegistrarProcesado(ev.EventId);
    }
    return Results.Ok();
});

import "github.com/Appiasoft/compense-saas-sdk-go/webhook"

estado := map[string]string{
	"wallets.transfer.created": "ENVIADO",
	"wallets.transfer.settled": "ENTREGADO",
	"wallets.transfer.failed":  "FALLIDO",
}
secrets := []string{os.Getenv("COMPENSE_WEBHOOK_SECRET")}
http.Handle("/compense/webhooks", webhook.Handler(secrets, func(ctx context.Context, ev *webhook.Event) error {
	nuevo, ok := estado[ev.Event()]
	if ev.IsTest() || !ok || yaProcesado(ev.ID) {
		return nil
	}
	r := ev.Resource()
	actualizarEnvio(r["transaction_id"], nuevo, r["reason"])
	registrarProcesado(ev.ID)
	return nil
}))

# Evento de prueba hacia tu endpoint
curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/webhooks/endpoints/$ENDPOINT_ID/test/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"event_type": "wallets.transfer.failed"}'

estado = "PENDING"
while True:
    paso = client.sandbox.simulate.wallet_transfer(status=estado, amount="33.33",
                                                   transaction_id="wtx-E-3f1c9a0b2d4e")
    print(paso["previous_status"], "→", paso["status"], paso.get("reason_code"))
    if paso["terminal"]:
        break
    estado = paso["status"]
# PENDING → PROCESSING → SETTLED → RETURNED (TRANSFER_RETURNED)

let estado = "PENDING";
for (;;) {
  const paso = await client.sandbox.simulate.walletTransfer({ status: estado, amount: "33.33", transactionId: "wtx-E-3f1c9a0b2d4e" });
  console.log(paso.previous_status, "→", paso.status, paso.reason_code ?? "");
  if (paso.terminal) break;
  estado = String(paso.status);
}

$estado = 'PENDING';
do {
    $paso = $client->sandbox->simulate->walletTransfer(status: $estado, amount: '33.33', transactionId: 'wtx-E-3f1c9a0b2d4e');
    echo $paso['previous_status'], ' → ', $paso['status'], ' ', $paso['reason_code'] ?? '', PHP_EOL;
    $estado = $paso['status'];
} while (!$paso['terminal']);

string estadoSim = "PENDING";
while (true)
{
    var paso = await client.Sandbox.Simulate.WalletTransferAsync(estadoSim, "33.33", "wtx-E-3f1c9a0b2d4e");
    Console.WriteLine($"{paso["previous_status"]} → {paso["status"]} {paso["reason_code"]}");
    if (paso["terminal"]!.GetValue<bool>()) break;
    estadoSim = paso["status"]!.GetValue<string>();
}

estadoSim := "PENDING"
for {
	paso, err := client.Sandbox.Simulate.WalletTransfer(ctx, &compense.SimulationState{
		Status: estadoSim, Amount: "33.33", TransactionID: "wtx-E-3f1c9a0b2d4e",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(paso["previous_status"], "→", paso["status"], paso["reason_code"])
	if fin, _ := paso["terminal"].(bool); fin {
		break
	}
	estadoSim, _ = paso["status"].(string)
}

curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/sandbox/wallet/simulate/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"status": "SETTLED", "amount": "33.33", "transaction_id": "wtx-E-3f1c9a0b2d4e"}'
# {"object": "wallet_transfer", "previous_status": "SETTLED", "status": "RETURNED",
#  "terminal": true, "reason_code": "TRANSFER_RETURNED", "amount": 33.33, ...}