rpc

type ActionAllowanceV1 struct {
	// GatedAction is the specific action being gated (e.g. transfer, app_operation)
	GatedAction core.GatedAction `json:"gated_action"`
	// TimeWindow is the time window for which the allowance is valid (e.g. "1h", "24h")
	TimeWindow string `json:"time_window"`
	// Allowance is the total allowance for the gated action within the time window
	Allowance string `json:"allowance"`
	// Used is the amount of the allowance that has already been used within the time window
	Used string `json:"used"`
}

type AppAllocationV1 struct {
	// Participant is the participant's wallet address
	Participant string `json:"participant"`
	// Asset is the asset symbol
	Asset string `json:"asset"`
	// Amount is the amount allocated to the participant
	Amount string `json:"amount"`
}

type AppDefinitionV1 struct {
	// Application is the application identifier from an app registry
	Application string `json:"application_id"`
	// Participants is the list of participants in the app session
	Participants []AppParticipantV1 `json:"participants"`
	// Quorum is the quorum required for the app session
	Quorum uint8 `json:"quorum"`
	// Nonce is a unique number to prevent replay attacks
	Nonce string `json:"nonce"`
}

type AppInfoV1 struct {
	AppV1
	// CreatedAt is the creation timestamp (unix seconds)
	CreatedAt string `json:"created_at"`
	// UpdatedAt is the last update timestamp (unix seconds)
	UpdatedAt string `json:"updated_at"`
}

type AppParticipantV1 struct {
	// WalletAddress is the participant's wallet address
	WalletAddress string `json:"wallet_address"`
	// SignatureWeight is the signature weight for the participant
	SignatureWeight uint8 `json:"signature_weight"`
}

type AppSessionInfoV1 struct {
	// AppSessionID is the unique application session identifier
	AppSessionID string `json:"app_session_id"`
	// Status is the session status (open/closed)
	Status string `json:"status"`
	// AppDefinitionV1 contains immutable application fields
	AppDefinitionV1 AppDefinitionV1 `json:"app_definition"`
	// SessionData is the JSON stringified session data
	SessionData *string `json:"session_data,omitempty"`
	// Version is the current version of the session state
	Version string `json:"version"`
	// Nonce is the nonce for the session
	Allocations []AppAllocationV1 `json:"allocations"`
}

type AppSessionKeyStateV1 struct {
	// ID Hash(user_address + session_key + version)
	// UserAddress is the user wallet address
	UserAddress string `json:"user_address"`
	// SessionKey is the session key address for delegation
	SessionKey string `json:"session_key"`
	// Version is the version of the session key format
	Version string `json:"version"`
	// ApplicationID is the application IDs associated with this session key
	ApplicationIDs []string `json:"application_ids"`
	// AppSessionID is the application session IDs associated with this session key
	AppSessionIDs []string `json:"app_session_ids"`
	// ExpiresAt is Unix timestamp in seconds indicating when the session key expires
	ExpiresAt string `json:"expires_at"`
	// UserSig is the user's signature over the session key metadata to authorize the registration/update of the session key
	UserSig string `json:"user_sig"`
}

type AppSessionsV1CreateAppSessionRequest struct {
	// Definition is the application definition including participants and quorum
	Definition AppDefinitionV1 `json:"definition"`
	// SessionData is the optional JSON stringified session data
	SessionData string `json:"session_data"`
	// QuorumSigs is the list of participant signatures for the app session creation
	QuorumSigs []string `json:"quorum_sigs,omitempty"`
	// OwnerSig is the optional owner signature for app session creation if approval required by the app registry
	OwnerSig string `json:"owner_sig,omitempty"`
}

type AppSessionsV1CreateAppSessionResponse struct {
	// AppSessionID is the created application session ID
	AppSessionID string `json:"app_session_id"`
	// Version is the initial version of the session
	Version string `json:"version"`
	// Status is the status of the session (closed)
	Status string `json:"status"`
}

