x402

type AfterPaymentCreationHook ¶

type AfterPaymentCreationHook func(PaymentCreatedContext) error

AfterPaymentCreationHook is called after successful payment payload creation Any error returned will be logged but will not affect the payment creation result

type AfterSettleHook ¶

type AfterSettleHook func(SettleResultContext) error

AfterSettleHook is called after successful payment settlement Any error returned will be logged but will not affect the settlement result

type AfterVerifyHook ¶

type AfterVerifyHook func(VerifyResultContext) error

AfterVerifyHook is called after successful payment verification Any error returned will be logged but will not affect the verification result

type AssetAmount ¶

type AssetAmount struct {
	Asset  string                 `json:"asset"`
	Amount string                 `json:"amount"`
	Extra  map[string]interface{} `json:"extra,omitempty"`
}

AssetAmount represents an amount of a specific asset

type AssetDecimalsProvider ¶

type AssetDecimalsProvider interface {
	GetAssetDecimals(asset string, network Network) int
}

AssetDecimalsProvider is an optional interface that SchemeNetworkServer implementations can satisfy to report the decimal precision of the asset for a given network. SettlePayment uses this to convert dollar-format settlement overrides to atomic units. Falls back to 6 decimals when the scheme does not implement this interface.

type BeforeHookResult ¶

type BeforeHookResult struct {
	Abort   bool
	Reason  string
	Message string
}

BeforeHookResult represents the result of a "before" hook If Abort is true, the operation will be aborted with the given Reason

type BeforePaymentCreationHook ¶

type BeforePaymentCreationHook func(PaymentCreationContext) (*BeforePaymentCreationHookResult, error)

BeforePaymentCreationHook is called before payment payload creation If it returns a result with Abort=true, payment creation will be aborted and an error will be returned with the provided reason

type BeforePaymentCreationHookResult ¶

type BeforePaymentCreationHookResult struct {
	Abort  bool
	Reason string
}

BeforePaymentCreationHookResult represents the result of a "before payment creation" hook If Abort is true, the payment creation will be aborted with the given Reason

type BeforeSettleHook ¶

type BeforeSettleHook func(SettleContext) (*BeforeHookResult, error)

BeforeSettleHook is called before payment settlement If it returns a result with Abort=true, settlement will be aborted and an error will be returned with the provided reason

type BeforeVerifyHook ¶

type BeforeVerifyHook func(VerifyContext) (*BeforeHookResult, error)

BeforeVerifyHook is called before payment verification If it returns a result with Abort=true, verification will be skipped and an invalid VerifyResponse will be returned with the provided reason

type ClientExtension ¶

type ClientExtension interface {
	// Key returns the unique extension identifier (e.g., "eip2612GasSponsoring").
	// Must match the extension key used in PaymentRequired.Extensions.
	Key() string

	// EnrichPaymentPayload is called after payload creation when the extension key
	// is present in paymentRequired.Extensions. Allows the extension to enrich the
	// payload with extension-specific data (e.g., signing an EIP-2612 permit).
	EnrichPaymentPayload(ctx context.Context, payload types.PaymentPayload, required types.PaymentRequired) (types.PaymentPayload, error)
}

ClientExtension can enrich payment payloads on the client side. Client extensions are invoked after the scheme creates the base payload but before it is returned. This allows mechanism-specific logic (e.g., EVM EIP-2612 permit signing) to enrich the payload's extensions data.

type ClientOption ¶

type ClientOption func(*x402Client)

ClientOption configures the client

func WithAfterPaymentCreationHook(hook AfterPaymentCreationHook) ClientOption

func WithBeforePaymentCreationHook(hook BeforePaymentCreationHook) ClientOption

func WithOnPaymentCreationFailureHook(hook OnPaymentCreationFailureHook) ClientOption

func WithPaymentSelector(selector PaymentRequirementsSelector) ClientOption

func WithPolicy(policy PaymentPolicy) ClientOption

type ExtensionAwareClient ¶

