@le-space/aleph-bootstrap 0.3.0 → 0.3.3

package/README.md

@@ -14,6 +14,12 @@ It is designed for two complementary jobs:
 - `createLibp2pAlephBootstrap(options)`
 - `filterPublicMultiaddrs(addrs, options?)`
 - `createRelayBootstrapPost(options)`
+- `signRelayBootstrapAuthorization(args)`
+- `signRelayBootstrapProof(args)`
+- `verifyRelayBootstrapAuthorization(record)`
+- `verifyRelayBootstrapProof(record, options?)`
+- `verifyRelayBootstrapDualKeyContent(content, options?)`
+- `relayBootstrapTrustMode(content)`
 
 ## Default Aleph convention
 
@@ -24,3 +30,34 @@ The package defaults to the shared relay-bootstrap namespace:
 - post type: `relay-bootstrap`
 
 All values are overrideable per app or environment.
+
+## Discovery Trust Modes
+
+The package accepts both:
+
+- legacy wallet-signed bootstrap posts
+- dual-key-attested bootstrap posts
+
+By default, discovery will:
+
+- accept legacy posts
+- verify dual-key records when they are present
+- ignore malformed or invalid dual-key records
+
+If a consumer wants to require the stronger model:
+
+```ts
+const list = await discoverAlephBootstrapMultiaddrs({
+  requireDualKeyAttestation: true,
+})
+```
+
+## Dual-Key Model
+
+The intended stronger trust model is:
+
+- owner key `A` authorizes relay publisher key `B`
+- relay publisher key `B` signs the bootstrap payload
+- the Aleph bootstrap `POST` is published by `B`
+- readers verify both the owner authorization and relay proof before trusting
+  the record

package/index.d.ts

@@ -1,15 +1,59 @@
+import { bootstrap } from '@libp2p/bootstrap';
+
 declare const DEFAULT_ALEPH_API_HOST = "https://api2.aleph.im";
 declare const DEFAULT_ALEPH_BOOTSTRAP_CHANNEL = "simple-todo";
 declare const DEFAULT_ALEPH_BOOTSTRAP_REF = "simple-todo-bootstrap";
 declare const DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE = "relay-bootstrap";
 declare const DEFAULT_BOOTSTRAP_MAX_AGE_MS: number;
 declare const DEFAULT_BOOTSTRAP_PAGINATION = 50;
