Quickstart

curl -s https://registry.libertynet.ai/health

const res = await fetch("https://registry.libertynet.ai/health");
console.log(await res.json());

import json, urllib.request
with urllib.request.urlopen("https://registry.libertynet.ai/health") as r:
    print(json.load(r))

curl -s https://registry.libertynet.ai/nodes | head -c 400

const { count, nodes } = await (await fetch("https://registry.libertynet.ai/nodes")).json();
console.log(`${count} nodes`);
console.log(nodes[0]);

import json, urllib.request
with urllib.request.urlopen("https://registry.libertynet.ai/nodes") as r:
    data = json.load(r)
print(f"{data['count']} nodes")
print(data["nodes"][0])

import { createHash } from "node:crypto";

const B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

function b58decode(s) {
  let n = 0n;
  for (const c of s) {
    const i = B58.indexOf(c);
    if (i < 0) return null;
    n = n * 58n + BigInt(i);
  }
  let hex = n.toString(16);
  if (hex.length % 2) hex = "0" + hex;
  // base58 drops leading zero bytes, so restore one per leading '1'
  let lead = 0;
  for (const c of s) { if (c === "1") lead++; else break; }
  return Buffer.concat([Buffer.alloc(lead), Buffer.from(hex, "hex")]);
}

// The registry serves keys as hex in /nodes and as base58 in /peers. Same key.
function keyBytes(pk) {
  return /^[0-9a-f]{64}$/.test(pk) ? Buffer.from(pk, "hex") : b58decode(pk);
}

/** Does this DID actually derive from this public key? */
function verifyIdBinding(did, publicKey) {
  const key = keyBytes(publicKey);
  if (!key || key.length !== 32) return false;

  const digest = createHash("sha256").update(key).digest("hex");
  const body = did.replace(/^did:svrp:(?:[a-z]:)?/, "");

  if (body.length === 64) return body === key.toString("hex"); // full-hex form
  if (body.length === 8) return body === digest.slice(0, 8);   // short form
  if (body.length === 10) return body === digest.slice(0, 10); // collision fallback
  return false;
}

const { nodes } = await (await fetch("https://registry.libertynet.ai/nodes")).json();

let verified = 0;
for (const n of nodes) {
  if (verifyIdBinding(n.did, n.public_key)) verified++;
  else console.log("REJECT", n.did);
}
console.log(`${verified}/${nodes.length} identities verified`);

const fresh = nodes.filter(
  (n) => n.last_seen && Date.now() - Date.parse(n.last_seen) < 10 * 60 * 1000,
);
console.log(`${fresh.length} seen in the last 10 minutes`);

import hashlib, json, re, urllib.request

B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

def b58decode(s):
    n = 0
    for c in s:
        i = B58.find(c)
        if i < 0:
            return None
        n = n * 58 + i
    raw = n.to_bytes((n.bit_length() + 7) // 8, "big")
    # base58 drops leading zero bytes, so restore one per leading '1'
    return b"\0" * (len(s) - len(s.lstrip("1"))) + raw

# The registry serves keys as hex in /nodes and as base58 in /peers. Same key.
def key_bytes(pk):
    if re.fullmatch(r"[0-9a-f]{64}", pk):
        return bytes.fromhex(pk)
    return b58decode(pk)

def verify_id_binding(did: str, public_key: str) -> bool:
    """Does this DID actually derive from this public key?"""
    key = key_bytes(public_key)
    if not key or len(key) != 32:
        return False

    digest = hashlib.sha256(key).hexdigest()
    body = re.sub(r"^did:svrp:(?:[a-z]:)?", "", did)

    if len(body) == 64:
        return body == key.hex()        # full-hex form
    if len(body) == 8:
        return body == digest[:8]       # short form
    if len(body) == 10:
        return body == digest[:10]      # collision fallback
    return False

with urllib.request.urlopen("https://registry.libertynet.ai/nodes", timeout=10) as r:
    nodes = json.load(r)["nodes"]

verified = sum(verify_id_binding(n["did"], n["public_key"]) for n in nodes)
print(f"{verified}/{len(nodes)} identities verified")

import { LibertyNet } from "libertynet-sdk";

const ln = new LibertyNet();               // verification is on; you cannot turn it off
const nodes = await ln.discovery.online(); // fresh, verified nodes only

console.log(nodes.map((n) => `${n.did} ${n.region} ${n.capabilities.join(",")}`));

from libertynet import LibertyNet

ln = LibertyNet()                  # verification is on; you cannot turn it off
nodes = ln.discovery.online()      # fresh, verified nodes only

for n in nodes:
    print(n.did, n.region, ",".join(n.capabilities))