type ExtensionAwareClient interface {
	SchemeNetworkClient
	CreatePaymentPayloadWithExtensions(ctx context.Context, requirements types.PaymentRequirements, extensions map[string]interface{}) (types.PaymentPayload, error)
}

ExtensionAwareClient is an optional interface for schemes that can handle extensions. When a scheme implements this, x402Client will call CreatePaymentPayloadWithExtensions instead of CreatePaymentPayload, passing the server-declared extensions so the scheme can enrich the payload (e.g., EIP-2612 gas sponsoring).

type FacilitatorAfterSettleHook ¶

type FacilitatorAfterSettleHook func(FacilitatorSettleResultContext) error

FacilitatorAfterSettleHook is called after successful facilitator payment settlement Any error returned will be logged but will not affect the settlement result

type FacilitatorAfterVerifyHook ¶

type FacilitatorAfterVerifyHook func(FacilitatorVerifyResultContext) error

FacilitatorAfterVerifyHook is called after successful facilitator payment verification Any error returned will be logged but will not affect the verification result

type FacilitatorBeforeHookResult ¶

type FacilitatorBeforeHookResult struct {
	Abort   bool
	Reason  string
	Message string
}

FacilitatorBeforeHookResult represents the result of a facilitator "before" hook If Abort is true, the operation will be aborted with the given Reason

type FacilitatorBeforeSettleHook ¶

type FacilitatorBeforeSettleHook func(FacilitatorSettleContext) (*FacilitatorBeforeHookResult, error)

FacilitatorBeforeSettleHook is called before facilitator payment settlement If it returns a result with Abort=true, settlement will be aborted and an error will be returned with the provided reason

type FacilitatorBeforeVerifyHook ¶

type FacilitatorBeforeVerifyHook func(FacilitatorVerifyContext) (*FacilitatorBeforeHookResult, error)

FacilitatorBeforeVerifyHook is called before facilitator payment verification If it returns a result with Abort=true, verification will be skipped and an invalid VerifyResponse will be returned with the provided reason

type FacilitatorClient ¶

type FacilitatorClient interface {
	// Verify a payment (detects version from bytes, routes internally)
	Verify(ctx context.Context, payloadBytes []byte, requirementsBytes []byte) (*VerifyResponse, error)

	// Settle a payment (detects version from bytes, routes internally)
	Settle(ctx context.Context, payloadBytes []byte, requirementsBytes []byte) (*SettleResponse, error)

	// GetSupported returns supported payment kinds in flat array format with x402Version in each element (backward compatible)
	GetSupported(ctx context.Context) (SupportedResponse, error)
}

FacilitatorClient interface for facilitators that support V1 and/or V2. Uses bytes at network boundary - SDK internal routing unmarshals and routes to typed mechanisms. Both modern facilitators (supporting V1+V2) and legacy facilitators (V1 only) implement this interface.

type FacilitatorContext ¶

type FacilitatorContext struct {
	// contains filtered or unexported fields
}

FacilitatorContext provides access to registered facilitator extensions. Passed to SchemeNetworkFacilitator.Verify/Settle so mechanism implementations can retrieve extension-provided capabilities.

func NewFacilitatorContext(extensions map[string]FacilitatorExtension) *FacilitatorContext

func (c *FacilitatorContext) GetExtension(key string) FacilitatorExtension

type FacilitatorExtension ¶

type FacilitatorExtension interface {
	Key() string
}

FacilitatorExtension is the base interface for extensions registered with x402Facilitator. Extensions are stored by key and made available to mechanism implementations via FacilitatorContext. Specific extensions embed this and add their own capabilities (e.g., a batch signer).

func NewFacilitatorExtension(key string) FacilitatorExtension

type FacilitatorOnSettleFailureHook ¶

type FacilitatorOnSettleFailureHook func(FacilitatorSettleFailureContext) (*FacilitatorSettleFailureHookResult, error)

FacilitatorOnSettleFailureHook is called when facilitator payment settlement fails If it returns a result with Recovered=true, the provided SettleResponse will be returned instead of the error

type FacilitatorOnVerifyFailureHook ¶

type FacilitatorOnVerifyFailureHook func(FacilitatorVerifyFailureContext) (*FacilitatorVerifyFailureHookResult, error)

