@le-space/rootfs 0.3.26 → 0.3.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/rootfs",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "description": "Shared rootfs contract parsing, reference profile assets, and build helpers.",
   "license": "MIT",
   "type": "module",

package/reference/orbitdb-relay-pinner/rootfs/orbitdb-relay-pinner-bootstrap-refresh.py

@@ -306,19 +306,22 @@ def sign_aleph_message(unsigned_message: dict[str, object], private_key: str) ->
 
 def broadcast_aleph_message(api_host: str, message: dict[str, object]) -> tuple[int, dict]:
     url = urllib.parse.urljoin(api_host.rstrip("/") + "/", "api/v0/messages")
-    attempts = [
-        {"sync": True, "message": message},
-        {**message, "sync": True},
-        dict(message),
-    ]
+    request_body = {"sync": True, "message": message}
+    max_attempts = 3
     last: tuple[int, dict] | None = None
-    for attempt in attempts:
-        last = post_json(url, attempt)
+    for index in range(max_attempts):
+        last = post_json(url, request_body)
         if 200 <= last[0] < 300:
             return last
-    if last is None:
-        raise RuntimeError("Aleph broadcast failed before any attempt was made")
-    raise RuntimeError(f"Aleph broadcast failed: {last[0]} {json_dumps(last[1])}")
+        publication_status = last[1].get("publication_status") if isinstance(last[1], dict) else None
+        retryable = last[0] >= 500 or (
+            isinstance(publication_status, dict)
+            and isinstance(publication_status.get("status"), str)
+            and publication_status.get("status").strip().lower() == "error"
+        )
+        if index >= max_attempts - 1 or not retryable:
+            raise RuntimeError(f"Aleph broadcast failed: {last[0]} {json_dumps(last[1])}")
+    raise RuntimeError("Aleph broadcast failed: retry budget exhausted")
 
 
 def parse_post_record(entry: object) -> dict[str, object] | None:

package/reference/uc-go-peer/rootfs/uc-go-peer-bootstrap-deregister.py

@@ -155,22 +155,16 @@ def is_retryable_broadcast_failure(http_status: int, payload: object) -> bool:
 
 def broadcast_aleph_message(api_host: str, message: dict[str, object]) -> tuple[int, object]:
     url = urllib.parse.urljoin(api_host.rstrip("/") + "/", "api/v0/messages")
-    attempts = [
-        {"sync": True, "message": message},
-        {**message, "sync": True},
-        dict(message),
-    ]
-    for index, attempt in enumerate(attempts):
-        http_status, payload = post_json(url, attempt)
+    request_body = {"sync": True, "message": message}
+    max_attempts = 3
+    for index in range(max_attempts):
+        http_status, payload = post_json(url, request_body)
         if 200 <= http_status < 300:
             return http_status, payload
-        can_retry = index < len(attempts) - 1 and (
-            is_invalid_message_format(http_status, payload)
-            or is_retryable_broadcast_failure(http_status, payload)
-        )
+        can_retry = index < max_attempts - 1 and is_retryable_broadcast_failure(http_status, payload)
         if not can_retry:
             raise RuntimeError(f"Aleph broadcast failed: {http_status} {json_dumps(payload)}")
-    raise RuntimeError("Aleph broadcast failed: no compatible request format was accepted")
+    raise RuntimeError("Aleph broadcast failed: retry budget exhausted")
 
 
 def parse_post_record(entry: object) -> dict[str, object] | None:

package/reference/uc-go-peer/rootfs/uc-go-peer-bootstrap-refresh.py

@@ -246,13 +246,13 @@ def build_post_content(
     owner_authorization: dict[str, object] | None,
     relay_proof: dict[str, object],
     now_ms: int,
+    now_seconds: float,
     ref: str,
     post_type: str,
 ) -> dict[str, object]:
     content = {
         "peerId": peer_id,
         "multiaddrs": multiaddrs,
-        "browserMultiaddrs": browser_multiaddrs if browser_multiaddrs else None,
         "registrationId": registration_id,
         "profile": profile,
         "version": version,
@@ -266,12 +266,14 @@ def build_post_content(
         "relayProof": relay_proof,
         "updatedAt": now_ms,
     }
+    if browser_multiaddrs:
+        content["browserMultiaddrs"] = browser_multiaddrs
     return {
         "type": post_type,
         "address": sender,
         "ref": ref,
         "content": content,
-        "time": now_ms,
+        "time": now_seconds,
     }
 
 
@@ -347,22 +349,16 @@ def is_retryable_broadcast_failure(http_status: int, payload: object) -> bool:
 
 def broadcast_aleph_message(api_host: str, message: dict[str, object]) -> tuple[int, object]:
     url = urllib.parse.urljoin(api_host.rstrip("/") + "/", "api/v0/messages")
-    attempts = [
-        {"sync": True, "message": message},
-        {**message, "sync": True},
-        dict(message),
-    ]
-    for index, attempt in enumerate(attempts):
-        http_status, payload = post_json(url, attempt)
+    request_body = {"sync": True, "message": message}
+    max_attempts = 3
+    for index in range(max_attempts):
+        http_status, payload = post_json(url, request_body)
         if 200 <= http_status < 300:
             return http_status, payload
-        can_retry = index < len(attempts) - 1 and (
-            is_invalid_message_format(http_status, payload)
-            or is_retryable_broadcast_failure(http_status, payload)
-        )
+        can_retry = index < max_attempts - 1 and is_retryable_broadcast_failure(http_status, payload)
         if not can_retry:
             raise RuntimeError(f"Aleph broadcast failed: {http_status} {json_dumps(payload)}")
-    raise RuntimeError("Aleph broadcast failed: no compatible request format was accepted")
+    raise RuntimeError("Aleph broadcast failed: retry budget exhausted")
 
 
 def parse_post_record(entry: object) -> dict[str, object] | None:
@@ -538,6 +534,7 @@ def main() -> None:
         owner_authorization,
         relay_proof,
         now_ms,
+        now_seconds,
         ref,
         post_type,
     )

package/reference/uc-go-peer/rootfs/uc-go-peer-setup-server.py

@@ -284,24 +284,18 @@ def _post_json(url: str, body: dict[str, object]) -> tuple[int, object]:
 
 def _broadcast_aleph_message(api_host: str, message: dict[str, object]) -> tuple[int, object]:
     url = f"{api_host.rstrip('/')}/api/v0/messages"
-    attempts = [
-        {"sync": True, "message": message},
-        {**message, "sync": True},
-        dict(message),
-    ]
-    for index, attempt in enumerate(attempts):
-        http_status, payload = _post_json(url, attempt)
+    request_body = {"sync": True, "message": message}
+    max_attempts = 3
+    for index in range(max_attempts):
+        http_status, payload = _post_json(url, request_body)
         if 200 <= http_status < 300:
             return http_status, payload
-        can_retry = index < len(attempts) - 1 and (
-            _is_invalid_message_format(http_status, payload)
-            or _is_retryable_broadcast_failure(http_status, payload)
-        )
+        can_retry = index < max_attempts - 1 and _is_retryable_broadcast_failure(http_status, payload)
         if not can_retry:
             raise RuntimeError(
                 f"Aleph bootstrap status broadcast failed: {http_status} {_json_dumps(payload)}"
             )
-    raise RuntimeError("Aleph bootstrap status broadcast failed: no compatible request format was accepted")
+    raise RuntimeError("Aleph bootstrap status broadcast failed: retry budget exhausted")
 
 
 def _publish_vm_bootstrap_config_signal(record: dict) -> None: