problem+json errors

from compense_gateway import (AuthError, CompenseAPIError, IdempotencyConflictError,
                              NotFoundError, RateLimitError, ValidationError)

try:
    client.wallet.p2p.transfer(document="1032456789", resolution_token=token,
                               amount="30000", idempotency_key="nova-p2p-2026-11-02-000123")
except ValidationError as e:
    for err in e.errors:                       # 422: per-field errors
        print(err["field"], err["message"])
    print(e.detail)                            # or the engine's message
except IdempotencyConflictError as e:
    if e.problem.type.endswith("/idempotency-conflict"):
        ...                                    # in progress: retry with the same key
    else:
        print("Engine rejection:", e.detail)   # e.g. expired token or insufficient funds
except RateLimitError as e:
    print("Retry in", e.retry_after, "s")
except (AuthError, NotFoundError):
    raise
except CompenseAPIError as e:
    log.error("Compense %s %s trace=%s", e.status, e.title, e.trace_id)
    raise

import {
  AuthError, CompenseAPIError, CompenseConnectionError, IdempotencyConflictError,
  RateLimitError, ValidationError,
} from "@compense/sdk";

try {
  await client.wallet.p2p.transfer({ document: "1032456789", resolutionToken: token,
    amount: "30000", idempotencyKey: "nova-p2p-2026-11-02-000123" });
} catch (err) {
  if (err instanceof ValidationError) {
    for (const e of err.errors) console.log(e.field, e.message);
  } else if (err instanceof IdempotencyConflictError) {
    if (err.problem.type.endsWith("/idempotency-conflict")) { /* retry with the same key */ }
    else console.log("Engine rejection:", err.detail);
  } else if (err instanceof RateLimitError) {
    console.log("Retry in", err.retryAfter, "s");
  } else if (err instanceof AuthError) {
    throw err;
  } else if (err instanceof CompenseAPIError) {
    console.error(`Compense ${err.status} ${err.title} trace=${err.traceId}`);
    throw err;
  } else if (err instanceof CompenseConnectionError) {
    // no response: resend with the SAME idempotencyKey
  } else throw err;
}

use Compense\Sdk\Exception\AuthException;
use Compense\Sdk\Exception\CompenseApiException;
use Compense\Sdk\Exception\IdempotencyConflictException;
use Compense\Sdk\Exception\RateLimitException;
use Compense\Sdk\Exception\TransportException;
use Compense\Sdk\Exception\ValidationException;

try {
    $client->wallet->p2p->transfer(document: '1032456789', resolutionToken: $token,
        amount: '30000', idempotencyKey: 'nova-p2p-2026-11-02-000123');
} catch (ValidationException $e) {
    foreach ($e->errors() as $err) {
        echo $err['field'], ': ', $err['message'], PHP_EOL;
    }
} catch (IdempotencyConflictException $e) {
    if (str_ends_with($e->problem->type, '/idempotency-conflict')) {
        // in progress: retry with the same key
    } else {
        echo 'Engine rejection: ', $e->detail, PHP_EOL;
    }
} catch (RateLimitException $e) {
    echo 'Retry in ', $e->retryAfter, ' s', PHP_EOL;
} catch (AuthException $e) {
    throw $e;
} catch (CompenseApiException $e) {
    error_log("Compense {$e->status} {$e->title} trace={$e->traceId}");
    throw $e;
} catch (TransportException $e) {
    // no response: resend with the SAME idempotencyKey
}

try
{
    await client.Wallet.P2P.TransferAsync("1032456789", token, "30000",
        idempotencyKey: "nova-p2p-2026-11-02-000123");
}
catch (ValidationException e)
{
    foreach (var err in e.Errors) Console.WriteLine($"{err["field"]}: {err["message"]}");
}
catch (IdempotencyConflictException e) when (e.Problem.Type.EndsWith("/idempotency-conflict"))
{
    // in progress: retry with the same key
}
catch (IdempotencyConflictException e)
{
    Console.WriteLine($"Engine rejection: {e.Detail}");
}
catch (RateLimitException e)
{
    Console.WriteLine($"Retry in {e.RetryAfter}");
}
catch (CompenseApiException e) when (e is not AuthException)
{
    logger.LogError("Compense {Status} {Title} trace={TraceId}", e.Status, e.Title, e.TraceId);
    throw;
}

_, err := client.Wallet.P2P.Transfer(ctx, &compense.WalletTransferParams{
	Document: "1032456789", ResolutionToken: token, Amount: "30000",
}, compense.WithIdempotencyKey("nova-p2p-2026-11-02-000123"))

var apiErr *compense.APIError
switch {
case err == nil:
case compense.IsValidationError(err):
	errors.As(err, &apiErr)
	for _, fe := range apiErr.Errors() {
		fmt.Println(fe["field"], fe["message"])
	}
case compense.IsIdempotencyConflict(err):
	errors.As(err, &apiErr)
	if strings.HasSuffix(apiErr.Problem.Type, "/idempotency-conflict") {
		// in progress: retry with the same key
	} else {
		fmt.Println("engine rejection:", apiErr.Detail)
	}
case compense.IsRateLimited(err):
	errors.As(err, &apiErr)
	fmt.Println("retry in", *apiErr.RetryAfter)
case errors.As(err, &apiErr):
	log.Printf("compense %d %s trace=%s", apiErr.StatusCode, apiErr.Title, apiErr.TraceID)
default:
	// transport or context: resend with the SAME key
}

curl -s -X POST https://sandbox.dev.compense.co/gw/v1/gateway/wallet/p2p/transfers/ \
  -H "X-API-Key: $COMPENSE_API_KEY" -H "Idempotency-Key: nova-p2p-2026-11-02-000123" \
  -H "Content-Type: application/json" \
  -d '{"document":"1032456789","resolution_token":"vencido","amount":"30000"}' \
  -w '\nHTTP %{http_code}\n'
# {"type":"…","title":"…","status":409,"detail":"…","trace_id":"…"}