forwarder

type Accounter interface {
	// Allow returns an indication if the user is allowed to receive
	// the packet that took the given amount of airtime from the gateway.
	Allow(user common.Address, airtime time.Duration) bool

	// AddPayment must be called each time a router sends an airtime
	// payment to the forwarder. The accounter will store/track these
	// and determines if the router is allowed to receive more data.
	AddPayment(payment *router.AirtimePaymentEvent)
}

type Backend interface {
	// Stop closes the backend.
	Stop() error

	// Start starts the backend.
	Start() error

	// SetDownlinkTxAckFunc sets the DownlinkTXAck handler func.
	SetDownlinkTxAckFunc(func(*gw.DownlinkTxAck))

	// SetGatewayStatsFunc sets the GatewayStats handler func.
	SetGatewayStatsFunc(func(*gw.GatewayStats))

	// SetUplinkFrameFunc sets the UplinkFrame handler func.
	SetUplinkFrameFunc(func(*gw.UplinkFrame))

	// SetRawPacketForwarderEventFunc sets the RawPacketForwarderEvent handler func.
	SetRawPacketForwarderEventFunc(func(*gw.RawPacketForwarderEvent))

	// SetSubscribeEventFunc sets the Subscribe handler func.
	SetSubscribeEventFunc(func(events.Subscribe))

	// SendDownlinkFrame sends the given downlink frame.
	SendDownlinkFrame(*gw.DownlinkFrame) error

	// ApplyConfiguration applies the given configuration to the gateway.
	ApplyConfiguration(*gw.GatewayConfiguration) error

	// RawPacketForwarderCommand sends the given raw command to the packet-forwarder.
	RawPacketForwarderCommand(*gw.RawPacketForwarderCommand) error
}

type BlockchainConfig struct {
	Polygon *BlockchainPolygonConfig
}

type BlockchainPolygonConfig struct {
	Endpoint      string
	ChainID       uint64 `mapstructure:"chain_id"`
	Confirmations uint64
}

type Config struct {
	Forwarder ForwarderConfig

	Log LogConfig

	BlockChain BlockchainConfig

	Metrics *MetricsConfig
}

type CoverageClient struct {
}

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

type ForwarderBackendConfig struct {
	SemtechUDP    *ForwarderBackendSemtechUDPConfig `mapstructure:"semtech_udp"`
	BasicStation  *struct{}                         `mapstructure:"basic_station"`
	Concentratord *struct{}                         `mapstructure:"concentratord"`
}

type ForwarderBackendSemtechUDPConfig struct {
	UDPBind    *string `mapstructure:"udp_bind"`
	FakeRxTime *bool   `mapstructure:"fake_rx_time"`
}

type ForwarderConfig struct {
	// Backend holdsconfiguration related to the forwarders gateway
	// endpoint and supported protocol.
	Backend ForwarderBackendConfig

	// Gateways holds configuration related to gateways.
	Gateways ForwarderGatewayConfig

	Routers ForwarderRoutersConfig

	// Optional account strategy configuration, if not specified no account is used meaning
	// that all packets are exchanged between gateway and routers.
	Accounting *struct{}
}

type ForwarderGatewayConfig struct {
	// Store describes how gateways are stored/loaded in the forwarder.
	Store ForwarderGatewayStoreConfig

	// RecordUnknown records gateways that connect to the forwarder but
	// are not in the forwarders gateway store. Recorded gateways can
	// be imported later if required.
	RecordUnknown *ForwarderGatewayRecordUnknownConfig `mapstructure:"record_unknown"`
	// RegistryAddress holds the address where the gateway registry is
	// deployed on chain. It is used to retrieve gateway details to
	// determine which gateways in the store are onboarded on ThingsIX
	// and have their details. Once token support is integrated to ThingsIX
	// only data for these gateways will be forwarded.
	RegistryAddress *common.Address `mapstructure:"gateway_registry"`

	// Refresh indicates the interval in which the gateway registry is
	// used to check if gateways from the forwarders store are onboarded
	// have their gateways set.
	Refresh *time.Duration
}

type ForwarderGatewayRecordUnknownConfig struct {
	// File points to a file on the local file system where
	// unknown gateways that connect are recorded.
	File string
}

type ForwarderGatewayStoreConfig struct {
	// YamlStorePath indicates that gateways are stored in a
	// YAML based file store located on the local file system.
	// Only data for gateways in the store is forwarded.
	YamlStorePath *string `mapstructure:"file"`
}

type ForwarderRoutersConfig struct {
	// Default routers that will receive all gateway data unfiltered
	Default []*Router

	// OnChain idicates that ThingsIX routers are loaded from the router
	// registry as deployed on the blockchain.
	OnChain *ForwarderRoutersOnChainConfig `mapstructure:"on_chain"`

	// ThingsIXApi indicates when non-nil that router information must be
	// fetched from the ThingsIX API
	ThingsIXApi *ForwarderRoutersThingsIXAPIConfig `mapstructure:"thingsix_api"`
}

type ForwarderRoutersOnChainConfig struct {
	// RegistryContract indicates when non-nil that router information must
	// be fetched from the registry smart contract (required blockchain cfg)
	RegistryContract common.Address `mapstructure:"registry"`

	// Interval indicates how often the routes are refreshed
	UpdateInterval *time.Duration `mapstructure:"interval"`
}

type ForwarderRoutersThingsIXAPIConfig struct {
	Endpoint *string
	// Interval indicates how often the routes are refreshed
	UpdateInterval *time.Duration `mapstructure:"interval"`
}

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

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

type ID [32]byte

type LogConfig struct {
	Level     logrus.Level
	Timestamp bool
}

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

type MetricsConfig struct {
	Prometheus *MetricsPrometheusConfig
}

type MetricsPrometheusConfig struct {
	Address string
	Path    string
}

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

type NoAccounting struct {
}

type Router struct {
	// ID is the routers identity as its registered in the smart contract
	ThingsIXID ID
	// Endpoint is the URI where the router can be reached
	Endpoint string
	// Default is an indication if the router is configured in the configuration and wants to receive all data
	Default bool
	// Name is an optional name users can appoint to routers that are in the configuration
	Name string
	// NetID is the NetID that a Router wants to receive traffic for
	NetID lorawan.NetID
	// Prefix is the DevAddr prefix that matches the DevAddr of devices the Router wants to receive traffic for
	Prefix uint32
	// Mask is the DevAddr mask  that matches the DevAddr of devices the Router wants to receive traffic for
	Mask uint8
	// Owner is the routers owner
	Owner common.Address
	// contains filtered or unexported fields
}

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

type RouterDetails struct {
	// Endpoint is the URI where the router can be reached
	Endpoint string
	// NetID is the NetID that a Router wants to receive traffic for
	NetID lorawan.NetID
	// Prefix is the DevAddr prefix that matches the DevAddr of devices the Router wants to receive traffic for
	Prefix uint32
	// Mask is the DevAddr mask  that matches the DevAddr of devices the Router wants to receive traffic for
	Mask uint8
	// Owner is the routers owner
	Owner common.Address
}

type RoutesUpdaterFunc func() ([]*Router, error)

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

type UnknownGatewayLoggerFunc func(localGatewayID lorawan.EUI64)