type AppSessionsV1GetAppDefinitionRequest struct {
	// AppSessionID is the application session ID
	AppSessionID string `json:"app_session_id"`
}

type AppSessionsV1GetAppDefinitionResponse struct {
	// Definition is the application definition
	Definition AppDefinitionV1 `json:"definition"`
}

type AppSessionsV1GetAppSessionsRequest struct {
	// AppSessionID filters by application session ID
	AppSessionID *string `json:"app_session_id,omitempty"`
	// Participant filters by participant wallet address
	Participant *string `json:"participant,omitempty"`
	// Status filters by status (open/closed)
	Status *string `json:"status,omitempty"`
	// Pagination contains pagination parameters (offset, limit, sort)
	Pagination *PaginationParamsV1 `json:"pagination,omitempty"`
}

type AppSessionsV1GetAppSessionsResponse struct {
	// AppSessions is the list of application sessions
	AppSessions []AppSessionInfoV1 `json:"app_sessions"`
	// Metadata contains pagination information
	Metadata PaginationMetadataV1 `json:"metadata"`
}

type AppSessionsV1GetLastKeyStatesRequest struct {
	// UserAddress is the user's wallet address
	UserAddress string  `json:"user_address"`
	SessionKey  *string `json:"session_key,omitempty"` // Optionally filter by SessionKey
}

type AppSessionsV1GetLastKeyStatesResponse struct {
	// States is the list of active session key states for the user
	States []AppSessionKeyStateV1 `json:"states"`
}

type AppSessionsV1RebalanceAppSessionsRequest struct {
	// SignedUpdates is the list of signed application session state updates
	SignedUpdates []SignedAppStateUpdateV1 `json:"signed_updates"`
}

type AppSessionsV1RebalanceAppSessionsResponse struct {
	// BatchID is the unique identifier for this rebalancing operation
	BatchID string `json:"batch_id"`
}

type AppSessionsV1SubmitAppStateRequest struct {
	// AppStateUpdate is the application session state update to be submitted
	AppStateUpdate AppStateUpdateV1 `json:"app_state_update"`
	// QuorumSigs is the signature quorum for the application session
	QuorumSigs []string `json:"quorum_sigs"`
}

type AppSessionsV1SubmitAppStateResponse struct{}

type AppSessionsV1SubmitDepositStateRequest struct {
	// AppStateUpdate is the application session state update to be submitted
	AppStateUpdate AppStateUpdateV1 `json:"app_state_update"`
	// QuorumSigs is the list of participant signatures for the app state update
	QuorumSigs []string `json:"quorum_sigs"`
	// SigQuorum is the signature quorum for the application session
	UserState StateV1 `json:"user_state"`
}

type AppSessionsV1SubmitDepositStateResponse struct {
	// StateNodeSig is the Node's signature for the deposit state
	StateNodeSig string `json:"signature"`
}

type AppSessionsV1SubmitSessionKeyStateRequest struct {
	// State contains the session key metadata and delegation information
	State AppSessionKeyStateV1 `json:"state"`
}

type AppSessionsV1SubmitSessionKeyStateResponse struct {
}

type AppStateUpdateV1 struct {
	// AppSessionID is the unique application session identifier
	AppSessionID string `json:"app_session_id"`
	// Intent is the intent of the app session update (operate, deposit, withdraw, close)
	Intent app.AppStateUpdateIntent `json:"intent"`
	// Version is the version of the app state
	Version string `json:"version"`
	// Allocations is the list of allocations in the app state
	Allocations []AppAllocationV1 `json:"allocations"`
	// SessionData is the JSON stringified session data
	SessionData string `json:"session_data"`
}

type AppV1 struct {
	// ID is the application identifier
	ID string `json:"id"`
	// OwnerWallet is the owner's wallet address
	OwnerWallet string `json:"owner_wallet"`
	// Metadata is the application metadata
	Metadata string `json:"metadata"`
	// Version is the current version
	Version string `json:"version"`
	// CreationApprovalNotRequired indicates if sessions can be created without approval
	CreationApprovalNotRequired bool `json:"creation_approval_not_required"`
}

type AppsV1GetAppsRequest struct {
	// AppID filters by application ID
	AppID *string `json:"app_id,omitempty"`
	// OwnerWallet filters by owner wallet address
	OwnerWallet *string `json:"owner_wallet,omitempty"`
	// Pagination contains pagination parameters (offset, limit, sort)
	Pagination *PaginationParamsV1 `json:"pagination,omitempty"`
}

type AppsV1GetAppsResponse struct {
	// Apps is the list of registered applications
	Apps []AppInfoV1 `json:"apps"`
	// Metadata contains pagination information
	Metadata PaginationMetadataV1 `json:"metadata"`
}

type AppsV1SubmitAppVersionRequest struct {
	// App contains the application definition
	App AppV1 `json:"app"`
	// OwnerSig is the owner's signature over the packed app data
	OwnerSig string `json:"owner_sig"`
}

type AppsV1SubmitAppVersionResponse struct {
}

type AssetV1 struct {
	// Name is the asset name
	Name string `json:"name"`
	// Symbol is the asset symbol
	Symbol string `json:"symbol"`
	// Decimals is the number of decimal places for the asset
	Decimals uint8 `json:"decimals"`
	// SuggestedBlockchainID is the suggested blockchain network ID for this asset
	SuggestedBlockchainID string `json:"suggested_blockchain_id"`
	// Tokens is the list of supported tokens for the asset
	Tokens []TokenV1 `json:"tokens"`
}

type BalanceEntryV1 struct {
	// Asset is the asset symbol
	Asset string `json:"asset"`
	// Amount is the balance amount
	Amount string `json:"amount"`
}

type BlockchainInfoV1 struct {
	// Name is the blockchain name
	Name string `json:"name"`
	// BlockchainID is the blockchain network ID
	BlockchainID string `json:"blockchain_id"`
	// ChannelHubAddress is the contract address on this network
	ChannelHubAddress string `json:"channel_hub_address"`
	// LockingContractAddress is the contract address for the locking contract on this network
	LockingContractAddress string `json:"locking_contract_address"`
}

type ChannelDefinitionV1 struct {
	// Nonce is a unique number to prevent replay attacks
	Nonce string `json:"nonce"`
	// Challenge is the challenge period for the channel in seconds
	Challenge uint32 `json:"challenge"`
	// ApprovedSigValidators is a hex string bitmap representing the approved signature validators for the channel
	ApprovedSigValidators string `json:"approved_sig_validators"`
}

type ChannelSessionKeyStateV1 struct {
	// ID Hash(user_address + session_key + version)
	// UserAddress is the user wallet address
	UserAddress string `json:"user_address"`
	// SessionKey is the session key address for delegation
	SessionKey string `json:"session_key"`
	// Version is the version of the session key format
	Version string `json:"version"`
	// Assets associated with this session key
	Assets []string `json:"assets"`
	// Expiration time as unix timestamp of this session key
	ExpiresAt string `json:"expires_at"`
	// UserSig is the user's signature over the session key metadata to authorize the registration/update of the session key
	UserSig string `json:"user_sig"`
}

type ChannelV1 struct {
	// ChannelID is the unique identifier for the channel
	ChannelID string `json:"channel_id"`
	// UserWallet is the user wallet address
	UserWallet string `json:"user_wallet"`
	// Asset is the asset symbol (e.g. USDC, ETH)
	Asset string `json:"asset"`
	// Type is the type of the channel (home, escrow)
	Type string `json:"type"`
	// BlockchainID is the unique identifier for the blockchain
	BlockchainID string `json:"blockchain_id"`
	// TokenAddress is the address of the token used in the channel
	TokenAddress string `json:"token_address"`
	// ChallengeDuration is the challenge period for the channel in seconds
	ChallengeDuration uint32 `json:"challenge_duration"`
	// ChallegeExpiresAt
	ChallengeExpiresAt *time.Time `json:"challenge_expires_at"`
	// Nonce is the nonce for the channel
	Nonce string `json:"nonce"`
	// ApprovedSigValidators is a hex string bitmap of approved signature validators
	ApprovedSigValidators string `json:"approved_sig_validators"`
	// Status is the current status of the channel (void, open, challenged, closed)
	Status string `json:"status"`
	// StateVersion is the on-chain state version of the channel
	StateVersion string `json:"state_version"`
}