+declare const DEFAULT_BOOTSTRAP_MAX_PAGES = 5;
+declare const RELAY_BOOTSTRAP_SIGNATURE_SCHEME = "personal_sign";
+interface RelayBootstrapAuthorizationPayload {
+    ownerAddress: string;
+    publisherAddress: string;
+    peerId: string;
+    registrationId?: string;
+    profile?: string;
+    version?: string;
+    instanceItemHash?: string;
+    issuedAt: number;
+    expiresAt?: number;
+}
+interface RelayBootstrapAuthorizationRecord {
+    scheme: string;
+    payload: RelayBootstrapAuthorizationPayload;
+    signature: string;
+}
+interface RelayBootstrapProofPayload {
+    peerId: string;
+    multiaddrs: string[];
+    browserMultiaddrs?: string[];
+    registrationId?: string;
+    profile?: string;
+    version?: string;
+    updatedAt: number;
+}
+interface RelayBootstrapProofRecord {
+    scheme: string;
+    payload: RelayBootstrapProofPayload;
+    signature: string;
+}
+interface RelayBootstrapVerificationResult {
+    ok: boolean;
+    errors: string[];
+}
+type RelayBootstrapProofSigner = (address: string, payload: string) => Promise<string>;
 interface RelayBootstrapContent {
     peerId: string;
     multiaddrs: string[];
     browserMultiaddrs?: string[];
+    registrationId?: string;
     profile?: string;
     version?: string;
+    ownerAddress?: string;
+    publisherAddress?: string;
+    authorization?: RelayBootstrapAuthorizationRecord;
+    relayProof?: RelayBootstrapProofRecord;
     updatedAt: number;
 }
 interface RelayBootstrapPostContent {
@@ -35,8 +79,11 @@ interface DiscoverAlephBootstrapOptions {
     postType?: string;
     page?: number;
     pagination?: number;
+    maxPages?: number;
     maxAgeMs?: number;
     browserDialableOnly?: boolean;
+    requireDualKeyAttestation?: boolean;
+    verifyDualKeyAttestation?: boolean;
     fetch?: typeof fetch;
 }
 interface FilterPublicMultiaddrsOptions {
@@ -48,14 +95,20 @@ interface CreateRelayBootstrapPostOptions {
     peerId: string;
     multiaddrs: string[];
     browserMultiaddrs?: string[];
+    registrationId?: string;
     ref?: string;
     channel?: string;
     postType?: string;
     profile?: string;
     version?: string;
+    ownerAddress?: string;
+    publisherAddress?: string;
+    authorization?: RelayBootstrapAuthorizationRecord;
+    relayProof?: RelayBootstrapProofRecord;
     now?: number;
     hasher: (payload: string) => Promise<string> | string;
 }
+type RelayBootstrapTrustMode = "legacy-wallet-signed" | "dual-key-attested";
 declare function dedupeMultiaddrs(addrs: readonly string[]): string[];
 declare function isPublicMultiaddr(addr: string): boolean;
 declare function filterPublicMultiaddrs(addrs: readonly string[], options?: FilterPublicMultiaddrsOptions): string[];
@@ -64,10 +117,15 @@ declare function buildRelayBootstrapPostContent(args: {
     peerId: string;
     multiaddrs: string[];
     browserMultiaddrs?: string[];
+    registrationId?: string;
     ref?: string;
     postType?: string;
     profile?: string;
     version?: string;
+    ownerAddress?: string;
+    publisherAddress?: string;
+    authorization?: RelayBootstrapAuthorizationRecord;
+    relayProof?: RelayBootstrapProofRecord;
     now?: number;
 }): RelayBootstrapPostContent;
 declare function createRelayBootstrapPost(args: CreateRelayBootstrapPostOptions): Promise<{
@@ -80,11 +138,48 @@ declare function createRelayBootstrapPost(args: CreateRelayBootstrapPostOptions)
     item_content: string;
     item_hash: string;
 }>;
+declare function relayBootstrapTrustMode(content: RelayBootstrapContent | null | undefined): RelayBootstrapTrustMode;
+declare function signRelayBootstrapAuthorization(args: {
+    ownerAddress: string;
+    publisherAddress: string;
+    peerId: string;
+    registrationId?: string;
+    profile?: string;
+    version?: string;
+    instanceItemHash?: string;
+    issuedAt?: number;
+    expiresAt?: number;
+    signer: RelayBootstrapProofSigner;
+}): Promise<RelayBootstrapAuthorizationRecord>;
+declare function signRelayBootstrapProof(args: {
+    publisherAddress: string;
+    peerId: string;
+    multiaddrs: string[];
+    browserMultiaddrs?: string[];
+    registrationId?: string;
+    profile?: string;
+    version?: string;
+    updatedAt?: number;
+    signer: RelayBootstrapProofSigner;
+}): Promise<RelayBootstrapProofRecord>;
+declare function verifyRelayBootstrapAuthorization(authorization: RelayBootstrapAuthorizationRecord | null | undefined, options?: {
+    now?: number;
+}): Promise<RelayBootstrapVerificationResult>;
+declare function verifyRelayBootstrapProof(proof: RelayBootstrapProofRecord | null | undefined, options?: {
+    expectedPublisherAddress?: string;
+    expectedPeerId?: string;
+}): Promise<RelayBootstrapVerificationResult>;
+declare function verifyRelayBootstrapDualKeyContent(content: RelayBootstrapContent | null | undefined, options?: {
+    now?: number;
+}): Promise<RelayBootstrapVerificationResult>;
 declare function fetchAlephBootstrapPosts(options?: DiscoverAlephBootstrapOptions): Promise<RelayBootstrapPostRecord[]>;
+declare function selectCurrentRelayBootstrapPosts(posts: readonly RelayBootstrapPostRecord[], options?: Pick<DiscoverAlephBootstrapOptions, "maxAgeMs"> & {
+    now?: number;
+}): RelayBootstrapPostRecord[];
 declare function discoverAlephBootstrapMultiaddrs(options?: DiscoverAlephBootstrapOptions): Promise<string[]>;
 declare function createLibp2pAlephBootstrap(options?: DiscoverAlephBootstrapOptions & {
     timeout?: number;
     tagName?: string;
-}): Promise<unknown>;
+}): Promise<ReturnType<typeof bootstrap>>;
 
