A decentralized peer-to-peer network for exchanging standardized space data using Space Data Standards, built on IPFS and libp2p.

Enable decentralized, global collaboration on space situational awareness and space traffic management.

As space becomes increasingly congested with satellites, debris, and new actors, the need for transparent, real-time data sharing has never been greater. Space Data Network removes barriers to collaboration by:

• Eliminating single points of failure - No central server that can go down or be blocked
• Enabling permissionless participation - Anyone can join and contribute data
• Ensuring data integrity - Cryptographic verification of all shared data
• Reducing latency - Direct peer-to-peer data exchange without intermediaries
• Promoting interoperability - Standardized formats everyone can use

Space Data Network enables real-time sharing of space situational awareness data between organizations, satellites, and ground stations. Built on IPFS/libp2p with FlatBuffers serialization, SDN provides:

• Standardized Data Exchange - All Space Data Standards schemas supported
• Decentralized Architecture - No central server required
• Real-time PubSub - Subscribe to data streams by type (OMM, CDM, EPM, etc.)
• Cryptographic Verification - Ed25519 signatures on all data
• Cross-Platform - Server (Go), Browser (TypeScript), Desktop, Edge Relay support

# Download latest release
curl -sSL https://digitalarsenal.github.io/space-data-network//install.sh | bash

# Or build from source
git clone https://github.com/DigitalArsenal/space-data-network.git
cd space-data-network/sdn-server
go build -o spacedatanetwork ./cmd/spacedatanetwork

cd space-data-network/sdn-js
npm install
npm run build

# Initialize configuration
./spacedatanetwork init

# Start the node
./spacedatanetwork daemon

import { SDNNode, SchemaRegistry } from './path/to/sdn-js/dist/esm/index.js';

// Create and start a node
const node = new SDNNode();
await node.start();

// Subscribe to Orbital Mean-Elements Messages
node.subscribe('OMM', (data, peerId) => {
  console.log(`Received OMM from ${peerId}:`, data);
});

// Publish data
const ommData = { /* your OMM data */ };
await node.publish('OMM', ommData);

• Local CI (same checks as GitHub CI):

./scripts/ci-local.sh quick

• Full local CI (includes encryption tests):

./scripts/ci-local.sh full

• Pushes run local CI automatically via .husky/pre-push. To bypass intentionally:

SKIP_LOCAL_CI=1 git push

+-------------------------------------------------------------------+
|                      Space Data Network                           |
+-------------------------------------------------------------------+
|                                                                   |
|   +-----------+      +-----------+      +-----------+             |
|   | Full Node |<---->| Full Node |<---->| Full Node |             |
|   |   (Go)    |      |   (Go)    |      |   (Go)    |             |
|   +-----+-----+      +-----+-----+      +-----+-----+             |
|         |                  |                  |                   |
|         |     DHT + PubSub |                  |                   |
|         |                  |                  |                   |
|   +-----+-----+      +-----+-----+      +-----+-----+             |
|   |Edge Relay |      |Edge Relay |      |Edge Relay |             |
|   |   (Go)    |      |   (Go)    |      |   (Go)    |             |
|   +-----+-----+      +-----+-----+      +-----+-----+             |
|         |                  |                  |                   |
|         |  Circuit Relay   |                  |                   |
|         |                  |                  |                   |
|   +-----+-----+      +-----+-----+      +-----+-----+             |
|   |  Browser  |      |  Desktop  |      |  Browser  |             |
|   |   (JS)    |      |   (App)   |      |   (JS)    |             |
|   +-----------+      +-----------+      +-----------+             |
|                                                                   |
+-------------------------------------------------------------------+

cd sdn-js
npm install
npm run build

Every SDN node derives its cryptographic identity from a BIP-39 mnemonic using SLIP-10 hierarchical deterministic key derivation with the standard BIP-44 Bitcoin derivation path (coin type 0).

BIP-39 Mnemonic → PBKDF2 → 512-bit Seed → SLIP-10 Master Key
    ├── m/44'/0'/0'/0'/0'  →  Ed25519 Signing Key (also libp2p PeerID)
    └── m/44'/0'/0'/1'/0'  →  X25519 Encryption Key

SDN reuses the standard BIP-44 HD wallet path structure with Bitcoin's coin type 0:

• Wallet-native identity. The BIP-44 path structure lets users derive SDN signing and encryption keys from the same mnemonic they use for cryptocurrency wallets. One seed, many independent key trees.
• Multi-account. The account' segment enables one mnemonic to manage multiple SDN identities (operator, sensor, analytics service), each with independent key pairs.