type ChannelsV1GetChannelsRequest struct {
	// Wallet filters by user's wallet address
	Wallet string `json:"wallet"`
	// Status filters by status
	Status *string `json:"status,omitempty"`
	// Asset filters by asset
	Asset *string `json:"asset,omitempty"`
	// ChannelType filters by channel type ("home" or "escrow")
	ChannelType *string `json:"channel_type,omitempty"`
	// Pagination contains pagination parameters (offset, limit, sort)
	Pagination *PaginationParamsV1 `json:"pagination,omitempty"`
}

type ChannelsV1GetChannelsResponse struct {
	// Channels is the list of channels
	Channels []ChannelV1 `json:"channels"`
	// Metadata contains pagination information
	Metadata PaginationMetadataV1 `json:"metadata"`
}

type ChannelsV1GetEscrowChannelRequest struct {
	// EscrowChannelID is the escrow channel ID
	EscrowChannelID string `json:"escrow_channel_id"`
}

type ChannelsV1GetEscrowChannelResponse struct {
	// Channel is the on-chain channel information
	Channel ChannelV1 `json:"channel"`
}

type ChannelsV1GetHomeChannelRequest struct {
	// UserWallet is the user's wallet address
	Wallet string `json:"wallet"`
	// Asset is the asset symbol
	Asset string `json:"asset"`
}

type ChannelsV1GetHomeChannelResponse struct {
	// Channel is the on-chain channel information
	Channel ChannelV1 `json:"channel"`
}

type ChannelsV1GetLastKeyStatesRequest struct {
	// UserAddress is the user's wallet address
	UserAddress string  `json:"user_address"`
	SessionKey  *string `json:"session_key,omitempty"` // Optionally filter by SessionKey
}

type ChannelsV1GetLastKeyStatesResponse struct {
	// States is the list of active session key states for the user
	States []ChannelSessionKeyStateV1 `json:"states"`
}

type ChannelsV1GetLatestStateRequest struct {
	// UserWallet is the user's wallet address
	Wallet string `json:"wallet"`
	// Asset is the asset symbol
	Asset string `json:"asset"`
	// OnlySigned can be enabled to get the latest signed state to know what is the current pending transition
	OnlySigned bool `json:"only_signed"`
}

type ChannelsV1GetLatestStateResponse struct {
	// State is the current state of the user
	State StateV1 `json:"state"`
}

type ChannelsV1GetStatesRequest struct {
	// Wallet is the user's wallet address
	Wallet string `json:"wallet"`
	// Asset filters by asset symbol
	Asset string `json:"asset"`
	// Epoch filters by user epoch index
	Epoch *string `json:"epoch,omitempty"`
	// ChannelID filters by Home/Escrow Channel ID
	ChannelID *string `json:"channel_id,omitempty"`
	// OnlySigned returns only signed states
	OnlySigned bool `json:"only_signed"`
	// Pagination contains pagination parameters (offset, limit, sort)
	Pagination *PaginationParamsV1 `json:"pagination,omitempty"`
}

type ChannelsV1GetStatesResponse struct {
	// States is the list of states
	States []StateV1 `json:"states"`
	// Metadata contains pagination information
	Metadata PaginationMetadataV1 `json:"metadata"`
}

type ChannelsV1HomeChannelCreatedEvent struct {
	// Channel is the created home channel information
	Channel ChannelV1 `json:"channel"`
	// InitialState is the initial state of the home channel
	InitialState StateV1 `json:"initial_state"`
}

type ChannelsV1RequestCreationRequest struct {
	// State is the state to be submitted
	State StateV1 `json:"state"`
	// ChannelDefinition is the definition of the channel to be created
	ChannelDefinition ChannelDefinitionV1 `json:"channel_definition"`
}

type ChannelsV1RequestCreationResponse struct {
	// Signature is the Node's signature for the state
	Signature string `json:"signature"`
}

type ChannelsV1SubmitSessionKeyStateRequest struct {
	// State contains the session key metadata and delegation information
	State ChannelSessionKeyStateV1 `json:"state"`
}

type ChannelsV1SubmitSessionKeyStateResponse struct {
}

type ChannelsV1SubmitStateRequest struct {
	// State is the state to be submitted
	State StateV1 `json:"state"`
}

type ChannelsV1SubmitStateResponse struct {
	// Signature is the Node's signature for the state
	Signature string `json:"signature"`
}

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

type Connection interface {
	// ConnectionID returns the unique identifier for this connection.
	// This ID is generated when the connection is established and remains
	// constant throughout the connection's lifetime.
	ConnectionID() string

	// Origin returns the origin of the connection, such as the client's IP address or other identifying information.
	Origin() string

	// RawRequests returns a read-only channel for receiving incoming raw request messages.
	// Messages received on this channel are raw bytes that need to be unmarshaled
	// into Request objects for processing. The channel is closed when the
	// connection is terminated.
	RawRequests() <-chan []byte

	// WriteRawResponse attempts to send a raw response message to the client.
	// The method returns true if the message was successfully queued for sending,
	// or false if the operation timed out (indicating a potentially unresponsive client).
	// Messages that fail to send may trigger connection closure.
	WriteRawResponse(message []byte) bool

	// Serve starts the connection's lifecycle by spawning goroutines for reading and writing.
	// This method returns immediately after starting the goroutines. The handleClosure
	// callback will be invoked asynchronously when the connection terminates (with an
	// error if abnormal termination occurred). The parentCtx parameter enables
	// graceful shutdown of the connection.
	Serve(parentCtx context.Context, handleClosure func(error))
}

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

type Context struct {
	// Context is the standard Go context for the request
	Context context.Context
	// Request is the original RPC request message
	Request Message
	// Response is the response message to be sent back to the client
	Response Message
	// Storage provides per-connection storage for session data
	Storage *SafeStorage
	// contains filtered or unexported fields
}

type Dialer interface {
	// Dial establishes a connection to the specified URL.
	// This method is designed to be called in a goroutine as it blocks until the connection is closed.
	// The handleClosure callback is invoked when the connection is closed, with an error if any.
	Dial(ctx context.Context, url string, handleClosure func(err error)) error

	// IsConnected returns true if the dialer has an active connection.
	IsConnected() bool

	// Call sends an RPC request and waits for a response.
	// It returns an error if the request cannot be sent or no response is received.
	// The context can be used to cancel the request.
	Call(ctx context.Context, req *Message) (*Message, error)

	// EventCh returns a read-only channel for receiving unsolicited events from the server.
	// Events are responses that don't match any pending request ID.
	EventCh() <-chan *Message
}

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

type Event string

type GorillaWsConnectionAdapter interface {
	// ReadMessage reads a message from the WebSocket connection.
	ReadMessage() (messageType int, p []byte, err error)
	// NextWriter returns a writer for the next message to be sent on the WebSocket connection.
	NextWriter(messageType int) (io.WriteCloser, error)
	// Close closes the WebSocket connection.
	Close() error
	// WriteControl writes a control message (ping, pong, close) to the connection.
	WriteControl(messageType int, data []byte, deadline time.Time) error
	// SetPongHandler sets the handler for pong messages received from the peer.
	SetPongHandler(h func(appData string) error)
	// SetReadDeadline sets the deadline for future Read calls.
	// A zero value means reads will not time out.
	SetReadDeadline(t time.Time) error
}

type Group string

type Handler func(c *Context)

type HandlerGroup interface {
	Handle(method string, handler Handler)
	Use(middleware Handler)
	NewGroup(name string) HandlerGroup
}

