server

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

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

type AtxpMcpChallengeData struct {
	PaymentRequestID  string `json:"paymentRequestId"`
	PaymentRequestURL string `json:"paymentRequestUrl"`
	ChargeAmount      string `json:"chargeAmount,omitempty"`
}

type BalanceRequest struct {
	SourceAccountID      string `json:"sourceAccountId"`
	DestinationAccountID string `json:"destinationAccountId"`
	SourceAccountToken   string `json:"sourceAccountToken,omitempty"`
}

type Challenge struct {
	Code    int
	Message string
	Data    map[string]any

	// Structured views of the same data, for callers that want typed access
	// (e.g. to emit an HTTP 402 instead of an MCP error).
	AtxpMcp AtxpMcpChallengeData
	X402    X402PaymentRequirements
	MPP     []MppChallengeData
}

type ChargeRequest struct {
	Options              []chargeOptionWire `json:"options"`
	SourceAccountID      string             `json:"sourceAccountId"`
	DestinationAccountID string             `json:"destinationAccountId"`
	PayeeName            string             `json:"payeeName"`
	// SourceAccountToken is the caller's OAuth/connection token for on-demand
	// (pull-mode) charging. Wallet-grade; never logged.
	SourceAccountToken string `json:"sourceAccountToken,omitempty"`
	// PaymentRequestID ties /settle and the follow-up /charge to one payment.
	PaymentRequestID string `json:"paymentRequestId,omitempty"`
}

type Config struct {
	// Destination is where payments are received. Required.
	Destination Destination

	// ConnectionToken is the merchant's own ATXP connection token. It is sent
	// (over HTTPS only) as the X-ATXP-TOKEN header during dynamic client
	// registration so the registered client is bound to the merchant's ATXP
	// account. Wallet-grade secret — never logged or echoed. Optional only if
	// the authorization server permits unauthenticated registration.
	ConnectionToken string

	// AuthServer is the ATXP authorization server base URL. Defaults to
	// https://auth.atxp.ai.
	AuthServer string

	// PayeeName labels the merchant in challenges and metadata, and doubles as
	// the dynamic-client-registration client_name sent to the authorization
	// server. Defaults to "An ATXP Server"; set this to something distinctive
	// in production. The auth server treats client_name as claimed once
	// registered; with the default Store (in-memory, lost on restart) a second
	// process registering under the same unset-default name, whether a
	// restart of this merchant or an unrelated one reusing the same
	// ConnectionToken, gets a permanent 409 for that name, with no way to
	// recover the original client_secret. See Store's doc comment.
	PayeeName string

	// Currency is the settlement currency. Defaults to "USDC".
	Currency string

	// MinimumPayment is a price floor applied to every charge. Must be <= $1.00.
	// The zero Amount means no floor.
	MinimumPayment Amount

	// AppName is an observability label (1–64 chars of [a-zA-Z0-9._-]) sent on
	// settle/verify calls. Untrusted by auth; do not use for billing.
	AppName string

	// ExpectedAudience, when set, is required to appear in an introspected
	// token's `aud`. Leaving it empty disables the audience check (the TS
	// default), but setting it to this resource's URL is strongly recommended.
	ExpectedAudience string

	// Store persists DCR client credentials (keyed by AS issuer). Defaults to a
	// process-local in-memory store, which loses its client_secret on every
	// restart. The authorization server does not let a new registration
	// reclaim an already-claimed client_name, so a restarted (or
	// ConnectionToken-sharing) merchant that doesn't set a distinctive
	// PayeeName will permanently fail dynamic client registration with a 409.
	// Production deployments should supply a persistent Store implementation.
	Store atxp.Store

	// HTTPClient is used for all authorization-server calls. Optional.
	HTTPClient *http.Client

	// Logger receives operational messages. Never receives secrets. Defaults to
	// a no-op logger.
	Logger Logger

	// OpaqueKey is the HMAC key for opaque-identity signing. When nil, the key
	// is loaded from ATXP_OPAQUE_KEY (base64) or randomly generated per process.
	OpaqueKey []byte

	// AllowHTTP permits plaintext HTTP to the authorization server. For local
	// development and tests ONLY — it disables the HTTPS requirement that keeps
	// the connection token from traversing the network in the clear.
	AllowHTTP bool
}

type CredentialDetection struct {
	Protocol         Protocol
	Credential       string
	PaymentRequestID string
}

type Destination interface {
	AccountID(ctx context.Context) (string, error)
	Sources(ctx context.Context, include []string) ([]Source, error)
}

type InvalidAccountIDError struct{ AccountID string }

type Logger interface {
	Debugf(format string, args ...any)
	Infof(format string, args ...any)
	Warnf(format string, args ...any)
	Errorf(format string, args ...any)
}

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

type MppChallengeData struct {
	ID        string         `json:"id"`
	Method    string         `json:"method"`
	Intent    string         `json:"intent"`
	Amount    string         `json:"amount"`
	Currency  string         `json:"currency"`
	Network   string         `json:"network"`
	Recipient string         `json:"recipient"`
	Expires   string         `json:"expires,omitempty"`
	Resource  *resourceRef   `json:"resource,omitempty"`
	Request   map[string]any `json:"request,omitempty"`
	Opaque    map[string]any `json:"opaque,omitempty"`
}

