posemesh-node-registration 0.2.1

Posemesh node registration client and Axum handlers for DDS callbacks.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

# Posemesh Node Registration SDK

This crate packages the logic required for nodes to register with the discovery service.

## Modules

- `crypto`: helpers for secp256k1 key loading, Ethereum address derivation, and SIWE signature generation.
- `http`: an `axum` router that handles legacy DDS callbacks (e.g. `/internal/v1/registrations`) and health probes.
- `state`: in-memory cache plus persistence primitives for registration status and a cross-process lock.
- `register`: async registration client that periodically signs and submits SIWE-based registration payloads to DDS.

## Adding the Dependency

```toml
# Cargo.toml
[dependencies]
posemesh-node-registration = "0.2.1"
```

## Example: Mounting the HTTP Routes

```rust
use axum::Router;
use posemesh_node_registration::http::{router_dds, DdsState};

fn build_app() -> Router {
    let dds_state = DdsState;

    // Merge with your existing routes as needed
    router_dds(dds_state)
}
```

The callback handler automatically persists secrets in-memory via `state::write_node_secret`. 
Consumers that need to read the cached secret can call `state::read_node_secret()`.

## Example: Spawning the Registration Loop

```rust
use posemesh_node_registration::register::{self, RegistrationConfig};

async fn spawn_registration(config: RegistrationConfig) {
    tokio::spawn(register::run_registration_loop(config));
}

fn build_registration_config() -> RegistrationConfig {
    RegistrationConfig {
        dds_base_url: "https://dds.auki.network".into(),
        node_version: "1.0.0".into(),
        reg_secret: "my-reg-secret".into(),
        secp256k1_privhex: std::env::var("SECP256K1_PRIVHEX").expect("missing key"),
        client: reqwest::Client::builder()
            .timeout(std::time::Duration::from_secs(10))
            .build()
            .expect("client"),
        register_interval_secs: 60,
        max_retry: -1,
        capabilities: vec![
            "/reconstruction/global-refinement/v1".into(),
            "/reconstruction/local-refinement/v1".into(),
        ],
    }
}
```

`run_registration_loop` takes care of:

- Generating SIWE messages/signatures for registration payloads.
- Persisting registration state for downstream consumers.
- Parking once the runtime has successfully acquired registration, then re-arming only on recovery signals.
- Enforcing a process-local lock so that only one registrar task runs at a time.
- Exponential backoff with jitter when DDS requests fail, while rate-limiting repeated `409 Conflict` warnings.