type LedgerV1 struct {
	// TokenAddress is the address of the token used in this channel
	TokenAddress string `json:"token_address"`
	// BlockchainID is the unique identifier for the blockchain
	BlockchainID string `json:"blockchain_id"`
	// UserBalance is the user balance in the channel
	UserBalance string `json:"user_balance"`
	// UserNetFlow is the user net flow in the channel
	UserNetFlow string `json:"user_net_flow"`
	// NodeBalance is the node balance in the channel
	NodeBalance string `json:"node_balance"`
	// NodeNetFlow is the node net flow in the channel
	NodeNetFlow string `json:"node_net_flow"`
}

type Message struct {
	Type MsgType `json:"type"`

	// RequestID is a unique identifier for tracking requests and matching responses.
	// Clients should generate unique IDs to prevent collisions and enable proper
	// request-response correlation.
	RequestID uint64 `json:"request_id"`

	// Method specifies the RPC method to be invoked (e.g., "wallet_transfer").
	// Method names should follow a consistent naming convention, typically
	// using lowercase with underscores (e.g., "module_action").
	Method string `json:"method"`

	// Payload contains the method-specific parameters as a flexible map.
	// This allows different methods to have different parameter structures
	// while maintaining type safety through the Translate method.
	Payload Payload `json:"payload"`

	// Timestamp is the Unix timestamp in milliseconds when the payload was created.
	// This is used for replay protection and request expiration checks.
	// Servers should validate that timestamps are within an acceptable time window.
	Timestamp uint64 `json:"ts"`
}

type Method string

type MsgType uint8

type Node interface {
	// ServeHTTP handles incoming HTTP requests and upgrades them to
	// the appropriate transport protocol (e.g., WebSocket). It manages
	// connection lifecycle, including reading requests, routing to
	// handlers, and sending responses.
	ServeHTTP(w http.ResponseWriter, r *http.Request)

	// Handle registers a handler function for a specific RPC method.
	// When a request with the matching method name is received,
	// the handler will be invoked with the request context.
	Handle(method string, handler Handler)

	// Notify sends a server-initiated notification to a specific user.
	// All active connections for the user will receive the notification.
	// If the user has no active connections, the notification is dropped.
	Notify(userID string, method string, params Payload)

	// Use adds global middleware that will be executed for all requests.
	// Middleware is executed in the order it was added, before any
	// method-specific handlers.
	Use(middleware Handler)

	// NewGroup creates a new handler group for organizing related endpoints.
	// Groups can have their own middleware and can be nested to create
	// hierarchical handler structures.
	NewGroup(name string) HandlerGroup
}

type NodeV1GetAssetsRequest struct {
	// BlockchainID filters by blockchain network ID
	BlockchainID *string `json:"blockchain_id,omitempty"`
}

type NodeV1GetAssetsResponse struct {
	// Assets is the list of supported assets
	Assets []AssetV1 `json:"assets"`
}

type NodeV1GetConfigRequest struct{}

type NodeV1GetConfigResponse struct {
	// NodeAddress is the node wallet address
	NodeAddress string `json:"node_address"`
	// NodeVersion is the node software version
	NodeVersion string `json:"node_version"`
	// SupportedSigValidators is the list of supported signature validators identifiers for state sig verification
	SupportedSigValidators []core.ChannelSignerType `json:"supported_sig_validators"`
	// Blockchains is the list of supported networks
	Blockchains []BlockchainInfoV1 `json:"blockchains"`
}

type NodeV1PingRequest struct{}

type NodeV1PingResponse struct{}

type ObserveConnectionsFn func(region, origin string, count uint32)

type PaginationMetadataV1 struct {
	// Page is the current page number
	Page uint32 `json:"page"`
	// PerPage is the number of items per page
	PerPage uint32 `json:"per_page"`
	// TotalCount is the total number of items
	TotalCount uint32 `json:"total_count"`
	// PageCount is the total number of pages
	PageCount uint32 `json:"page_count"`
}