-export { type CreateRelayBootstrapPostOptions, DEFAULT_ALEPH_API_HOST, DEFAULT_ALEPH_BOOTSTRAP_CHANNEL, DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE, DEFAULT_ALEPH_BOOTSTRAP_REF, DEFAULT_BOOTSTRAP_MAX_AGE_MS, DEFAULT_BOOTSTRAP_PAGINATION, type DiscoverAlephBootstrapOptions, type FilterPublicMultiaddrsOptions, type RelayBootstrapContent, type RelayBootstrapPostContent, type RelayBootstrapPostRecord, buildRelayBootstrapPostContent, createLibp2pAlephBootstrap, createRelayBootstrapPost, dedupeMultiaddrs, discoverAlephBootstrapMultiaddrs, fetchAlephBootstrapPosts, filterPublicMultiaddrs, isPublicMultiaddr };
+export { type CreateRelayBootstrapPostOptions, DEFAULT_ALEPH_API_HOST, DEFAULT_ALEPH_BOOTSTRAP_CHANNEL, DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE, DEFAULT_ALEPH_BOOTSTRAP_REF, DEFAULT_BOOTSTRAP_MAX_AGE_MS, DEFAULT_BOOTSTRAP_MAX_PAGES, DEFAULT_BOOTSTRAP_PAGINATION, type DiscoverAlephBootstrapOptions, type FilterPublicMultiaddrsOptions, RELAY_BOOTSTRAP_SIGNATURE_SCHEME, type RelayBootstrapAuthorizationPayload, type RelayBootstrapAuthorizationRecord, type RelayBootstrapContent, type RelayBootstrapPostContent, type RelayBootstrapPostRecord, type RelayBootstrapProofPayload, type RelayBootstrapProofRecord, type RelayBootstrapProofSigner, type RelayBootstrapTrustMode, type RelayBootstrapVerificationResult, buildRelayBootstrapPostContent, createLibp2pAlephBootstrap, createRelayBootstrapPost, dedupeMultiaddrs, discoverAlephBootstrapMultiaddrs, fetchAlephBootstrapPosts, filterPublicMultiaddrs, isPublicMultiaddr, relayBootstrapTrustMode, selectCurrentRelayBootstrapPosts, signRelayBootstrapAuthorization, signRelayBootstrapProof, verifyRelayBootstrapAuthorization, verifyRelayBootstrapDualKeyContent, verifyRelayBootstrapProof };

package/index.js

@@ -1,11 +1,44 @@
 // src/index.ts
 import { bootstrap } from "@libp2p/bootstrap";
+import { recoverMessageAddress } from "viem";
 var DEFAULT_ALEPH_API_HOST = "https://api2.aleph.im";
 var DEFAULT_ALEPH_BOOTSTRAP_CHANNEL = "simple-todo";
 var DEFAULT_ALEPH_BOOTSTRAP_REF = "simple-todo-bootstrap";
 var DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE = "relay-bootstrap";
 var DEFAULT_BOOTSTRAP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var DEFAULT_BOOTSTRAP_PAGINATION = 50;