The xpub (extended public key) serves as the master network identity. Anyone with the xpub can derive the node's public signing and encryption keys without access to private key material.

Space Data Network is built on the InterPlanetary File System (IPFS) stack:

SDN extends IPFS with space-specific optimizations:

• FlatBuffers for zero-copy performance
• Schema-validated data (Space Data Standards + OrbPro control schemas)
• Topic-per-schema PubSub
• SQLite storage with FlatBuffer virtual tables

OrbPro licensing/key exchange stream schemas (v1.0) are versioned in the plugin SDK:

• packages/plugin-sdk/schemas/orbpro/key-broker/PublicKeyResponse.fbs
• packages/plugin-sdk/schemas/orbpro/key-broker/KeyBrokerRequest.fbs
• packages/plugin-sdk/schemas/orbpro/key-broker/KeyBrokerResponse.fbs

Regenerate plugin SDK + SDN Go bindings from these schemas (via flatc-wasm):

npm run generate:plugin-sdk:key-broker-bindings

Run the plugin SDK protocol test client:

npm run test:plugin-sdk:key-broker-client -- --node-info-url http://127.0.0.1:5010/api/node/info

SDN supports all Space Data Standards:

node.subscribe('CDM', (cdm, peerId) => {
  if (cdm.COLLISION_PROBABILITY > 1e-4) {
    alertOperator(cdm);
  }
});

• OMM - Mean orbital elements (TLE-equivalent)
• OEM - Precise ephemeris state vectors
• OCM - Comprehensive orbit characterization

• MPE - Maneuver notifications
• LDM/LCC - Launch coordination
• ROC - Reentry predictions

SDN uses a two-tier peer topology for maximum reach and reliability:

┌─────────────────────────────────────────────────────────────────┐
│                    FULL NODES (Open Internet)                    │
│                                                                  │
│    ┌──────────┐      ┌──────────┐      ┌──────────┐             │
│    │Full Node │◄────►│Full Node │◄────►│Full Node │             │
│    │  (Go)    │      │  (Go)    │      │  (Go)    │             │
│    └────┬─────┘      └────┬─────┘      └────┬─────┘             │
│         │                 │                 │                    │
│         │    DHT + GossipSub + Relay        │                    │
│         │                 │                 │                    │
├─────────┼─────────────────┼─────────────────┼────────────────────┤
│         ▼                 ▼                 ▼                    │
│                 LIGHT PEERS (Behind NAT/Firewall)                │
│                                                                  │
│    ┌──────────┐      ┌──────────┐      ┌──────────┐             │
│    │ Browser  │      │ Desktop  │      │Corporate │             │
│    │  (JS)    │      │  (App)   │      │   Node   │             │
│    └──────────┘      └──────────┘      └──────────┘             │
└─────────────────────────────────────────────────────────────────┘

• Run on servers with public IP addresses
• Participate in DHT routing and peer discovery
• Relay traffic for firewalled peers via Circuit Relay
• Pin and store content for the network
• Requirements: Public IP, ports 4001 (libp2p), 8080 (HTTP API)

• Connect through relay nodes when behind NAT/firewalls
• Can subscribe to data, publish messages, verify signatures
• Cannot contribute to DHT routing
• Includes: browsers, mobile apps, desktop apps, corporate networks

Help strengthen the network by running a full node:

./spacedatanetwork daemon --relay-enabled --announce-public

All data on SDN is content-addressed using cryptographic hashes (CIDs):

SDN uses Publish Notification Messages (PNM) for intelligent content distribution. Instead of broadcasting all data, nodes announce content availability via PNM, allowing peers to selectively fetch based on their configuration.

Publisher                           Subscriber
    |                                   |
    |-- Pin content locally             |
    |-- Broadcast PNM (CID + schema) ---|--> Receive PNM
    |                                   |-- Check config for peer + schema
    |                                   |-- If autoFetch: fetch content
    |                                   |-- If autoPin: pin with TTL

Nodes can configure auto-fetch, auto-pin, and TTL per-source AND per-schema:

This enables flexible policies like:

• Auto-pin all conjunction warnings from anyone
• Auto-fetch orbital data only from trusted partners
• Store data from government agencies for 1 week, commercial for 24h

See sdn-server documentation for configuration details.

SDN includes an optional commercial layer for monetizing space data:

1. Provider publishes premium data product (high-precision ephemeris, analysis, etc.)
2. Per-customer encryption - Data encrypted with each customer's public key (ECIES)
3. Customer pays via credit card through integrated payment gateway
4. Access granted - Customer receives and decrypts data with their private key