type PaginationParamsV1 struct {
	// Offset is the pagination offset (number of items to skip)
	Offset *uint32 `json:"offset,omitempty"`
	// Limit is the number of items to return
	Limit *uint32 `json:"limit,omitempty"`
	// Sort is the sort order (asc/desc)
	Sort *string `json:"sort,omitempty"`
}

type Payload map[string]json.RawMessage

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

type SendResponseFunc func(method string, params Payload)

type SignedAppStateUpdateV1 struct {
	// AppStateUpdate is the application session state update
	AppStateUpdate AppStateUpdateV1 `json:"app_state_update"`
	// QuorumSigs is the signature quorum for the application session
	QuorumSigs []string `json:"quorum_sigs"`
}

type StateV1 struct {
	// ID is the deterministic ID (hash) of the state
	ID string `json:"id"`
	// Transition is the state transition that led to this state
	Transition TransitionV1 `json:"transition"`
	// Asset is the asset type of the state
	Asset string `json:"asset"`
	// UserWallet is the user wallet address
	UserWallet string `json:"user_wallet"`
	// Epoch is the user Epoch Index
	Epoch string `json:"epoch"`
	// Version is the version of the state
	Version string `json:"version"`
	// HomeChannelID is the identifier for the home Channel blockchain network
	HomeChannelID *string `json:"home_channel_id,omitempty"`
	// EscrowChannelID is the identifier for the escrow Channel blockchain network
	EscrowChannelID *string `json:"escrow_channel_id,omitempty"`
	// HomeLedger contains user and node balances for the home channel
	HomeLedger LedgerV1 `json:"home_ledger"`
	// EscrowLedger contains user and node balances for the escrow channel
	EscrowLedger *LedgerV1 `json:"escrow_ledger,omitempty"`
	// UserSig is the user signature for the state
	UserSig *string `json:"user_sig,omitempty"`
	// NodeSig is the node signature for the state
	NodeSig *string `json:"node_sig,omitempty"`
}

type TokenV1 struct {
	// Name is the token name
	Name string `json:"name"`
	// Symbol is the token symbol
	Symbol string `json:"symbol"`
	// Address is the token contract address
	Address string `json:"address"`
	// BlockchainID is the blockchain network ID
	BlockchainID string `json:"blockchain_id"`
	// Decimals is the number of decimal places
	Decimals uint8 `json:"decimals"`
}

type TransactionV1 struct {
	// ID is the unique transaction reference
	ID string `json:"id"`
	// Asset is the asset symbol
	Asset string `json:"asset"`
	// TxType is the transaction type
	TxType core.TransactionType `json:"tx_type"`
	// FromAccount is the account that sent the funds
	FromAccount string `json:"from_account"`
	// ToAccount is the account that received the funds
	ToAccount string `json:"to_account"`
	// SenderNewStateID is the ID of the new sender's channel state
	SenderNewStateID *string `json:"sender_new_state_id,omitempty"`
	// ReceiverNewStateID is the ID of the new receiver's channel state
	ReceiverNewStateID *string `json:"receiver_new_state_id,omitempty"`
	// Amount is the transaction amount
	Amount string `json:"amount"`
	// CreatedAt is when the transaction was created
	CreatedAt string `json:"created_at"`
}

type TransitionV1 struct {
	// Type is the type of state transition
	Type core.TransitionType `json:"type"`
	// TxID is the transaction ID associated with the transition
	TxID string `json:"tx_id"`
	// AccountID is the account identifier (varies based on transition type)
	AccountID string `json:"account_id"`
	// Amount is the amount involved in the transition
	Amount string `json:"amount"`
}

type UserV1GetActionAllowancesRequest struct {
	// Wallet is the user's wallet address
	Wallet string `json:"wallet"`
}

type UserV1GetActionAllowancesResponse struct {
	// Allowances is the list of action allowances for the user
	Allowances []ActionAllowanceV1 `json:"allowances"`
}

type UserV1GetBalancesRequest struct {
	// Wallet is the user's wallet address
	Wallet string `json:"wallet"`
}

