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 Config struct {
	Forwarder struct {
		// Backend holdsconfiguration related to the forwarders gateway
		// endpoint and supported protocol.
		Backend struct {
			SemtechUDP *struct {
				UDPBind    *string `mapstructure:"udp_bind"`
				FakeRxTime *bool   `mapstructure:"fake_rx_time"`
			} `mapstructure:"semtech_udp"`

			BasicStation  *struct{} `mapstructure:"basic_station"`
			Concentratord *struct{} `mapstructure:"concentratord"`
		}

		// Gateways holds configuration related to gateways.
		Gateways struct {
			// Store describes how gateways are stored/loaded in the forwarder.
			Store 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"`
			}

			// 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 *struct {
				// File points to a file on the local file system where
				// unknown gateways that connect are recorded.
				File string
			} `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
		}

		Routers 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 *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"`
			} `mapstructure:"on_chain"`

			// ThingsIXApi indicates when non-nil that router information must be
			// fetched from the ThingsIX API
			ThingsIXApi *struct {
				Endpoint *string
				// Interval indicates how often the routes are refreshed
				UpdateInterval *time.Duration `mapstructure:"interval"`
			} `mapstructure:"thingsix_api"`
		}

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

	Log struct {
		Level     logrus.Level
		Timestamp bool
	}

	BlockChain struct {
		Polygon *struct {
			Endpoint      string
			ChainID       uint64 `mapstructure:"chain_id"`
			Confirmations uint64
		}
	}

	Metrics *struct {
		Prometheus *struct {
			Address string
			Path    string
		}
	}
}

type CoverageClient struct {
}

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

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

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

type ID [32]byte

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

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
	// NetIDs is the set of network identifiers this routers wants to receive packets from
	NetIDs []lorawan.NetID
	// 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
	// NetIDs is the set of network identifiers this routers wants to receive packets from
	NetIDs []lorawan.NetID
	// 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)