FacilitatorOnVerifyFailureHook is called when facilitator payment verification fails If it returns a result with Recovered=true, the provided VerifyResponse will be returned instead of the error

type FacilitatorSettleContext ¶

type FacilitatorSettleContext struct {
	Ctx               context.Context
	Payload           PaymentPayloadView
	Requirements      PaymentRequirementsView
	PayloadBytes      []byte // Raw bytes for extensions needing full data
	RequirementsBytes []byte // Raw bytes for extensions needing full data
}

FacilitatorSettleContext contains information passed to facilitator settle hooks Uses view interfaces for version-agnostic hooks PayloadBytes and RequirementsBytes provide escape hatch for extensions (e.g., Bazaar)

type FacilitatorSettleFailureContext ¶

type FacilitatorSettleFailureContext struct {
	FacilitatorSettleContext
	Error error
}

FacilitatorSettleFailureContext contains facilitator settle operation failure and context

type FacilitatorSettleFailureHookResult ¶

type FacilitatorSettleFailureHookResult struct {
	Recovered bool
	Result    *SettleResponse
}

FacilitatorSettleFailureHookResult represents the result of a facilitator settle failure hook

type FacilitatorSettleResultContext ¶

type FacilitatorSettleResultContext struct {
	FacilitatorSettleContext
	Result *SettleResponse
}

FacilitatorSettleResultContext contains facilitator settle operation result and context

type FacilitatorVerifyContext ¶

type FacilitatorVerifyContext struct {
	Ctx               context.Context
	Payload           PaymentPayloadView
	Requirements      PaymentRequirementsView
	PayloadBytes      []byte // Raw bytes for extensions needing full data
	RequirementsBytes []byte // Raw bytes for extensions needing full data
}

FacilitatorVerifyContext contains information passed to facilitator verify hooks Uses view interfaces for version-agnostic hooks PayloadBytes and RequirementsBytes provide escape hatch for extensions (e.g., Bazaar)

type FacilitatorVerifyFailureContext ¶

type FacilitatorVerifyFailureContext struct {
	FacilitatorVerifyContext
	Error error
}

FacilitatorVerifyFailureContext contains facilitator verify operation failure and context

type FacilitatorVerifyFailureHookResult ¶

type FacilitatorVerifyFailureHookResult struct {
	Recovered bool
	Result    *VerifyResponse
}

FacilitatorVerifyFailureHookResult represents the result of a facilitator verify failure hook If Recovered is true, the hook has recovered from the failure with the given result

type FacilitatorVerifyResultContext ¶

type FacilitatorVerifyResultContext struct {
	FacilitatorVerifyContext
	Result *VerifyResponse
}

FacilitatorVerifyResultContext contains facilitator verify operation result and context

type MoneyParser ¶

type MoneyParser func(amount float64, network Network) (*AssetAmount, error)

MoneyParser is a function that converts a decimal amount to an AssetAmount If the parser cannot handle the conversion, it should return nil Multiple parsers can be registered and will be tried in order The default parser is always used as a fallback

Args:

amount: Decimal amount (e.g., 1.50 for $1.50)
network: Network identifier

Returns:

AssetAmount or nil if this parser cannot handle the conversion

type Network ¶

type Network string

Network represents a blockchain network identifier in CAIP-2 format Format: namespace:reference (e.g., "eip155:1" for Ethereum mainnet)

func ParseNetwork(s string) Network

func (n Network) Match(pattern Network) bool

func (n Network) Parse() (namespace, reference string, err error)

type OnPaymentCreationFailureHook ¶

type OnPaymentCreationFailureHook func(PaymentCreationFailureContext) (*PaymentCreationFailureHookResult, error)

OnPaymentCreationFailureHook is called when payment payload creation fails If it returns a result with Recovered=true, the provided PaymentPayload will be returned instead of the error

type OnSettleFailureHook ¶

type OnSettleFailureHook func(SettleFailureContext) (*SettleFailureHookResult, error)

