We need access to an anemo::Network within RPC handler functions so they can send their own outbound RPCs as part of serving requests.

Like curl but for anemo

Features that would be nice:

• craft and send arbitrary requests to any anemo endpoint (needs to support whatever kind of admin keys or credentials would be required for this to be safe)
• query for list of available services and methods

For error responses, some nice to haves:

• machine-usable errors (i.e. I can include my custom Error object in response and then extract it from the Status to do stuff with error data in code)
• more complete list of HTTP status codes

Would aid clarity to not have two functions that do the same thing, unless there's an idiomatic reason for this?

This should have the same interface as any regular RPC send, just treating the time it takes for anemo to connect to the peer the same way as any other kind of latency.

Otherwise every client that needs reliable send (or not really reliable, but more like, "keep trying until explicitly told to give up") will have to reimplement essentially the same logic on the application side.

There should be a conventional way to create a mock RPC server for unit testing.

anemo (or some sui middleware) should have support for request limiting.

Ideally on a per-method, per-peer level we could set limits for request rate and max number of concurrent inflight requests. (Would be ideal if these were modifiable while program is running, to respond to byzantine nodes by deprioritizing.)

A udp socket that is bound to an ipv4 address cannot trivially communicate with an ipv6 address. Despite this we should probably make a better effort when bound to an ipv4 address by:

• looking at all addresses from the dns resolution process and find a suitable address (instead of always grabbing the first)
• attempting to convert an ipv6 address to an ipv4 mapped address when possible.

It's possible to use tokio timeout but this leads to unwieldy types containing numerous nested Results. I think default and per-RPC timeouts should be a native feature of the code generated RPC services in anemo. Timeout should be a supported error type within anemo::rpc::Status. Bonus if we also make client propagate its timeout to server so that the server can behave accordingly (eg fail-fast, or use it to set appropriate timeouts on Child RPCs).

It should be possible to constrain which peers anemo will allow to connect or send certain RPCs.

In order to stop using a random reset key 3bcbd2c used the ed25519 private key as a seed to an rng in order to generate a 64 byte long reset key. This may not be cryptographically safe and should instead be replaced with an HKDF.

bmwill@3bcbd2c#r90041540

This may not be cryptographically safe. Consider using an audited HKDF, as done e.g. in https://www.rfc-editor.org/rfc/rfc9001.html#initial-secrets.

Global timeout on both client and server side should be a default but not an override. Should be configurable on a per-method basis to a different value, or no timeout at all.