type MppSessionSupport struct {
	EscrowContract   string `json:"escrowContract"`
	AuthorizedSigner string `json:"authorizedSigner"`
	Operator         string `json:"operator"`
	ChainID          int    `json:"chainId"`
}

type OAuthChallengeResponse struct {
	Status  int
	Headers map[string]string
	Body    string
}

type PaymentRequest struct {
	// Price is what to charge for this call. The amount actually charged is
	// max(Price, the merchant's MinimumPayment).
	Price Amount

	// User is the caller's account id — the `sub` from a passing CheckToken.
	// Required; without an authenticated caller there is nobody to charge.
	User string

	// SourceAccountToken is the caller's connection/OAuth token for on-demand
	// (pull-mode) charging. Wallet-grade secret. Optional: without it, the
	// caller is sent a challenge to pay out-of-band.
	SourceAccountToken string

	// PaymentRequestID ties this charge to an existing payment lifecycle
	// (idempotency). Optional.
	PaymentRequestID string

	// Session, when set, charges locally against the request-scoped payment
	// session (opened from a detected retry credential via
	// Merchant.OpenPaymentSession) instead of issuing a network /charge call.
	// Multiple RequirePayment calls sharing a Session settle once, for the
	// sum actually charged, when the caller closes it via
	// Merchant.CloseSession. Optional — nil preserves the on-demand /charge
	// behavior.
	Session *PaymentSession

	// Resource is the resource URL recorded in the challenge for activity labels.
	// Optional.
	Resource string

	// ExistingPaymentID, when set, is consulted before creating a new payment
	// request so a re-challenge reuses an in-flight payment. Optional.
	ExistingPaymentID func(ctx context.Context) (string, error)
}

type PaymentServer interface {
	// Charge attempts an on-demand pull. Returns true when the charge settled
	// (HTTP 200 or 202), false when payment is still required (HTTP 402), and a
	// non-nil error for every other outcome — including network failures — so a
	// caller that treats (false, nil) as "unpaid" never mistakes an
	// infrastructure error for a definite "unpaid".
	Charge(ctx context.Context, req ChargeRequest) (bool, error)
	// CreatePaymentRequest registers a payment request and returns its id.
	CreatePaymentRequest(ctx context.Context, req ChargeRequest) (string, error)
	// GetBalance returns the caller's available USDC balance.
	GetBalance(ctx context.Context, req BalanceRequest) (Amount, error)
}

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

type ProtectedResourceMetadata struct {
	Resource               string   `json:"resource"`
	ResourceName           string   `json:"resource_name"`
	AuthorizationServers   []string `json:"authorization_servers"`
	BearerMethodsSupported []string `json:"bearer_methods_supported"`
	ScopesSupported        []string `json:"scopes_supported"`
}

type Protocol string

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

type SettleResult struct {
	TxHash         *string `json:"txHash"`
	SettledAmount  string  `json:"settledAmount"`
	AlreadySettled bool    `json:"alreadySettled,omitempty"`
}

type SettlementContext struct {
	PaymentRequirements  *X402PaymentRequirements
	PaymentRequestID     string
	SourceAccountID      string
	DestinationAccountID string
	Options              any
}

type SolanaMppSessionSupport struct {
	AuthorizedSigner string `json:"authorizedSigner"`
}

type Source struct {
	Chain   string `json:"chain"`
	Address string `json:"address"`
}

type StaticDestination struct {
	ID        string   // "network:address"
	Addresses []Source // per-chain receive addresses (may be empty)
}

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

type TokenCheck struct {
	Passes              bool
	Problem             TokenProblem
	Token               string
	Data                *TokenData
	ResourceMetadataURL string
}

type TokenData struct {
	Active bool          `json:"active"`
	Scope  string        `json:"scope,omitempty"`
	Sub    string        `json:"sub,omitempty"`
	Aud    stringOrSlice `json:"aud,omitempty"`
	Exp    int64         `json:"exp,omitempty"`
}

type TokenProblem string

type UnderpaymentError struct {
	Spent   Amount
	Settled Amount
	// ParseError is set instead of a meaningful Settled when the settle
	// response's amount could not be parsed at all. Treated as a failure
	// too, since an amount that can't be verified isn't a verified amount.
	ParseError error
}

type VerifyResult struct {
	Valid bool `json:"valid"`
}

type X402PaymentOption struct {
	Scheme            string         `json:"scheme"`
	Network           string         `json:"network"`
	Amount            string         `json:"amount"`
	Resource          string         `json:"resource"`
	Description       string         `json:"description"`
	MimeType          string         `json:"mimeType,omitempty"`
	PayTo             string         `json:"payTo"`
	MaxTimeoutSeconds int            `json:"maxTimeoutSeconds,omitempty"`
	Asset             string         `json:"asset,omitempty"`
	Extra             map[string]any `json:"extra,omitempty"`
}

type X402PaymentRequirements struct {
	X402Version int                 `json:"x402Version"`
	Accepts     []X402PaymentOption `json:"accepts"`
}