OnSettleFailureHook is called when payment settlement fails If it returns a result with Recovered=true, the provided SettleResponse will be returned instead of the error

type OnVerifyFailureHook ¶

type OnVerifyFailureHook func(VerifyFailureContext) (*VerifyFailureHookResult, error)

OnVerifyFailureHook is called when payment verification fails If it returns a result with Recovered=true, the provided VerifyResponse will be returned instead of the error

type PartialPaymentPayload ¶

type PartialPaymentPayload struct {
	X402Version int `json:"x402Version"`
}

PartialPaymentPayload contains only x402Version for version detection Used to detect protocol version before unmarshaling to specific types

type PaymentCreatedContext ¶

type PaymentCreatedContext struct {
	PaymentCreationContext
	Payload PaymentPayloadView
}

PaymentCreatedContext contains payment creation result and context

type PaymentCreationContext ¶

type PaymentCreationContext struct {
	Ctx                  context.Context
	Version              int // V1 or V2
	SelectedRequirements PaymentRequirementsView
}

PaymentCreationContext contains information passed to payment creation hooks Uses view interfaces for version-agnostic hooks

type PaymentCreationFailureContext ¶

type PaymentCreationFailureContext struct {
	PaymentCreationContext
	Error error
}

PaymentCreationFailureContext contains payment creation failure and context

type PaymentCreationFailureHookResult ¶

type PaymentCreationFailureHookResult struct {
	Recovered bool
	Payload   PaymentPayloadView
}

PaymentCreationFailureHookResult represents the result of a payment creation failure hook If Recovered is true, the hook has recovered from the failure with the given payload

type PaymentError ¶

type PaymentError struct {
	Code    string                 `json:"code"`
	Message string                 `json:"message"`
	Details map[string]interface{} `json:"details,omitempty"`
}

PaymentError represents a payment-specific error

func NewPaymentError(code, message string, details map[string]interface{}) *PaymentError

func (e *PaymentError) Error() string

type PaymentPayload ¶

type PaymentPayload = types.PaymentPayload

Re-export V2 types as default in x402 package V2 types are defined in types/v2.go but re-exported here for convenience

type PaymentPayloadView ¶

type PaymentPayloadView interface {
	GetVersion() int
	GetScheme() string
	GetNetwork() string // Returns network as string (can be converted to Network type)
	GetPayload() map[string]interface{}
}

PaymentPayloadView is a unified interface for payment payloads Both V1 and V2 types implement this to work with hooks

type PaymentPolicy ¶

type PaymentPolicy func(requirements []PaymentRequirementsView) []PaymentRequirementsView

PaymentPolicy filters or transforms payment requirements Works with unified view interface

type PaymentRequired ¶

type PaymentRequired = types.PaymentRequired

Re-export V2 types as default in x402 package V2 types are defined in types/v2.go but re-exported here for convenience

type PaymentRequirements ¶

type PaymentRequirements = types.PaymentRequirements

Re-export V2 types as default in x402 package V2 types are defined in types/v2.go but re-exported here for convenience

type PaymentRequirementsSelector ¶

type PaymentRequirementsSelector func(requirements []PaymentRequirementsView) PaymentRequirementsView

PaymentRequirementsSelector chooses which payment option to use Works with unified view interface

type PaymentRequirementsView ¶

type PaymentRequirementsView interface {
	GetScheme() string
	GetNetwork() string // Returns network as string (can be converted to Network type)
	GetAsset() string
	GetAmount() string // V1: MaxAmountRequired, V2: Amount
	GetPayTo() string
	GetMaxTimeoutSeconds() int
	GetExtra() map[string]interface{}
}

PaymentRequirementsView is a unified interface for payment requirements Both V1 and V2 types implement this to work with selectors/policies/hooks

func DefaultPaymentSelector(requirements []PaymentRequirementsView) PaymentRequirementsView

type Price ¶

type Price interface{}

Price represents a price that can be specified in various formats

type ResourceConfig ¶

