* feat: add batch-settlement implementation to Go SDK * feat: add batch-settlement examples for go sdk * feat: updated typescript examples to match go examples * feat: add e2e testing for batch-settlement in go * Batch-settlement: go-ts parity (#2227) * fix PendingRequest and refund cleanup * fix lint * remove duplicate payer info from storage * fix PAYMENT-RESPONSE field ordering * clean up comments * consolidate ProcessSettlementWithExtensions into ProcessSettlement --------- Co-authored-by: phdargen <p.dargent@cern.ch>
798 lines
22 KiB
Go
798 lines
22 KiB
Go
package x402
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/x402-foundation/x402/go/types"
|
|
)
|
|
|
|
// Mock server for testing
|
|
type mockSchemeNetworkServer struct {
|
|
scheme string
|
|
parsePrice func(price Price, network Network) (AssetAmount, error)
|
|
enhanceReqs func(ctx context.Context, base types.PaymentRequirements, supported types.SupportedKind, extensions []string) (types.PaymentRequirements, error)
|
|
}
|
|
|
|
func (m *mockSchemeNetworkServer) Scheme() string {
|
|
return m.scheme
|
|
}
|
|
|
|
func (m *mockSchemeNetworkServer) ParsePrice(price Price, network Network) (AssetAmount, error) {
|
|
if m.parsePrice != nil {
|
|
return m.parsePrice(price, network)
|
|
}
|
|
return AssetAmount{
|
|
Asset: "USDC",
|
|
Amount: "1000000",
|
|
Extra: map[string]interface{}{},
|
|
}, nil
|
|
}
|
|
|
|
func (m *mockSchemeNetworkServer) EnhancePaymentRequirements(ctx context.Context, base types.PaymentRequirements, supported types.SupportedKind, extensions []string) (types.PaymentRequirements, error) {
|
|
if m.enhanceReqs != nil {
|
|
return m.enhanceReqs(ctx, base, supported, extensions)
|
|
}
|
|
enhanced := base
|
|
if enhanced.Extra == nil {
|
|
enhanced.Extra = make(map[string]interface{})
|
|
}
|
|
enhanced.Extra["enhanced"] = true
|
|
return enhanced, nil
|
|
}
|
|
|
|
// mockFacilitatorClient is defined in server_hooks_test.go
|
|
|
|
// mockServerFacilitatorClient extends mockFacilitatorClient for server tests
|
|
type mockServerFacilitatorClient struct {
|
|
kinds []SupportedKind
|
|
}
|
|
|
|
func (m *mockServerFacilitatorClient) Verify(ctx context.Context, payloadBytes []byte, requirementsBytes []byte) (*VerifyResponse, error) {
|
|
return &VerifyResponse{IsValid: true, Payer: "0xpayer"}, nil
|
|
}
|
|
|
|
func (m *mockServerFacilitatorClient) Settle(ctx context.Context, payloadBytes []byte, requirementsBytes []byte) (*SettleResponse, error) {
|
|
return &SettleResponse{Success: true, Transaction: "0xtx", Network: "eip155:1", Payer: "0xpayer"}, nil
|
|
}
|
|
|
|
func (m *mockServerFacilitatorClient) GetSupported(ctx context.Context) (SupportedResponse, error) {
|
|
return SupportedResponse{
|
|
Kinds: m.kinds,
|
|
Extensions: []string{},
|
|
Signers: make(map[string][]string),
|
|
}, nil
|
|
}
|
|
|
|
func TestNewx402ResourceServer(t *testing.T) {
|
|
server := Newx402ResourceServer()
|
|
if server == nil {
|
|
t.Fatal("Expected server to be created")
|
|
}
|
|
if server.schemes == nil {
|
|
t.Fatal("Expected schemes map to be initialized")
|
|
}
|
|
if server.facilitatorClients == nil {
|
|
t.Fatal("Expected facilitator clients to be initialized")
|
|
}
|
|
if server.supportedCache == nil {
|
|
t.Fatal("Expected cache to be initialized")
|
|
}
|
|
}
|
|
|
|
func TestServerWithOptions(t *testing.T) {
|
|
mockClient := &mockFacilitatorClient{
|
|
kinds: []SupportedKind{
|
|
{X402Version: 2, Scheme: "exact", Network: "eip155:1"},
|
|
},
|
|
}
|
|
mockServer := &mockSchemeNetworkServer{scheme: "exact"}
|
|
|
|
server := Newx402ResourceServer(
|
|
WithFacilitatorClient(mockClient),
|
|
WithSchemeServer("eip155:1", mockServer),
|
|
WithCacheTTL(10*time.Minute),
|
|
)
|
|
|
|
// After Initialize, facilitatorClients map will be populated
|
|
ctx := context.Background()
|
|
if err := server.Initialize(ctx); err != nil {
|
|
t.Fatalf("Failed to initialize server: %v", err)
|
|
}
|
|
|
|
// Check schemes were registered
|
|
if server.schemes["eip155:1"]["exact"] != mockServer {
|
|
t.Fatal("Expected scheme server to be registered")
|
|
}
|
|
if server.supportedCache.ttl != 10*time.Minute {
|
|
t.Fatal("Expected cache TTL to be set")
|
|
}
|
|
}
|
|
|
|
func TestServerInitialize(t *testing.T) {
|
|
ctx := context.Background()
|
|
mockClient := &mockServerFacilitatorClient{
|
|
kinds: []SupportedKind{
|
|
{
|
|
X402Version: 2,
|
|
Scheme: "exact",
|
|
Network: "eip155:1",
|
|
},
|
|
{
|
|
X402Version: 2,
|
|
Scheme: "transfer",
|
|
Network: "eip155:8453",
|
|
},
|
|
},
|
|
}
|
|
|
|
server := Newx402ResourceServer(WithFacilitatorClient(mockClient))
|
|
err := server.Initialize(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
|
|
// Verify initialization worked by checking GetSupported
|
|
supported, err := mockClient.GetSupported(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get supported: %v", err)
|
|
}
|
|
totalKinds := len(supported.Kinds)
|
|
if totalKinds != 2 {
|
|
t.Fatalf("Expected 2 kinds, got %d", totalKinds)
|
|
}
|
|
}
|
|
|
|
func TestServerInitializeWithMultipleFacilitators(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
// First facilitator supports exact on mainnet
|
|
mockClient1 := &mockServerFacilitatorClient{
|
|
kinds: []SupportedKind{
|
|
{
|
|
X402Version: 2,
|
|
Scheme: "exact",
|
|
Network: "eip155:1",
|
|
},
|
|
},
|
|
}
|
|
|
|
// Second facilitator supports exact on mainnet and Base
|
|
mockClient2 := &mockServerFacilitatorClient{
|
|
kinds: []SupportedKind{
|
|
{
|
|
X402Version: 2,
|
|
Scheme: "exact",
|
|
Network: "eip155:1", // Same as first
|
|
},
|
|
{
|
|
X402Version: 2,
|
|
Scheme: "exact",
|
|
Network: "eip155:8453", // New network
|
|
},
|
|
},
|
|
}
|
|
|
|
server := Newx402ResourceServer(
|
|
WithFacilitatorClient(mockClient1),
|
|
WithFacilitatorClient(mockClient2),
|
|
)
|
|
|
|
err := server.Initialize(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
|
|
// Verify initialization worked by testing actual verify calls would route correctly
|
|
// (facilitatorClientsMap is now private, test behavior instead of structure)
|
|
payload := types.PaymentPayload{
|
|
X402Version: 2,
|
|
Accepted: types.PaymentRequirements{Scheme: "exact", Network: "eip155:1"},
|
|
Payload: map[string]interface{}{},
|
|
}
|
|
requirements := types.PaymentRequirements{Scheme: "exact", Network: "eip155:1"}
|
|
|
|
result, _ := server.VerifyPayment(ctx, payload, requirements)
|
|
if !result.IsValid {
|
|
t.Fatal("Expected verify to work after initialization")
|
|
}
|
|
}
|
|
|
|
func TestServerBuildPaymentRequirements(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
mockServer := &mockSchemeNetworkServer{
|
|
scheme: "exact",
|
|
parsePrice: func(price Price, network Network) (AssetAmount, error) {
|
|
return AssetAmount{
|
|
Asset: "USDC",
|
|
Amount: "5000000",
|
|
Extra: map[string]interface{}{"decimals": 6},
|
|
}, nil
|
|
},
|
|
}
|
|
|
|
mockClient := &mockFacilitatorClient{}
|
|
|
|
server := Newx402ResourceServer(
|
|
WithFacilitatorClient(mockClient),
|
|
WithSchemeServer("eip155:1", mockServer),
|
|
)
|
|
|
|
// Initialize to populate supported kinds
|
|
if err := server.Initialize(ctx); err != nil {
|
|
t.Fatalf("Failed to initialize server: %v", err)
|
|
}
|
|
|
|
config := ResourceConfig{
|
|
Scheme: "exact",
|
|
PayTo: "0xrecipient",
|
|
Price: "$5.00",
|
|
Network: "eip155:1",
|
|
MaxTimeoutSeconds: 600,
|
|
Extra: map[string]interface{}{
|
|
"assetTransferMethod": "permit2",
|
|
"merchantNote": "custom-scheme-data",
|
|
},
|
|
}
|
|
|
|
// BuildPaymentRequirements now requires supportedKind
|
|
supportedKind := types.SupportedKind{
|
|
Scheme: "exact",
|
|
Network: "eip155:1",
|
|
}
|
|
|
|
requirements, err := server.BuildPaymentRequirements(ctx, config, supportedKind, []string{})
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
|
|
if requirements.Scheme != "exact" {
|
|
t.Fatalf("Expected scheme 'exact', got %s", requirements.Scheme)
|
|
}
|
|
if requirements.Amount != "5000000" {
|
|
t.Fatalf("Expected amount '5000000', got %s", requirements.Amount)
|
|
}
|
|
if requirements.Asset != "USDC" {
|
|
t.Fatalf("Expected asset 'USDC', got %s", requirements.Asset)
|
|
}
|
|
if requirements.MaxTimeoutSeconds != 600 {
|
|
t.Fatalf("Expected timeout 600, got %d", requirements.MaxTimeoutSeconds)
|
|
}
|
|
if requirements.Extra["enhanced"] != true {
|
|
t.Fatal("Expected requirements to be enhanced")
|
|
}
|
|
if requirements.Extra["decimals"] != 6 {
|
|
t.Fatalf("Expected parsed extra to be preserved, got %v", requirements.Extra["decimals"])
|
|
}
|
|
if requirements.Extra["assetTransferMethod"] != "permit2" {
|
|
t.Fatalf("Expected config extra to be merged, got %v", requirements.Extra["assetTransferMethod"])
|
|
}
|
|
if requirements.Extra["merchantNote"] != "custom-scheme-data" {
|
|
t.Fatalf("Expected merchant extra to be merged, got %v", requirements.Extra["merchantNote"])
|
|
}
|
|
}
|
|
|
|
func TestServerBuildPaymentRequirementsNoScheme(t *testing.T) {
|
|
ctx := context.Background()
|
|
server := Newx402ResourceServer()
|
|
|
|
config := ResourceConfig{
|
|
Scheme: "unregistered",
|
|
PayTo: "0xrecipient",
|
|
Price: "$5.00",
|
|
Network: "eip155:1",
|
|
}
|
|
|
|
supportedKind := types.SupportedKind{
|
|
Scheme: "unregistered",
|
|
Network: "eip155:1",
|
|
}
|
|
|
|
_, err := server.BuildPaymentRequirements(ctx, config, supportedKind, []string{})
|
|
if err == nil {
|
|
t.Fatal("Expected error for unregistered scheme")
|
|
}
|
|
|
|
var paymentErr *PaymentError
|
|
if !errors.As(err, &paymentErr) || paymentErr.Code != ErrCodeUnsupportedScheme {
|
|
t.Fatal("Expected UnsupportedScheme error")
|
|
}
|
|
}
|
|
|
|
func TestServerCreatePaymentRequiredResponse(t *testing.T) {
|
|
server := Newx402ResourceServer()
|
|
|
|
requirements := []types.PaymentRequirements{
|
|
{
|
|
Scheme: "exact",
|
|
Network: "eip155:1",
|
|
Asset: "USDC",
|
|
Amount: "1000000",
|
|
PayTo: "0xrecipient",
|
|
},
|
|
}
|
|
|
|
info := &types.ResourceInfo{
|
|
URL: "https://api.example.com/resource",
|
|
Description: "Premium API access",
|
|
MimeType: "application/json",
|
|
}
|
|
|
|
response := server.CreatePaymentRequiredResponse(
|
|
requirements,
|
|
info,
|
|
"Custom error message",
|
|
map[string]interface{}{"custom": "extension"},
|
|
)
|
|
|
|
if response.X402Version != 2 {
|
|
t.Fatalf("Expected version 2, got %d", response.X402Version)
|
|
}
|
|
if response.Error != "Custom error message" {
|
|
t.Fatalf("Expected custom error, got %s", response.Error)
|
|
}
|
|
if response.Resource.URL != info.URL {
|
|
t.Fatal("Expected resource info to be set")
|
|
}
|
|
if len(response.Accepts) != 1 {
|
|
t.Fatal("Expected 1 requirement")
|
|
}
|
|
if response.Extensions["custom"] != "extension" {
|
|
t.Fatal("Expected custom extension")
|
|
}
|
|
}
|
|
|
|
// stubEnricherScheme records EnrichPaymentRequiredResponse calls and mutates
|
|
// the matching requirement's Extra to verify core wiring.
|
|
type stubEnricherScheme struct {
|
|
calls int
|
|
lastErrorReason string
|
|
lastPayload *types.PaymentPayload
|
|
}
|
|
|
|
func (s *stubEnricherScheme) Scheme() string { return "stub-enricher" }
|
|
func (s *stubEnricherScheme) ParsePrice(_ Price, _ Network) (AssetAmount, error) {
|
|
return AssetAmount{}, nil
|
|
}
|
|
func (s *stubEnricherScheme) EnhancePaymentRequirements(
|
|
_ context.Context,
|
|
r types.PaymentRequirements,
|
|
_ types.SupportedKind,
|
|
_ []string,
|
|
) (types.PaymentRequirements, error) {
|
|
return r, nil
|
|
}
|
|
func (s *stubEnricherScheme) EnrichPaymentRequiredResponse(ctx PaymentRequiredContext) {
|
|
s.calls++
|
|
s.lastErrorReason = ctx.Error
|
|
s.lastPayload = ctx.PaymentPayload
|
|
for i := range ctx.Requirements {
|
|
if ctx.Requirements[i].Scheme != "stub-enricher" {
|
|
continue
|
|
}
|
|
if ctx.Requirements[i].Extra == nil {
|
|
ctx.Requirements[i].Extra = map[string]interface{}{}
|
|
}
|
|
ctx.Requirements[i].Extra["EnrichedBy"] = "stub-enricher"
|
|
}
|
|
}
|
|
|
|
func TestCreatePaymentRequiredResponse_InvokesEnricher(t *testing.T) {
|
|
server := Newx402ResourceServer()
|
|
enricher := &stubEnricherScheme{}
|
|
server.Register(Network("eip155:1"), enricher)
|
|
|
|
pp := &types.PaymentPayload{X402Version: 2}
|
|
requirements := []types.PaymentRequirements{
|
|
{Scheme: "stub-enricher", Network: "eip155:1", Asset: "USDC", Amount: "1"},
|
|
}
|
|
resp := server.CreatePaymentRequiredResponseWithPayload(
|
|
requirements, &types.ResourceInfo{URL: "https://x"}, "some_error", nil, pp,
|
|
)
|
|
|
|
if enricher.calls != 1 {
|
|
t.Fatalf("expected 1 enricher call, got %d", enricher.calls)
|
|
}
|
|
if enricher.lastErrorReason != "some_error" {
|
|
t.Fatalf("unexpected error reason: %q", enricher.lastErrorReason)
|
|
}
|
|
if enricher.lastPayload != pp {
|
|
t.Fatalf("expected payload to flow through")
|
|
}
|
|
if resp.Accepts[0].Extra["EnrichedBy"] != "stub-enricher" {
|
|
t.Fatalf("expected enrichment mutation, got %+v", resp.Accepts[0].Extra)
|
|
}
|
|
}
|
|
|
|
func TestCreatePaymentRequiredResponse_NoEnricherForUnknownScheme(t *testing.T) {
|
|
server := Newx402ResourceServer()
|
|
requirements := []types.PaymentRequirements{
|
|
{Scheme: "unknown", Network: "eip155:1"},
|
|
}
|
|
// Must not panic and must return baseline response.
|
|
resp := server.CreatePaymentRequiredResponse(requirements, nil, "err", nil)
|
|
if len(resp.Accepts) != 1 {
|
|
t.Fatalf("expected requirements untouched")
|
|
}
|
|
}
|
|
|
|
func TestServerVerifyPayment(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
mockClient := &mockFacilitatorClient{
|
|
kinds: []SupportedKind{
|
|
{X402Version: 2, Scheme: "exact", Network: "eip155:1"},
|
|
},
|
|
verify: func(ctx context.Context, payloadBytes []byte, requirementsBytes []byte) (*VerifyResponse, error) {
|
|
return &VerifyResponse{
|
|
IsValid: true,
|
|
Payer: "0xverifiedpayer",
|
|
}, nil
|
|
},
|
|
}
|
|
|
|
server := Newx402ResourceServer(WithFacilitatorClient(mockClient))
|
|
if err := server.Initialize(ctx); err != nil {
|
|
t.Fatalf("Failed to initialize server: %v", err)
|
|
}
|
|
|
|
requirements := types.PaymentRequirements{
|
|
Scheme: "exact",
|
|
Network: "eip155:1",
|
|
Asset: "USDC",
|
|
Amount: "1000000",
|
|
PayTo: "0xrecipient",
|
|
}
|
|
|
|
payload := types.PaymentPayload{
|
|
X402Version: 2,
|
|
Accepted: requirements,
|
|
Payload: map[string]interface{}{},
|
|
}
|
|
|
|
// Server uses typed API now
|
|
response, err := server.VerifyPayment(ctx, payload, requirements)
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
if !response.IsValid {
|
|
t.Fatal("Expected valid verification")
|
|
}
|
|
if response.Payer != "0xverifiedpayer" {
|
|
t.Fatalf("Expected payer '0xverifiedpayer', got %s", response.Payer)
|
|
}
|
|
}
|
|
|
|
func TestServerSettlePayment(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
mockClient := &mockFacilitatorClient{
|
|
kinds: []SupportedKind{
|
|
{X402Version: 2, Scheme: "exact", Network: "eip155:1"},
|
|
},
|
|
settle: func(ctx context.Context, payloadBytes []byte, requirementsBytes []byte) (*SettleResponse, error) {
|
|
return &SettleResponse{
|
|
Success: true,
|
|
Transaction: "0xsettledtx",
|
|
Payer: "0xpayer",
|
|
Network: "eip155:1",
|
|
}, nil
|
|
},
|
|
}
|
|
|
|
server := Newx402ResourceServer(WithFacilitatorClient(mockClient))
|
|
if err := server.Initialize(ctx); err != nil {
|
|
t.Fatalf("Failed to initialize server: %v", err)
|
|
}
|
|
|
|
requirements := types.PaymentRequirements{
|
|
Scheme: "exact",
|
|
Network: "eip155:1",
|
|
Asset: "USDC",
|
|
Amount: "1000000",
|
|
PayTo: "0xrecipient",
|
|
}
|
|
|
|
payload := types.PaymentPayload{
|
|
X402Version: 2,
|
|
Accepted: requirements,
|
|
Payload: map[string]interface{}{},
|
|
}
|
|
|
|
// Server uses typed API now
|
|
response, err := server.SettlePayment(ctx, payload, requirements, nil)
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
if !response.Success {
|
|
t.Fatal("Expected successful settlement")
|
|
}
|
|
if response.Transaction != "0xsettledtx" {
|
|
t.Fatalf("Expected transaction '0xsettledtx', got %s", response.Transaction)
|
|
}
|
|
}
|
|
|
|
func TestServerFindMatchingRequirements(t *testing.T) {
|
|
server := Newx402ResourceServer()
|
|
|
|
available := []types.PaymentRequirements{
|
|
{
|
|
Scheme: "exact",
|
|
Network: "eip155:1",
|
|
Asset: "USDC",
|
|
Amount: "1000000",
|
|
PayTo: "0xrecipient1",
|
|
},
|
|
{
|
|
Scheme: "transfer",
|
|
Network: "eip155:8453",
|
|
Asset: "USDC",
|
|
Amount: "2000000",
|
|
PayTo: "0xrecipient2",
|
|
},
|
|
}
|
|
|
|
// Test V2 matching (typed)
|
|
payloadV2 := types.PaymentPayload{
|
|
X402Version: 2,
|
|
Accepted: types.PaymentRequirements{
|
|
Scheme: "transfer",
|
|
Network: "eip155:8453",
|
|
Asset: "USDC",
|
|
Amount: "2000000",
|
|
PayTo: "0xrecipient2",
|
|
},
|
|
}
|
|
|
|
matched := server.FindMatchingRequirements(available, payloadV2)
|
|
if matched == nil {
|
|
t.Fatal("Expected match for v2")
|
|
}
|
|
if matched.Scheme != "transfer" {
|
|
t.Fatal("Expected transfer scheme to match")
|
|
}
|
|
|
|
// Server is V2 only - skip V1 matching test
|
|
|
|
// Test no match
|
|
payloadNoMatch := types.PaymentPayload{
|
|
X402Version: 2,
|
|
Accepted: types.PaymentRequirements{
|
|
Scheme: "nonexistent",
|
|
Network: "eip155:1",
|
|
Asset: "USDC",
|
|
Amount: "3000000",
|
|
PayTo: "0xrecipient3",
|
|
},
|
|
}
|
|
|
|
matched = server.FindMatchingRequirements(available, payloadNoMatch)
|
|
if matched != nil {
|
|
t.Fatal("Expected no match")
|
|
}
|
|
}
|
|
|
|
// TestServerProcessPaymentRequest - SKIPPED: ProcessPaymentRequest is a stub
|
|
/*
|
|
func TestServerProcessPaymentRequest(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
mockServer := &mockSchemeNetworkServer{scheme: "exact"}
|
|
mockClient := &mockFacilitatorClient{}
|
|
|
|
server := Newx402ResourceServer(
|
|
WithFacilitatorClient(mockClient),
|
|
WithSchemeServer("eip155:1", mockServer),
|
|
)
|
|
server.Initialize(ctx)
|
|
|
|
config := ResourceConfig{
|
|
Scheme: "exact",
|
|
PayTo: "0xrecipient",
|
|
Price: "$1.00",
|
|
Network: "eip155:1",
|
|
}
|
|
|
|
info := ResourceInfo{
|
|
URL: "https://api.example.com/resource",
|
|
Description: "API resource",
|
|
}
|
|
|
|
// Test without payment (should require payment)
|
|
result, err := server.ProcessPaymentRequest(ctx, nil, config, info, nil)
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
if result.Success {
|
|
t.Fatal("Expected payment to be required")
|
|
}
|
|
if result.RequiresPayment == nil {
|
|
t.Fatal("Expected payment required response")
|
|
}
|
|
|
|
// Test with valid payment
|
|
// First, build requirements to see what they actually are
|
|
builtReqs, _ := server.BuildPaymentRequirements(ctx, config)
|
|
|
|
payload := &PaymentPayload{
|
|
X402Version: 2,
|
|
Payload: map[string]interface{}{},
|
|
Accepted: builtReqs[0], // Use the actual built requirements
|
|
}
|
|
|
|
result, err = server.ProcessPaymentRequest(ctx, payload, config, info, nil)
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
if !result.Success {
|
|
if result.Error != "" {
|
|
t.Fatalf("Expected payment to be verified, got error: %s", result.Error)
|
|
}
|
|
if result.RequiresPayment != nil {
|
|
t.Fatalf("Expected payment to be verified, got payment required: %v", result.RequiresPayment.Error)
|
|
}
|
|
t.Fatal("Expected payment to be verified")
|
|
}
|
|
if result.VerificationResult == nil {
|
|
t.Fatal("Expected verification result")
|
|
}
|
|
if !result.VerificationResult.IsValid {
|
|
t.Fatal("Expected valid verification")
|
|
}
|
|
}
|
|
*/
|
|
|
|
func TestSupportedCache(t *testing.T) {
|
|
cache := &SupportedCache{
|
|
data: make(map[string]SupportedResponse),
|
|
expiry: make(map[string]time.Time),
|
|
ttl: 100 * time.Millisecond,
|
|
}
|
|
|
|
response := SupportedResponse{
|
|
Kinds: []SupportedKind{
|
|
{X402Version: 2, Scheme: "exact", Network: "eip155:1"},
|
|
},
|
|
Extensions: []string{},
|
|
Signers: make(map[string][]string),
|
|
}
|
|
|
|
// Set stores the value.
|
|
cache.Set("test", response)
|
|
if len(cache.data) != 1 {
|
|
t.Fatal("Expected item in cache")
|
|
}
|
|
|
|
// Get returns the stored value before expiry.
|
|
cached, ok := cache.Get("test")
|
|
if !ok {
|
|
t.Fatal("Expected cached item to be found")
|
|
}
|
|
if len(cached.Kinds) != 1 || cached.Kinds[0].Scheme != "exact" || cached.Kinds[0].Network != "eip155:1" {
|
|
t.Fatalf("Expected cached response to match stored value, got %+v", cached)
|
|
}
|
|
|
|
// Clear removes all data and expiry state.
|
|
cache.Clear()
|
|
if len(cache.data) != 0 {
|
|
t.Fatal("Expected cache to be cleared")
|
|
}
|
|
if len(cache.expiry) != 0 {
|
|
t.Fatal("Expected expiry map to be cleared")
|
|
}
|
|
|
|
// Get returns false after the cache is cleared.
|
|
if _, ok := cache.Get("test"); ok {
|
|
t.Fatal("Expected cache miss after Clear")
|
|
}
|
|
}
|
|
|
|
func TestResolveSettlementOverrideAmount(t *testing.T) {
|
|
baseReqs := types.PaymentRequirements{
|
|
Amount: "2000",
|
|
}
|
|
|
|
t.Run("raw atomic units", func(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
expected string
|
|
}{
|
|
{"1000", "1000"},
|
|
{"0", "0"},
|
|
{"999999", "999999"},
|
|
}
|
|
for _, tt := range tests {
|
|
result, err := ResolveSettlementOverrideAmount(tt.input, baseReqs, 6)
|
|
if err != nil {
|
|
t.Errorf("ResolveSettlementOverrideAmount(%q) error: %v", tt.input, err)
|
|
}
|
|
if result != tt.expected {
|
|
t.Errorf("ResolveSettlementOverrideAmount(%q) = %q, want %q", tt.input, result, tt.expected)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("percent format", func(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
amount string
|
|
expected string
|
|
}{
|
|
{"50%", "2000", "1000"},
|
|
{"100%", "2000", "2000"},
|
|
{"0%", "2000", "0"},
|
|
{"25%", "2000", "500"},
|
|
{"33.33%", "3000", "999"},
|
|
{"10.5%", "1000", "105"},
|
|
}
|
|
for _, tt := range tests {
|
|
reqs := types.PaymentRequirements{Amount: tt.amount}
|
|
result, err := ResolveSettlementOverrideAmount(tt.input, reqs, 6)
|
|
if err != nil {
|
|
t.Errorf("ResolveSettlementOverrideAmount(%q, amount=%s) error: %v", tt.input, tt.amount, err)
|
|
}
|
|
if result != tt.expected {
|
|
t.Errorf("ResolveSettlementOverrideAmount(%q, amount=%s) = %q, want %q", tt.input, tt.amount, result, tt.expected)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("dollar price with default 6 decimals", func(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
expected string
|
|
}{
|
|
{"$1.00", "1000000"},
|
|
{"$0.05", "50000"},
|
|
{"$0.001", "1000"},
|
|
{"$0", "0"},
|
|
}
|
|
for _, tt := range tests {
|
|
result, err := ResolveSettlementOverrideAmount(tt.input, baseReqs, 6)
|
|
if err != nil {
|
|
t.Errorf("ResolveSettlementOverrideAmount(%q) error: %v", tt.input, err)
|
|
}
|
|
if result != tt.expected {
|
|
t.Errorf("ResolveSettlementOverrideAmount(%q) = %q, want %q", tt.input, result, tt.expected)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("dollar price with 8 decimals", func(t *testing.T) {
|
|
reqs := types.PaymentRequirements{Amount: "2000"}
|
|
result, err := ResolveSettlementOverrideAmount("$0.05", reqs, 8)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if result != "5000000" {
|
|
t.Errorf("expected 5000000 (8 decimals), got %s", result)
|
|
}
|
|
})
|
|
|
|
t.Run("dollar price result uses requirements asset regardless of decimals", func(t *testing.T) {
|
|
reqs := types.PaymentRequirements{Amount: "2000", Asset: "0xSomeToken"}
|
|
result, err := ResolveSettlementOverrideAmount("$0.001", reqs, 6)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
// Only the amount changes; the asset remains whatever is in requirements
|
|
if result != "1000" {
|
|
t.Errorf("expected 1000, got %s", result)
|
|
}
|
|
})
|
|
|
|
t.Run("dollar price with 6 decimals", func(t *testing.T) {
|
|
reqs := types.PaymentRequirements{Amount: "2000", Asset: "0xUnknownToken"}
|
|
result, err := ResolveSettlementOverrideAmount("$0.05", reqs, 6)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if result != "50000" {
|
|
t.Errorf("expected 50000 (6 decimals), got %s", result)
|
|
}
|
|
})
|
|
}
|