• Encryption: ECIES with X25519 key exchange + AES-256-GCM
• Payment Gateway: Stripe integration for credit card processing
• Revenue Distribution: Automated splits between data providers and platform
• Metering: Usage tracking for consumption-based billing

The marketplace operates on top of the free, open network. Core SSA data exchange remains free and open - the commercial layer is opt-in for premium products.

Run an end-to-end check that validates loading a licensing plugin from a local workspace into SDN.

npm run plugin-harness -- /path/to/private-repo

You can also use the command with any plugin workspace path:

npm run plugin-harness -- /path/to/repo

Options:

• --repo (or positional first arg): path to the plugin workspace
• --admin-addr: admin endpoint used for verification (default 127.0.0.1:5010)
• --artifact-dir: path to existing encrypted artifacts when --skip-build is set
• --skip-build: use existing artifacts in the staging directory
• --keep-workspace: keep temporary workspace for debugging
• --derivation-secret: optional derivation secret override (64 hex chars)

This command is key-management agnostic on the CLI:

• It derives the keypair internally for normal runs.
• A fixed test public key is read from PLUGIN_KEY_SERVER_ARTIFACT_PUBLIC_KEY_HEX when set.
• For --skip-build, it requires both PLUGIN_KEY_SERVER_ARTIFACT_PUBLIC_KEY_HEX and PLUGIN_KEY_SERVER_ARTIFACT_PRIVATE_KEY_HEX.

The command uses the standardized plugin task:

npm run build:key-server

It then copies/decrypts the generated encrypted artifact, boots SDN with a temporary plugin catalog, and verifies:

• /api/v1/plugins/manifest reports the plugin id (default plugin-key-broker) as running
• /api/v1/plugins/<plugin-id>/bundle returns 200 and non-empty WASM payload

This harness runs against private repos as long as the repo is reachable and follows the plugin workspace contract.

1. Clone/fetch private repo using your normal auth path (SSH key or token-based HTTPS).
2. Confirm workspace layout includes:
   • package.json
   • scripts/build-plugin-release.js (or PLUGIN_HARNESS_BUILD_HELPER_SCRIPT override)
   • npm run build:key-server succeeds (or configure PLUGIN_HARNESS_BUILD_COMMAND)
3. Export one of the artifact public key env vars used for staging:
   • PLUGIN_KEY_SERVER_ARTIFACT_PUBLIC_KEY_HEX (preferred)
   • PLUGIN_KEY_SERVER_ARTIFACT_PRIVATE_KEY_HEX when using --skip-build
4. Run:

npm run plugin-harness -- /path/to/private-plugin-repo

5. The harness validates the plugin lifecycle and plugin API endpoints in SDN.

Use `--skip-build` when reusing staged artifacts already in CI:

```bash
export PLUGIN_KEY_SERVER_ARTIFACT_PUBLIC_KEY_HEX=<public_hex>
export PLUGIN_KEY_SERVER_ARTIFACT_PRIVATE_KEY_HEX=<matching_private_hex>
npm run plugin-harness -- /path/to/private-plugin-repo --skip-build --artifact-dir /path/to/Build/plugin/licensing-server

If your private repo has a custom auth requirement, run the harness in that authenticated shell context so Git can access dependencies and source.

• Go 1.21+
• Node.js 18+
• Emscripten (for WASM)

git clone https://github.com/DigitalArsenal/space-data-network.git
cd space-data-network

# Build server
cd sdn-server
go build -o spacedatanetwork ./cmd/spacedatanetwork
go build -tags edge -o spacedatanetwork-edge ./cmd/spacedatanetwork-edge

# Build JavaScript SDK
cd ../sdn-js
npm install
npm run build

# Go tests
cd sdn-server && go test ./...

# JavaScript tests
cd sdn-js && npm test

Full documentation is available at docs.digitalarsenal.github.io/space-data-network or locally at docs/docs.html.

To preview the docs locally, start a webserver from the docs/ directory:

cd docs && python3 -m http.server 8080

Then open http://localhost:8080.

Topics covered:

• Getting Started & Quick Start
• Full Node Setup & Configuration
• Edge Relay Deployment
• JavaScript SDK Reference
• REST & WebSocket API
• Schema Reference (all Space Data Standards)

• digitalarsenal.github.io/space-data-network
• docs.digitalarsenal.github.io/space-data-network
• GitHub
• Space Data Standards
• SDN JS Source

See CONTRIBUTING.md for guidelines.

MIT License - see LICENSE for details.

Built for the space community