type ResourceConfig struct {
	Scheme            string                 `json:"scheme"`
	PayTo             string                 `json:"payTo"`
	Price             Price                  `json:"price"`
	Network           Network                `json:"network"`
	MaxTimeoutSeconds int                    `json:"maxTimeoutSeconds,omitempty"`
	Extra             map[string]interface{} `json:"extra,omitempty"`
}

ResourceConfig defines payment configuration for a protected resource

type ResourceInfo ¶

type ResourceInfo = types.ResourceInfo

Re-export V2 types as default in x402 package V2 types are defined in types/v2.go but re-exported here for convenience

type ResourceServerOption ¶

type ResourceServerOption func(*x402ResourceServer)

ResourceServerOption configures the server

func WithAfterSettleHook(hook AfterSettleHook) ResourceServerOption

func WithAfterVerifyHook(hook AfterVerifyHook) ResourceServerOption

func WithBeforeSettleHook(hook BeforeSettleHook) ResourceServerOption

func WithBeforeVerifyHook(hook BeforeVerifyHook) ResourceServerOption

func WithCacheTTL(ttl time.Duration) ResourceServerOption

func WithFacilitatorClient(client FacilitatorClient) ResourceServerOption

func WithOnSettleFailureHook(hook OnSettleFailureHook) ResourceServerOption

func WithOnVerifyFailureHook(hook OnVerifyFailureHook) ResourceServerOption

func WithSchemeServer(network Network, schemeServer SchemeNetworkServer) ResourceServerOption

type SchemeNetworkClient ¶

type SchemeNetworkClient interface {
	Scheme() string
	CreatePaymentPayload(ctx context.Context, requirements types.PaymentRequirements) (types.PaymentPayload, error)
}

SchemeNetworkClient is implemented by client-side payment mechanisms (V2)

type SchemeNetworkClientV1 ¶

type SchemeNetworkClientV1 interface {
	Scheme() string
	CreatePaymentPayload(ctx context.Context, requirements types.PaymentRequirementsV1) (types.PaymentPayloadV1, error)
}

SchemeNetworkClientV1 is implemented by client-side V1 payment mechanisms

type SchemeNetworkFacilitator ¶

type SchemeNetworkFacilitator interface {
	Scheme() string

	// CaipFamily returns the CAIP family pattern this facilitator supports.
	// Used to group signers by blockchain family in the supported response.
	//
	// Examples:
	//   - EVM facilitators return "eip155:*"
	//   - SVM facilitators return "solana:*"
	CaipFamily() string

	// GetExtra returns mechanism-specific extra data for the supported kinds endpoint.
	// This method is called when building the facilitator's supported response.
	//
	// For EVM schemes, return nil (no extra data needed).
	// For SVM schemes, return map with feePayer address.
	//
	// Args:
	//   network: Network identifier for context
	//
	// Returns:
	//   Extra data map or nil if no extra data is needed
	GetExtra(network Network) map[string]interface{}

	// GetSigners returns signer addresses used by this facilitator for a given network.
	// These are included in the supported response to help clients understand
	// which addresses might sign/pay for transactions.
	//
	// Supports multiple addresses for load balancing, key rotation, and high availability.
	//
	// Args:
	//   network: Network identifier
	//
	// Returns:
	//   Array of signer addresses
	//
	// Examples:
	//   - EVM: Returns facilitator wallet addresses
	//   - SVM: Returns fee payer addresses
	GetSigners(network Network) []string

	Verify(ctx context.Context, payload types.PaymentPayload, requirements types.PaymentRequirements, fctx *FacilitatorContext) (*VerifyResponse, error)
	Settle(ctx context.Context, payload types.PaymentPayload, requirements types.PaymentRequirements, fctx *FacilitatorContext) (*SettleResponse, error)
}

SchemeNetworkFacilitator is implemented by facilitator-side payment mechanisms (V2)

type SchemeNetworkFacilitatorV1 ¶