type UserV1GetBalancesResponse struct {
	// Balances is the list of asset balances
	Balances []BalanceEntryV1 `json:"balances"`
}

type UserV1GetTransactionsRequest struct {
	// Wallet filters by user's wallet address
	Wallet string `json:"wallet"`
	// Asset filters by asset symbol
	Asset *string `json:"asset,omitempty"`
	// TxType filters by transaction type
	TxType *core.TransactionType `json:"tx_type,omitempty"`
	// Pagination contains pagination parameters (offset, limit, sort)
	Pagination *PaginationParamsV1 `json:"pagination,omitempty"`
	// FromTime is the start time filter (Unix timestamp)
	FromTime *uint64 `json:"from_time,omitempty"`
	// ToTime is the end time filter (Unix timestamp)
	ToTime *uint64 `json:"to_time,omitempty"`
}

type UserV1GetTransactionsResponse struct {
	// Transactions is the list of transactions
	Transactions []TransactionV1 `json:"transactions"`
	// Metadata contains pagination information
	Metadata PaginationMetadataV1 `json:"metadata"`
}

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

type WebsocketConnectionConfig struct {
	// ConnectionID is the unique identifier for this connection (required)
	ConnectionID string
	// Origin is the origin of the connection, such as the client's IP address (optional)
	Origin string
	// WebsocketConn is the underlying WebSocket connection (required)
	WebsocketConn GorillaWsConnectionAdapter

	// WriteTimeout is the maximum duration to wait for a write operation (default: 5s)
	WriteTimeout time.Duration
	// WriteBufferSize is the capacity of the outgoing message buffer (default: 10)
	WriteBufferSize int
	// ProcessBufferSize is the capacity of the incoming message buffer (default: 10)
	ProcessBufferSize int
	// PingInterval is how often to send ping frames to clients (default: 5s).
	PingInterval time.Duration
	// PongTimeout is the maximum duration to wait for a pong response from the client (default: 10s).
	// If no pong is received within this duration, the connection is considered dead.
	PongTimeout time.Duration
	// Logger for connection events (default: no-op logger)
	Logger log.Logger
	// OnMessageSentHandler is called after a message is successfully sent (optional)
	OnMessageSentHandler func([]byte)
}

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

type WebsocketDialerConfig struct {
	// HandshakeTimeout is the duration to wait for the WebSocket handshake to complete
	HandshakeTimeout time.Duration

	// PingTimeout is how long to wait for a ping from the server before considering the connection dead.
	// The server sends periodic pings to keep connections alive and detect dead clients.
	PingTimeout time.Duration

	// EventChanSize is the buffer size for the event channel
	// A larger buffer prevents blocking when processing many unsolicited events
	EventChanSize int
}

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

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

type WebsocketNodeConfig struct {
	// Logger is used for structured logging throughout the node (required).
	Logger log.Logger

	// Connection lifecycle callbacks:
	// ObserveConnections is called with the current number of active connections whenever a connection is established or closed.
	ObserveConnections ObserveConnectionsFn

	// WsUpgraderReadBufferSize sets the read buffer size for the WebSocket upgrader (default: 1024).
	WsUpgraderReadBufferSize int
	// WsUpgraderWriteBufferSize sets the write buffer size for the WebSocket upgrader (default: 1024).
	WsUpgraderWriteBufferSize int
	// WsUpgraderCheckOrigin validates the origin of incoming WebSocket requests.
	// Default allows all origins; implement this for CORS protection.
	WsUpgraderCheckOrigin func(r *http.Request) bool

	// WsConnWriteTimeout is the maximum time to wait for a write operation (default: 5s).
	// Connections that exceed this timeout are considered unresponsive and closed.
	WsConnWriteTimeout time.Duration
	// WsConnWriteBufferSize is the capacity of each connection's outgoing message queue (default: 10).
	WsConnWriteBufferSize int
	// WsConnProcessBufferSize is the capacity of each connection's incoming message queue (default: 10).
	WsConnProcessBufferSize int
}