+var DEFAULT_BOOTSTRAP_MAX_PAGES = 5;
+var RELAY_BOOTSTRAP_SIGNATURE_SCHEME = "personal_sign";
+function serializeOwnerAuthorizationPayload(payload) {
+  return JSON.stringify({
+    ownerAddress: payload.ownerAddress,
+    publisherAddress: payload.publisherAddress,
+    peerId: payload.peerId,
+    registrationId: payload.registrationId,
+    profile: payload.profile,
+    version: payload.version,
+    instanceItemHash: payload.instanceItemHash,
+    issuedAt: payload.issuedAt,
+    expiresAt: payload.expiresAt
+  });
+}
+function serializeRelayProofPayload(payload) {
+  return JSON.stringify({
+    peerId: payload.peerId,
+    multiaddrs: dedupeMultiaddrs(payload.multiaddrs),
+    browserMultiaddrs: payload.browserMultiaddrs ? dedupeMultiaddrs(payload.browserMultiaddrs) : void 0,
+    registrationId: payload.registrationId,
+    profile: payload.profile,
+    version: payload.version,
+    updatedAt: payload.updatedAt
+  });
+}
+async function recoverAddressForSignature(payload, signature) {
+  return recoverMessageAddress({
+    message: payload,
+    signature
+  });
+}
 function asTrimmedString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -20,6 +53,13 @@ function asNumber(value) {
 function normalizeHost(host) {
   return host.trim().toLowerCase();
 }
+function normalizeAddress(address) {
+  return address.trim().toLowerCase();
+}
+function normalizeSignature(signature) {
+  const trimmed = signature.trim();
+  return trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+}
 function splitMultiaddr(addr) {
   return addr.split("/").filter(Boolean);
 }
@@ -102,11 +142,75 @@ function normalizeRelayBootstrapContent(value) {
     peerId,
     multiaddrs: dedupeMultiaddrs(multiaddrs),
     browserMultiaddrs: browserMultiaddrs ? dedupeMultiaddrs(browserMultiaddrs) : void 0,
+    registrationId: asTrimmedString(content.registrationId) ?? void 0,
     profile: asTrimmedString(content.profile) ?? void 0,
     version: asTrimmedString(content.version) ?? void 0,
+    ownerAddress: asTrimmedString(content.ownerAddress) ?? void 0,
+    publisherAddress: asTrimmedString(content.publisherAddress) ?? void 0,
+    authorization: normalizeRelayBootstrapAuthorizationRecord(content.authorization) ?? void 0,
+    relayProof: normalizeRelayBootstrapProofRecord(content.relayProof) ?? void 0,
+    updatedAt
+  };
+}
+function normalizeRelayBootstrapAuthorizationPayload(value) {
+  if (!value || typeof value !== "object") return null;
+  const payload = value;
+  const ownerAddress = asTrimmedString(payload.ownerAddress);
+  const publisherAddress = asTrimmedString(payload.publisherAddress);
+  const peerId = asTrimmedString(payload.peerId);
+  const issuedAt = asNumber(payload.issuedAt);
+  const expiresAt = asNumber(payload.expiresAt) ?? void 0;
+  if (!ownerAddress || !publisherAddress || !peerId || issuedAt == null) {
+    return null;
+  }
+  return {
+    ownerAddress,
+    publisherAddress,
+    peerId,
+    registrationId: asTrimmedString(payload.registrationId) ?? void 0,
+    profile: asTrimmedString(payload.profile) ?? void 0,
+    version: asTrimmedString(payload.version) ?? void 0,
+    instanceItemHash: asTrimmedString(payload.instanceItemHash) ?? void 0,
+    issuedAt,
+    expiresAt
+  };
+}
+function normalizeRelayBootstrapAuthorizationRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const scheme = asTrimmedString(record.scheme);
+  const signature = asTrimmedString(record.signature);
+  const payload = normalizeRelayBootstrapAuthorizationPayload(record.payload);
+  if (!scheme || !signature || !payload) return null;
+  return { scheme, signature, payload };
+}
+function normalizeRelayBootstrapProofPayload(value) {
+  if (!value || typeof value !== "object") return null;
+  const payload = value;
+  const peerId = asTrimmedString(payload.peerId);
+  const updatedAt = asNumber(payload.updatedAt);
+  if (!peerId || updatedAt == null) return null;
+  const multiaddrs = Array.isArray(payload.multiaddrs) ? payload.multiaddrs.filter((entry) => typeof entry === "string") : [];
+  const browserMultiaddrs = Array.isArray(payload.browserMultiaddrs) ? payload.browserMultiaddrs.filter((entry) => typeof entry === "string") : void 0;
+  return {
+    peerId,
+    multiaddrs: dedupeMultiaddrs(multiaddrs),
+    browserMultiaddrs: browserMultiaddrs ? dedupeMultiaddrs(browserMultiaddrs) : void 0,
+    registrationId: asTrimmedString(payload.registrationId) ?? void 0,
+    profile: asTrimmedString(payload.profile) ?? void 0,
+    version: asTrimmedString(payload.version) ?? void 0,
     updatedAt
   };
 }
+function normalizeRelayBootstrapProofRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const scheme = asTrimmedString(record.scheme);
+  const signature = asTrimmedString(record.signature);
+  const payload = normalizeRelayBootstrapProofPayload(record.payload);
+  if (!scheme || !signature || !payload) return null;
+  return { scheme, signature, payload };
+}
 function normalizeRelayBootstrapPostRecord(value) {
   if (!value || typeof value !== "object") return null;
   const entry = value;
@@ -133,8 +237,13 @@ function buildRelayBootstrapPostContent(args) {
       browserMultiaddrs: args.browserMultiaddrs ? filterPublicMultiaddrs(args.browserMultiaddrs, {
         browserDialableOnly: true
       }) : void 0,
+      registrationId: args.registrationId,
       profile: args.profile,
       version: args.version,
+      ownerAddress: args.ownerAddress,
+      publisherAddress: args.publisherAddress,
+      authorization: args.authorization,
+      relayProof: args.relayProof,
       updatedAt: Math.round(updatedAt)
     },
     time: now
@@ -148,10 +257,15 @@ async function createRelayBootstrapPost(args) {
     peerId: args.peerId,
     multiaddrs: args.multiaddrs,
     browserMultiaddrs: args.browserMultiaddrs,
+    registrationId: args.registrationId,
     ref: args.ref ?? DEFAULT_ALEPH_BOOTSTRAP_REF,
     postType: args.postType ?? DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE,
     profile: args.profile,
     version: args.version,
+    ownerAddress: args.ownerAddress,
+    publisherAddress: args.publisherAddress,
+    authorization: args.authorization,
+    relayProof: args.relayProof,
     now: nowMillis
   });
   itemContent.time = nowSeconds;
@@ -168,6 +282,165 @@ async function createRelayBootstrapPost(args) {
     item_hash: itemHash
   };
 }