type SchemeNetworkFacilitatorV1 interface {
	Scheme() string

	// CaipFamily returns the CAIP family pattern this facilitator supports.
	// Used to group signers by blockchain family in the supported response.
	//
	// Examples:
	//   - EVM facilitators return "eip155:*"
	//   - SVM facilitators return "solana:*"
	CaipFamily() string

	// GetExtra returns mechanism-specific extra data for the supported kinds endpoint.
	// This method is called when building the facilitator's supported response.
	//
	// For EVM schemes, return nil (no extra data needed).
	// For SVM schemes, return map with feePayer address.
	//
	// Args:
	//   network: Network identifier for context
	//
	// Returns:
	//   Extra data map or nil if no extra data is needed
	GetExtra(network Network) map[string]interface{}

	// GetSigners returns signer addresses used by this facilitator for a given network.
	// These are included in the supported response to help clients understand
	// which addresses might sign/pay for transactions.
	//
	// Supports multiple addresses for load balancing, key rotation, and high availability.
	//
	// Args:
	//   network: Network identifier
	//
	// Returns:
	//   Array of signer addresses
	//
	// Examples:
	//   - EVM: Returns facilitator wallet addresses
	//   - SVM: Returns fee payer addresses
	GetSigners(network Network) []string

	Verify(ctx context.Context, payload types.PaymentPayloadV1, requirements types.PaymentRequirementsV1, fctx *FacilitatorContext) (*VerifyResponse, error)
	Settle(ctx context.Context, payload types.PaymentPayloadV1, requirements types.PaymentRequirementsV1, fctx *FacilitatorContext) (*SettleResponse, error)
}

SchemeNetworkFacilitatorV1 is implemented by facilitator-side V1 payment mechanisms

type SchemeNetworkServer ¶

type SchemeNetworkServer interface {
	Scheme() string
	ParsePrice(price Price, network Network) (AssetAmount, error)
	EnhancePaymentRequirements(
		ctx context.Context,
		requirements types.PaymentRequirements,
		supportedKind types.SupportedKind,
		extensions []string,
	) (types.PaymentRequirements, error)
}

SchemeNetworkServer is implemented by server-side payment mechanisms (V2)

type SettleContext ¶

type SettleContext struct {
	Ctx               context.Context
	Payload           PaymentPayloadView
	Requirements      PaymentRequirementsView
	PayloadBytes      []byte // Raw bytes for extensions needing full data
	RequirementsBytes []byte // Raw bytes for extensions needing full data
}

SettleContext contains information passed to settle hooks Uses view interfaces for version-agnostic hooks PayloadBytes and RequirementsBytes provide escape hatch for extensions (e.g., Bazaar)

type SettleError ¶

type SettleError struct {
	ErrorReason  string  // Error reason/code (e.g., "transaction_failed", "insufficient_balance")
	Payer        string  // Payer address (if known)
	Network      Network // Network identifier
	Transaction  string  // Transaction hash (if settlement was attempted)
	ErrorMessage string  // Optional error message details
}

SettleError represents a payment settlement failure All settlement failures (business logic and system errors) are returned as errors

func NewSettleError(reason string, payer string, network Network, transaction string, message string) *SettleError

reason: Error reason/code
payer: Payer address (empty string if unknown)
network: Network identifier
transaction: Transaction hash (empty string if not submitted)
err: Optional underlying error

*SettleError

func (e *SettleError) Error() string

type SettleFailureContext ¶

type SettleFailureContext struct {
	SettleContext
	Error error
}

SettleFailureContext contains settle operation failure and context

type SettleFailureHookResult ¶

type SettleFailureHookResult struct {
	Recovered bool
	Result    *SettleResponse
}

SettleFailureHookResult represents the result of a settle failure hook

type SettleResponse ¶

type SettleResponse struct {
	Success      bool                   `json:"success"`
	ErrorReason  string                 `json:"errorReason,omitempty"`
	ErrorMessage string                 `json:"errorMessage,omitempty"`
	Payer        string                 `json:"payer,omitempty"`
	Transaction  string                 `json:"transaction"`
	Network      Network                `json:"network"`
	Amount       string                 `json:"amount,omitempty"`
	Extensions   map[string]interface{} `json:"extensions,omitempty"`
}

SettleResponse contains the settlement result If settlement fails, an error (typically *SettleError) is returned and this will be nil

type SettleResultContext ¶

type SettleResultContext struct {
	SettleContext
	Result *SettleResponse
}

SettleResultContext contains settle operation result and context

type SettlementOverrides ¶

type SettlementOverrides struct {
	// Amount to settle. Supports three formats:
	//   - Raw atomic units: "1000" settles exactly 1000 atomic units.
	//   - Percent: "50%" settles 50% of PaymentRequirements.Amount (up to 2 decimal places, floored).
	//   - Dollar price: "$0.05" converts to atomic units using Extra["decimals"] (default 6).
	// The resolved amount must be <= the authorized maximum in PaymentRequirements.
	Amount string `json:"amount,omitempty"`
}

SettlementOverrides allows overriding settlement parameters. Used to support partial settlement (e.g., upto scheme billing by actual usage).

type SupportedCache ¶

type SupportedCache struct {
	// contains filtered or unexported fields
}

SupportedCache caches facilitator capabilities

func (c *SupportedCache) Get(key string) (SupportedResponse, bool)

func (c *SupportedCache) Set(key string, response SupportedResponse)

type SupportedKind ¶

type SupportedKind = types.SupportedKind

Re-export V2 types as default in x402 package V2 types are defined in types/v2.go but re-exported here for convenience

type SupportedResponse ¶

type SupportedResponse = types.SupportedResponse

Re-export V2 types as default in x402 package V2 types are defined in types/v2.go but re-exported here for convenience

type SupportedResponseV1 ¶

type SupportedResponseV1 = types.SupportedResponseV1

Re-export V1 types for legacy facilitator support

type VerifyContext ¶

type VerifyContext struct {
	Ctx               context.Context
	Payload           PaymentPayloadView
	Requirements      PaymentRequirementsView
	PayloadBytes      []byte // Raw bytes for extensions needing full data
	RequirementsBytes []byte // Raw bytes for extensions needing full data
}

VerifyContext contains information passed to verify hooks Uses view interfaces for version-agnostic hooks PayloadBytes and RequirementsBytes provide escape hatch for extensions (e.g., Bazaar)

type VerifyError ¶

type VerifyError struct {
	InvalidReason  string // Error reason/code (e.g., "insufficient_balance", "invalid_signature")
	Payer          string // Payer address (if known)
	InvalidMessage string // Optional invalid message details
}

VerifyError represents a payment verification failure All verification failures (business logic and system errors) are returned as errors

func NewVerifyError(reason string, payer string, message string) *VerifyError

reason: Error reason/code
payer: Payer address (empty string if unknown)
network: Network identifier (empty string if unknown)
message: Optional invalid message details

*VerifyError

func (e *VerifyError) Error() string

type VerifyFailureContext ¶

type VerifyFailureContext struct {
	VerifyContext
	Error error
}

VerifyFailureContext contains verify operation failure and context

type VerifyFailureHookResult ¶

type VerifyFailureHookResult struct {
	Recovered bool
	Result    *VerifyResponse
}

VerifyFailureHookResult represents the result of a verify failure hook If Recovered is true, the hook has recovered from the failure with the given result

type VerifyResponse ¶

type VerifyResponse struct {
	IsValid        bool                   `json:"isValid"`
	InvalidReason  string                 `json:"invalidReason,omitempty"`
	InvalidMessage string                 `json:"invalidMessage,omitempty"`
	Payer          string                 `json:"payer,omitempty"`
	Extensions     map[string]interface{} `json:"extensions,omitempty"`
}

VerifyResponse contains the verification result If verification fails, an error (typically *VerifyError) is returned and this will be nil

type VerifyResultContext ¶

type VerifyResultContext struct {
	VerifyContext
	Result *VerifyResponse
}

VerifyResultContext contains verify operation result and context

type X402Client ¶

type X402Client = x402Client

X402Client is the exported type for x402Client

type X402Facilitator ¶

type X402Facilitator = x402Facilitator

X402Facilitator is the exported type for x402Facilitator

type X402ResourceServer ¶

type X402ResourceServer = x402ResourceServer

X402ResourceServer is the exported type for x402ResourceServer