@le-space/aleph-bootstrap 0.6.3 → 0.6.5

package/index.d.ts

@@ -4,9 +4,11 @@ declare const DEFAULT_ALEPH_API_HOST = "https://api.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_ALEPH_BOOTSTRAP_COMPACT_POST_TYPE = "relay-bootstrap-v2";
 declare const DEFAULT_BOOTSTRAP_MAX_AGE_MS: number;
 declare const DEFAULT_BOOTSTRAP_PAGINATION = 50;
 declare const DEFAULT_BOOTSTRAP_MAX_PAGES = 5;
+declare const DEFAULT_BOOTSTRAP_COMPACT_MULTIADDR_LIMIT = 3;
 declare const RELAY_BOOTSTRAP_SIGNATURE_SCHEME = "personal_sign";
 interface RelayBootstrapAuthorizationPayload {
     ownerAddress: string;
@@ -26,8 +28,10 @@ interface RelayBootstrapAuthorizationRecord {
 }
 interface RelayBootstrapProofPayload {
     peerId: string;
-    multiaddrs: string[];
+    multiaddrs?: string[];
     browserMultiaddrs?: string[];
+    multiaddrsHash?: string;
+    browserMultiaddrsHash?: string;
     registrationId?: string;
     profile?: string;
     version?: string;
@@ -77,10 +81,12 @@ interface DiscoverAlephBootstrapOptions {
     channel?: string;
     ref?: string;
     postType?: string;
+    postTypes?: string[];
     page?: number;
     pagination?: number;
     maxPages?: number;
     maxAgeMs?: number;
+    compactMultiaddrLimit?: number;
     browserDialableOnly?: boolean;
     requireDualKeyAttestation?: boolean;
     verifyDualKeyAttestation?: boolean;
@@ -105,10 +111,14 @@ interface CreateRelayBootstrapPostOptions {
     publisherAddress?: string;
     authorization?: RelayBootstrapAuthorizationRecord;
     relayProof?: RelayBootstrapProofRecord;
+    compact?: boolean;
+    compactMultiaddrLimit?: number;
     now?: number;
     hasher: (payload: string) => Promise<string> | string;
 }
 type RelayBootstrapTrustMode = "legacy-wallet-signed" | "dual-key-attested";
+declare function relayBootstrapMultiaddrsHash(addrs: readonly string[]): string;
+declare function selectCompactRelayBootstrapMultiaddrs(addrs: readonly string[], limit?: number): string[];
 declare function dedupeMultiaddrs(addrs: readonly string[]): string[];
 declare function isPublicMultiaddr(addr: string): boolean;
 declare function filterPublicMultiaddrs(addrs: readonly string[], options?: FilterPublicMultiaddrsOptions): string[];
@@ -126,6 +136,8 @@ declare function buildRelayBootstrapPostContent(args: {
     publisherAddress?: string;
     authorization?: RelayBootstrapAuthorizationRecord;
     relayProof?: RelayBootstrapProofRecord;
+    compact?: boolean;
+    compactMultiaddrLimit?: number;
     now?: number;
 }): RelayBootstrapPostContent;
 declare function createRelayBootstrapPost(args: CreateRelayBootstrapPostOptions): Promise<{
@@ -160,6 +172,8 @@ declare function signRelayBootstrapProof(args: {
     profile?: string;
     version?: string;
     updatedAt?: number;
+    compact?: boolean;
+    compactMultiaddrLimit?: number;
     signer: RelayBootstrapProofSigner;
 }): Promise<RelayBootstrapProofRecord>;
 declare function verifyRelayBootstrapAuthorization(authorization: RelayBootstrapAuthorizationRecord | null | undefined, options?: {
@@ -182,4 +196,4 @@ declare function createLibp2pAlephBootstrap(options?: DiscoverAlephBootstrapOpti
     tagName?: string;
 }): 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_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 };
+export { type CreateRelayBootstrapPostOptions, DEFAULT_ALEPH_API_HOST, DEFAULT_ALEPH_BOOTSTRAP_CHANNEL, DEFAULT_ALEPH_BOOTSTRAP_COMPACT_POST_TYPE, DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE, DEFAULT_ALEPH_BOOTSTRAP_REF, DEFAULT_BOOTSTRAP_COMPACT_MULTIADDR_LIMIT, 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, relayBootstrapMultiaddrsHash, relayBootstrapTrustMode, selectCompactRelayBootstrapMultiaddrs, selectCurrentRelayBootstrapPosts, signRelayBootstrapAuthorization, signRelayBootstrapProof, verifyRelayBootstrapAuthorization, verifyRelayBootstrapDualKeyContent, verifyRelayBootstrapProof };

package/index.js

@@ -1,13 +1,15 @@
 // src/index.ts
 import { bootstrap } from "@libp2p/bootstrap";
-import { recoverMessageAddress } from "viem";
+import { keccak256, recoverMessageAddress, stringToHex } from "viem";
 var DEFAULT_ALEPH_API_HOST = "https://api.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_ALEPH_BOOTSTRAP_COMPACT_POST_TYPE = "relay-bootstrap-v2";
 var DEFAULT_BOOTSTRAP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var DEFAULT_BOOTSTRAP_PAGINATION = 50;
 var DEFAULT_BOOTSTRAP_MAX_PAGES = 5;
+var DEFAULT_BOOTSTRAP_COMPACT_MULTIADDR_LIMIT = 3;
 var RELAY_BOOTSTRAP_SIGNATURE_SCHEME = "personal_sign";
 function serializeOwnerAuthorizationPayload(payload) {
   return JSON.stringify({
@@ -25,14 +27,41 @@ function serializeOwnerAuthorizationPayload(payload) {
 function serializeRelayProofPayload(payload) {
   return JSON.stringify({
     peerId: payload.peerId,
-    multiaddrs: dedupeMultiaddrs(payload.multiaddrs),
+    multiaddrs: payload.multiaddrs ? dedupeMultiaddrs(payload.multiaddrs) : void 0,
     browserMultiaddrs: payload.browserMultiaddrs ? dedupeMultiaddrs(payload.browserMultiaddrs) : void 0,
+    multiaddrsHash: payload.multiaddrsHash,
+    browserMultiaddrsHash: payload.browserMultiaddrsHash,
     registrationId: payload.registrationId,
     profile: payload.profile,
     version: payload.version,
     updatedAt: payload.updatedAt
   });
 }
+function relayBootstrapMultiaddrsHash(addrs) {
+  return keccak256(stringToHex(JSON.stringify(dedupeMultiaddrs(addrs))));
+}
+function compactPostType(postType) {
+  return (postType ?? DEFAULT_ALEPH_BOOTSTRAP_COMPACT_POST_TYPE) === DEFAULT_ALEPH_BOOTSTRAP_COMPACT_POST_TYPE;
+}
+function browserMultiaddrPreference(addr) {
+  const normalized = addr.toLowerCase();
+  if (normalized.includes("/tcp/443/tls/ws/")) return 0;
+  if (normalized.includes("/tls/ws/")) return 1;
+  if (normalized.includes("/webtransport/")) return 2;
+  if (normalized.includes("/webrtc-direct/")) return 3;
+  if (normalized.includes("/ws")) return 4;
+  return 5;
+}
+function selectCompactRelayBootstrapMultiaddrs(addrs, limit = DEFAULT_BOOTSTRAP_COMPACT_MULTIADDR_LIMIT) {
+  const entries = filterPublicMultiaddrs(addrs, {
+    browserDialableOnly: true
+  }).map((addr, index) => ({ addr, index }));
+  entries.sort((left, right) => {
+    const preference = browserMultiaddrPreference(left.addr) - browserMultiaddrPreference(right.addr);
+    return preference !== 0 ? preference : left.index - right.index;
+  });
+  return entries.map((entry) => entry.addr).slice(0, Math.max(1, Math.floor(limit)));
+}
 async function recoverAddressForSignature(payload, signature) {
   return recoverMessageAddress({
     message: payload,
@@ -194,8 +223,10 @@ function normalizeRelayBootstrapProofPayload(value) {
   const browserMultiaddrs = Array.isArray(payload.browserMultiaddrs) ? payload.browserMultiaddrs.filter((entry) => typeof entry === "string") : void 0;
   return {
     peerId,
-    multiaddrs: dedupeMultiaddrs(multiaddrs),
+    multiaddrs: multiaddrs.length > 0 ? dedupeMultiaddrs(multiaddrs) : void 0,
     browserMultiaddrs: browserMultiaddrs ? dedupeMultiaddrs(browserMultiaddrs) : void 0,
+    multiaddrsHash: asTrimmedString(payload.multiaddrsHash) ?? void 0,
+    browserMultiaddrsHash: asTrimmedString(payload.browserMultiaddrsHash) ?? void 0,
     registrationId: asTrimmedString(payload.registrationId) ?? void 0,
     profile: asTrimmedString(payload.profile) ?? void 0,
     version: asTrimmedString(payload.version) ?? void 0,
@@ -227,16 +258,24 @@ function normalizeRelayBootstrapPostRecord(value) {
 function buildRelayBootstrapPostContent(args) {
   const now = args.now ?? Date.now() / 1e3;
   const updatedAt = args.now ?? Date.now();
+  const postType = args.postType ?? DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE;
+  const compact = args.compact ?? compactPostType(postType);
+  const fullMultiaddrs = filterPublicMultiaddrs(args.multiaddrs);
+  const fullBrowserMultiaddrs = args.browserMultiaddrs ? filterPublicMultiaddrs(args.browserMultiaddrs, {
+    browserDialableOnly: true
+  }) : void 0;
+  const compactMultiaddrs = selectCompactRelayBootstrapMultiaddrs(
+    fullBrowserMultiaddrs && fullBrowserMultiaddrs.length > 0 ? fullBrowserMultiaddrs : fullMultiaddrs,
+    args.compactMultiaddrLimit
+  );
   return {
-    type: args.postType ?? DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE,
+    type: postType,
     address: args.sender,
     ...args.ref ? { ref: args.ref } : {},
     content: {
       peerId: args.peerId,
-      multiaddrs: filterPublicMultiaddrs(args.multiaddrs),
-      browserMultiaddrs: args.browserMultiaddrs ? filterPublicMultiaddrs(args.browserMultiaddrs, {
-        browserDialableOnly: true
-      }) : void 0,
+      multiaddrs: compact ? compactMultiaddrs : fullMultiaddrs,
+      browserMultiaddrs: compact ? void 0 : fullBrowserMultiaddrs,
       registrationId: args.registrationId,
       profile: args.profile,
       version: args.version,
@@ -266,6 +305,8 @@ async function createRelayBootstrapPost(args) {
     publisherAddress: args.publisherAddress,
     authorization: args.authorization,
     relayProof: args.relayProof,
+    compact: args.compact,
+    compactMultiaddrLimit: args.compactMultiaddrLimit,
     now: nowMillis
   });
   itemContent.time = nowSeconds;
@@ -309,12 +350,20 @@ async function signRelayBootstrapAuthorization(args) {
   };
 }
 async function signRelayBootstrapProof(args) {
+  const fullMultiaddrs = filterPublicMultiaddrs(args.multiaddrs);
+  const fullBrowserMultiaddrs = args.browserMultiaddrs ? filterPublicMultiaddrs(args.browserMultiaddrs, {
+    browserDialableOnly: true
+  }) : void 0;
+  const compactMultiaddrs = selectCompactRelayBootstrapMultiaddrs(
+    fullBrowserMultiaddrs && fullBrowserMultiaddrs.length > 0 ? fullBrowserMultiaddrs : fullMultiaddrs,
+    args.compactMultiaddrLimit
+  );
+  const compact = args.compact ?? false;
   const payload = {
     peerId: args.peerId,
-    multiaddrs: filterPublicMultiaddrs(args.multiaddrs),
-    browserMultiaddrs: args.browserMultiaddrs ? filterPublicMultiaddrs(args.browserMultiaddrs, {
-      browserDialableOnly: true
-    }) : void 0,
+    multiaddrs: compact ? void 0 : fullMultiaddrs,
+    browserMultiaddrs: compact ? void 0 : fullBrowserMultiaddrs,
+    multiaddrsHash: compact ? relayBootstrapMultiaddrsHash(compactMultiaddrs) : void 0,
     registrationId: args.registrationId,
     profile: args.profile,
     version: args.version,
@@ -432,11 +481,23 @@ async function verifyRelayBootstrapDualKeyContent(content, options = {}) {
     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))) {
+    if (proofPayload.multiaddrsHash) {
+      if (proofPayload.multiaddrsHash !== relayBootstrapMultiaddrsHash(content.multiaddrs)) {
+        errors.push("Relay proof multiaddrs hash does not match the bootstrap content.");
+      }
+    } else 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.");
+    if (proofPayload.browserMultiaddrsHash) {
+      if (proofPayload.browserMultiaddrsHash !== relayBootstrapMultiaddrsHash(content.browserMultiaddrs ?? [])) {
+        errors.push(
+          "Relay proof browserMultiaddrs hash does not match the bootstrap content."
+        );
+      }
+    } else if (proofPayload.browserMultiaddrs || content.browserMultiaddrs) {
+      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 };
@@ -474,7 +535,7 @@ async function fetchAlephBootstrapPosts(options = {}) {
     throw new Error(`Aleph bootstrap post lookup failed: ${response.status}`);
   }
   const payload = await response.json();
-  return (payload.posts ?? []).map((entry) => normalizeRelayBootstrapPostRecord(entry)).filter((entry) => entry != null);
+  return (payload.posts ?? []).map((entry) => normalizeRelayBootstrapPostRecord(entry)).filter((entry) => entry != null).sort((left, right) => compareRelayBootstrapPostRecency(right, left));
 }
 function compareRelayBootstrapPostRecency(left, right) {
   const leftUpdatedAt = left.content?.updatedAt ?? 0;
@@ -540,31 +601,38 @@ async function discoverAlephBootstrapMultiaddrs(options = {}) {
   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;
+  const postTypes = options.postType != null ? [options.postType] : options.postTypes && options.postTypes.length > 0 ? options.postTypes : [
+    DEFAULT_ALEPH_BOOTSTRAP_COMPACT_POST_TYPE,
+    DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE
+  ];
+  for (const postType of postTypes) {
+    const collectedPosts = [];
+    for (let offset = 0; offset < maxPages; offset += 1) {
+      const page = startPage + offset;
+      const pagePosts = await fetchAlephBootstrapPosts({
+        ...options,
+        postType,
+        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 [];
@@ -594,8 +662,10 @@ async function createLibp2pAlephBootstrap(options = {}) {
 export {
   DEFAULT_ALEPH_API_HOST,
   DEFAULT_ALEPH_BOOTSTRAP_CHANNEL,
+  DEFAULT_ALEPH_BOOTSTRAP_COMPACT_POST_TYPE,
   DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE,
   DEFAULT_ALEPH_BOOTSTRAP_REF,
+  DEFAULT_BOOTSTRAP_COMPACT_MULTIADDR_LIMIT,
   DEFAULT_BOOTSTRAP_MAX_AGE_MS,
   DEFAULT_BOOTSTRAP_MAX_PAGES,
   DEFAULT_BOOTSTRAP_PAGINATION,
@@ -608,7 +678,9 @@ export {
   fetchAlephBootstrapPosts,
   filterPublicMultiaddrs,
   isPublicMultiaddr,
+  relayBootstrapMultiaddrsHash,
   relayBootstrapTrustMode,
+  selectCompactRelayBootstrapMultiaddrs,
   selectCurrentRelayBootstrapPosts,
   signRelayBootstrapAuthorization,
   signRelayBootstrapProof,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/aleph-bootstrap",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Aleph-backed libp2p bootstrap discovery and relay registration helpers.",
   "license": "MIT",
   "type": "module",
@@ -25,6 +25,6 @@
   },
   "dependencies": {
     "@libp2p/bootstrap": "^11.0.46",
-    "viem": "^2.38.5"
+    "viem": "^2.53.1"
   }
 }