+function relayBootstrapTrustMode(content) {
+  if (content?.authorization && content?.relayProof && content.authorization.payload.publisherAddress && content.relayProof.payload.peerId) {
+    return "dual-key-attested";
+  }
+  return "legacy-wallet-signed";
+}
+async function signRelayBootstrapAuthorization(args) {
+  const payload = {
+    ownerAddress: args.ownerAddress,
+    publisherAddress: args.publisherAddress,
+    peerId: args.peerId,
+    registrationId: args.registrationId,
+    profile: args.profile,
+    version: args.version,
+    instanceItemHash: args.instanceItemHash,
+    issuedAt: args.issuedAt ?? Date.now(),
+    expiresAt: args.expiresAt
+  };
+  const serialized = serializeOwnerAuthorizationPayload(payload);
+  const signature = await args.signer(args.ownerAddress, serialized);
+  return {
+    scheme: RELAY_BOOTSTRAP_SIGNATURE_SCHEME,
+    payload,
+    signature: normalizeSignature(signature)
+  };
+}
+async function signRelayBootstrapProof(args) {
+  const payload = {
+    peerId: args.peerId,
+    multiaddrs: filterPublicMultiaddrs(args.multiaddrs),
+    browserMultiaddrs: args.browserMultiaddrs ? filterPublicMultiaddrs(args.browserMultiaddrs, {
+      browserDialableOnly: true
+    }) : void 0,
+    registrationId: args.registrationId,
+    profile: args.profile,
+    version: args.version,
+    updatedAt: args.updatedAt ?? Date.now()
+  };
+  const serialized = serializeRelayProofPayload(payload);
+  const signature = await args.signer(args.publisherAddress, serialized);
+  return {
+    scheme: RELAY_BOOTSTRAP_SIGNATURE_SCHEME,
+    payload,
+    signature: normalizeSignature(signature)
+  };
+}
+async function verifyRelayBootstrapAuthorization(authorization, options = {}) {
+  const errors = [];
+  if (!authorization) {
+    errors.push("Missing owner authorization.");
+    return { ok: false, errors };
+  }
+  if (authorization.scheme !== RELAY_BOOTSTRAP_SIGNATURE_SCHEME) {
+    errors.push(`Unsupported owner authorization scheme: ${authorization.scheme}`);
+    return { ok: false, errors };
+  }
+  const payload = authorization.payload;
+  const serialized = serializeOwnerAuthorizationPayload(payload);
+  try {
+    const recovered = await recoverAddressForSignature(
+      serialized,
+      authorization.signature
+    );
+    if (normalizeAddress(recovered) !== normalizeAddress(payload.ownerAddress)) {
+      errors.push("Owner authorization signature does not recover the owner address.");
+    }
+  } catch (error) {
+    errors.push(
+      `Owner authorization signature could not be recovered: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const now = options.now ?? Date.now();
+  if (payload.expiresAt != null && now > payload.expiresAt) {
+    errors.push("Owner authorization has expired.");
+  }
+  return { ok: errors.length === 0, errors };
+}
+async function verifyRelayBootstrapProof(proof, options = {}) {
+  const errors = [];
+  if (!proof) {
+    errors.push("Missing relay proof.");
+    return { ok: false, errors };
+  }
+  if (proof.scheme !== RELAY_BOOTSTRAP_SIGNATURE_SCHEME) {
+    errors.push(`Unsupported relay proof scheme: ${proof.scheme}`);
+    return { ok: false, errors };
+  }
+  const payload = proof.payload;
+  const serialized = serializeRelayProofPayload(payload);
+  try {
+    const recovered = await recoverAddressForSignature(serialized, proof.signature);
+    if (options.expectedPublisherAddress && normalizeAddress(recovered) !== normalizeAddress(options.expectedPublisherAddress)) {
+      errors.push("Relay proof signature does not recover the expected publisher address.");
+    }
+  } catch (error) {
+    errors.push(
+      `Relay proof signature could not be recovered: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (options.expectedPeerId && payload.peerId !== options.expectedPeerId) {
+    errors.push("Relay proof peer ID does not match the expected peer ID.");
+  }
+  return { ok: errors.length === 0, errors };
+}
+async function verifyRelayBootstrapDualKeyContent(content, options = {}) {
+  const errors = [];
+  if (!content) {
+    errors.push("Missing relay bootstrap content.");
+    return { ok: false, errors };
+  }
+  const authorization = await verifyRelayBootstrapAuthorization(
+    content.authorization,
+    options
+  );
+  errors.push(...authorization.errors);
+  const expectedPublisherAddress = content.publisherAddress ?? content.authorization?.payload.publisherAddress ?? void 0;
+  const proof = await verifyRelayBootstrapProof(content.relayProof, {
+    expectedPublisherAddress,
+    expectedPeerId: content.peerId
+  });
+  errors.push(...proof.errors);
+  if (content.ownerAddress && content.authorization) {
+    if (normalizeAddress(content.ownerAddress) !== normalizeAddress(content.authorization.payload.ownerAddress)) {
+      errors.push("Content ownerAddress does not match the owner authorization payload.");
+    }
+  }
+  if (expectedPublisherAddress && content.authorization) {
+    if (normalizeAddress(expectedPublisherAddress) !== normalizeAddress(content.authorization.payload.publisherAddress)) {
+      errors.push(
+        "Content publisherAddress does not match the owner authorization payload."
+      );
+    }
+  }
+  if (content.authorization && content.authorization.payload.peerId !== content.peerId) {
+    errors.push("Owner authorization peer ID does not match the bootstrap content peer ID.");
+  }
+  const proofPayload = content.relayProof?.payload;
+  if (proofPayload) {
+    if (proofPayload.registrationId !== content.registrationId) {
+      errors.push("Relay proof registrationId does not match the bootstrap content.");
+    }
+    if (proofPayload.profile !== content.profile) {
+      errors.push("Relay proof profile does not match the bootstrap content.");
+    }
+    if (proofPayload.version !== content.version) {
+      errors.push("Relay proof version does not match the bootstrap content.");
+    }
+    if (proofPayload.updatedAt !== content.updatedAt) {
+      errors.push("Relay proof updatedAt does not match the bootstrap content.");
+    }
+    if (JSON.stringify(dedupeMultiaddrs(proofPayload.multiaddrs)) !== JSON.stringify(dedupeMultiaddrs(content.multiaddrs))) {
+      errors.push("Relay proof multiaddrs do not match the bootstrap content.");
+    }
+    if (JSON.stringify(dedupeMultiaddrs(proofPayload.browserMultiaddrs ?? [])) !== JSON.stringify(dedupeMultiaddrs(content.browserMultiaddrs ?? []))) {
+      errors.push("Relay proof browserMultiaddrs do not match the bootstrap content.");
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
 async function fetchAlephBootstrapPosts(options = {}) {
   const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
   if (typeof fetchImpl !== "function") {
@@ -203,16 +476,104 @@ async function fetchAlephBootstrapPosts(options = {}) {
   const payload = await response.json();
   return (payload.posts ?? []).map((entry) => normalizeRelayBootstrapPostRecord(entry)).filter((entry) => entry != null);
 }
-async function discoverAlephBootstrapMultiaddrs(options = {}) {
-  const posts = await fetchAlephBootstrapPosts(options);
+function compareRelayBootstrapPostRecency(left, right) {
+  const leftUpdatedAt = left.content?.updatedAt ?? 0;
+  const rightUpdatedAt = right.content?.updatedAt ?? 0;
+  if (leftUpdatedAt !== rightUpdatedAt) return leftUpdatedAt - rightUpdatedAt;
+  const leftTime = left.time ?? 0;
+  const rightTime = right.time ?? 0;
+  return leftTime - rightTime;
+}
+function relayBootstrapRecordIdentity(post) {
+  const content = post.content;
+  if (!content) return null;
+  if (content.registrationId) return `registration:${content.registrationId}`;
+  if (post.address) return `sender:${normalizeAddress(post.address)}`;
+  return content.peerId ? `peer:${content.peerId}` : null;
+}
+function selectCurrentRelayBootstrapPosts(posts, options = {}) {
   const maxAgeMs = options.maxAgeMs ?? DEFAULT_BOOTSTRAP_MAX_AGE_MS;
-  const now = Date.now();
+  const now = options.now ?? Date.now();
+  const selected = /* @__PURE__ */ new Map();
+  for (const post of posts) {
+    const content = post.content;
+    if (!content) continue;
+    if (now - content.updatedAt > maxAgeMs) continue;
+    const identity = relayBootstrapRecordIdentity(post);
+    if (!identity) continue;
+    const previous = selected.get(identity);
+    if (!previous || compareRelayBootstrapPostRecency(post, previous) > 0) {
+      selected.set(identity, post);
+    }
+  }
+  return [...selected.values()].sort(
+    (left, right) => compareRelayBootstrapPostRecency(right, left)
+  );
+}
+async function filterTrustedRelayBootstrapPosts(posts, options = {}) {
+  const requireDualKeyAttestation = options.requireDualKeyAttestation ?? false;
+  const verifyDualKeyAttestation = options.verifyDualKeyAttestation ?? true;
+  const trusted = [];
+  for (const post of posts) {
+    const content = post.content;
+    if (!content) continue;
+    const trustMode = relayBootstrapTrustMode(content);
+    if (trustMode === "legacy-wallet-signed") {
+      if (!requireDualKeyAttestation) {
+        trusted.push(post);
+      }
+      continue;
+    }
+    if (!verifyDualKeyAttestation) {
+      trusted.push(post);
+      continue;
+    }
+    const verification = await verifyRelayBootstrapDualKeyContent(content);
+    if (verification.ok) {
+      trusted.push(post);
+    }
+  }
+  return trusted;
+}
+async function discoverAlephBootstrapMultiaddrs(options = {}) {
   const browserDialableOnly = options.browserDialableOnly ?? true;
+  const pagination = options.pagination ?? DEFAULT_BOOTSTRAP_PAGINATION;
+  const startPage = options.page ?? 1;
+  const maxPages = Math.max(1, options.maxPages ?? DEFAULT_BOOTSTRAP_MAX_PAGES);
+  const collectedPosts = [];
+  for (let offset = 0; offset < maxPages; offset += 1) {
+    const page = startPage + offset;
+    const pagePosts = await fetchAlephBootstrapPosts({
+      ...options,
+      page,
+      pagination
+    });
+    collectedPosts.push(...pagePosts);
+    const selectedPosts = selectCurrentRelayBootstrapPosts(collectedPosts, {
+      maxAgeMs: options.maxAgeMs
+    });
+    const trustedPosts = await filterTrustedRelayBootstrapPosts(selectedPosts, {
+      requireDualKeyAttestation: options.requireDualKeyAttestation,
+      verifyDualKeyAttestation: options.verifyDualKeyAttestation
+    });
+    const addrs = relayBootstrapPostsToMultiaddrs(
+      trustedPosts,
+      browserDialableOnly
+    );
+    if (addrs.length > 0) {
+      return addrs;
+    }
+    if (pagePosts.length < pagination) {
+      break;
+    }
+  }
+  return [];
+}
+function relayBootstrapPostsToMultiaddrs(posts, browserDialableOnly) {
   const addrs = [];
   for (const post of posts) {
     const content = post.content;
     if (!content) continue;
-    if (now - content.updatedAt > maxAgeMs) continue;
     const candidates = browserDialableOnly && Array.isArray(content.browserMultiaddrs) && content.browserMultiaddrs.length > 0 ? content.browserMultiaddrs : content.multiaddrs;
     addrs.push(
       ...filterPublicMultiaddrs(candidates, {
@@ -236,7 +597,9 @@ export {
   DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE,
   DEFAULT_ALEPH_BOOTSTRAP_REF,
   DEFAULT_BOOTSTRAP_MAX_AGE_MS,
+  DEFAULT_BOOTSTRAP_MAX_PAGES,
   DEFAULT_BOOTSTRAP_PAGINATION,
+  RELAY_BOOTSTRAP_SIGNATURE_SCHEME,
   buildRelayBootstrapPostContent,
   createLibp2pAlephBootstrap,
   createRelayBootstrapPost,
@@ -244,5 +607,12 @@ export {
   discoverAlephBootstrapMultiaddrs,
   fetchAlephBootstrapPosts,
   filterPublicMultiaddrs,
-  isPublicMultiaddr
+  isPublicMultiaddr,
+  relayBootstrapTrustMode,
+  selectCurrentRelayBootstrapPosts,
+  signRelayBootstrapAuthorization,
+  signRelayBootstrapProof,
+  verifyRelayBootstrapAuthorization,
+  verifyRelayBootstrapDualKeyContent,
+  verifyRelayBootstrapProof
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/aleph-bootstrap",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Aleph-backed libp2p bootstrap discovery and relay registration helpers.",
   "license": "MIT",
   "type": "module",
@@ -16,6 +16,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@libp2p/bootstrap": "^11.0.46"
+    "@libp2p/bootstrap": "^11.0.46",
+    "viem": "^2.38.5"
   }
 }