x402/go/server_test.go
Carson Roscoe 2b7914c72e
feat: batch settlement go sdk (#2230)
* 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>
2026-05-07 18:26:39 -07:00

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)
}
})
}