@le-space/rootfs 0.4.2 → 0.4.4

package/package.json

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

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

@@ -129,6 +129,21 @@ def signature_payload(chain: str, sender: str, message_type: str, item_hash: str
     return "\n".join([chain, sender, message_type, item_hash])
 
 
+def registration_id_instance_item_hash(registration_id: str | None) -> str | None:
+    normalized = str(registration_id or "").strip()
+    if not normalized:
+        return None
+
+    parts = [part.strip() for part in normalized.split(":") if part.strip()]
+    if not parts:
+        return None
+
+    candidate = parts[-1]
+    if len(candidate) == 64 and all(char in "0123456789abcdefABCDEF" for char in candidate):
+        return candidate
+    return None
+
+
 def relay_authorization_payload(
     owner_address: str,
     publisher_address: str,
@@ -136,6 +151,7 @@ def relay_authorization_payload(
     registration_id: str | None,
     profile: str | None,
     version: str | None,
+    instance_item_hash: str | None,
     issued_at: int,
 ) -> dict[str, object]:
     return {
@@ -145,7 +161,7 @@ def relay_authorization_payload(
         "registrationId": registration_id,
         "profile": profile,
         "version": version,
-        "instanceItemHash": None,
+        "instanceItemHash": instance_item_hash,
         "issuedAt": issued_at,
         "expiresAt": None,
     }
@@ -194,6 +210,7 @@ def load_owner_authorization(
         return None
 
     owner_address = address_from_private_key(owner_private_key)
+    instance_item_hash = registration_id_instance_item_hash(registration_id)
     payload = relay_authorization_payload(
         owner_address,
         publisher_address,
@@ -201,6 +218,7 @@ def load_owner_authorization(
         registration_id,
         profile,
         version,
+        instance_item_hash,
         issued_at,
     )
     return {
@@ -210,6 +228,28 @@ def load_owner_authorization(
     }
 
 
+def resolve_owner_address(
+    env_values: dict[str, str],
+    owner_authorization: dict[str, object] | None,
+) -> str | None:
+    if isinstance(owner_authorization, dict):
+        payload = owner_authorization.get("payload")
+        if isinstance(payload, dict):
+            owner_address = str(payload.get("ownerAddress") or "").strip()
+            if owner_address:
+                return owner_address
+
+    owner_address = env_values.get("ALEPH_BOOTSTRAP_OWNER_ADDRESS", "").strip()
+    if owner_address:
+        return owner_address
+
+    owner_private_key = env_values.get("ALEPH_BOOTSTRAP_OWNER_PRIVATE_KEY", "").strip()
+    if owner_private_key:
+        return address_from_private_key(owner_private_key)
+
+    return None
+
+
 def post_json(url: str, body: dict[str, object]) -> tuple[int, dict]:
     data = json_dumps(body).encode("utf-8")
     request = urllib.request.Request(
@@ -243,6 +283,7 @@ def build_post_content(
     registration_id: str | None,
     profile: str | None,
     version: str | None,
+    owner_address: str | None,
     owner_authorization: dict[str, object] | None,
     relay_proof: dict[str, object],
     now_ms: int,
@@ -256,11 +297,7 @@ def build_post_content(
         "registrationId": registration_id,
         "profile": profile,
         "version": version,
-        "ownerAddress": (
-            owner_authorization.get("payload", {}).get("ownerAddress")
-            if isinstance(owner_authorization, dict)
-            else None
-        ),
+        "ownerAddress": owner_address,
         "publisherAddress": sender,
         "authorization": owner_authorization,
         "relayProof": relay_proof,
@@ -508,6 +545,7 @@ def main() -> None:
         version,
         now_ms,
     )
+    owner_address = resolve_owner_address(env_values, owner_authorization)
 
     proof_payload = relay_proof_payload(
         peer_id,
@@ -531,6 +569,7 @@ def main() -> None:
         registration_id,
         profile,
         version,
+        owner_address,
         owner_authorization,
         relay_proof,
         now_ms,

package/reference/uc-go-peer/rootfs/uc-go-peer-configure.sh

@@ -26,6 +26,7 @@ UDP_PORT=""
 BOOTSTRAP_PUBLISHER_PRIVATE_KEY=""
 BOOTSTRAP_PUBLISHER_LIBP2P_IDENTITY_B64=""
 BOOTSTRAP_OWNER_PRIVATE_KEY=""
+BOOTSTRAP_OWNER_ADDRESS=""
 BOOTSTRAP_OWNER_AUTHORIZATION_B64=""
 BOOTSTRAP_REGISTRATION_ID=""
 START_SERVICE=1
@@ -46,6 +47,7 @@ Usage:
     [--bootstrap-publisher-private-key <hex>] \
     [--bootstrap-publisher-libp2p-identity-b64 <base64>] \
     [--bootstrap-owner-private-key <hex>] \
+    [--bootstrap-owner-address <address>] \
     [--bootstrap-owner-authorization-b64 <base64>] \
     [--bootstrap-registration-id <id>] \
     [--no-start]
@@ -169,6 +171,10 @@ while [ "$#" -gt 0 ]; do
       BOOTSTRAP_OWNER_PRIVATE_KEY="${2:-}"
       shift 2
       ;;
+    --bootstrap-owner-address)
+      BOOTSTRAP_OWNER_ADDRESS="${2:-}"
+      shift 2
+      ;;
     --bootstrap-owner-authorization-b64)
       BOOTSTRAP_OWNER_AUTHORIZATION_B64="${2:-}"
       shift 2
@@ -275,6 +281,7 @@ fi
 if [ -n "${BOOTSTRAP_OWNER_PRIVATE_KEY}" ]; then
   write_env_var "ALEPH_BOOTSTRAP_OWNER_PRIVATE_KEY" "${BOOTSTRAP_OWNER_PRIVATE_KEY}"
 fi
+write_env_var "ALEPH_BOOTSTRAP_OWNER_ADDRESS" "${BOOTSTRAP_OWNER_ADDRESS}"
 if [ -n "${BOOTSTRAP_OWNER_AUTHORIZATION_B64}" ]; then
   write_env_var "ALEPH_BOOTSTRAP_OWNER_AUTHORIZATION_B64" "${BOOTSTRAP_OWNER_AUTHORIZATION_B64}"
 fi

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

@@ -164,6 +164,9 @@ def _build_configure_args(record: dict) -> list[str]:
     registration_id = str(bootstrap.get("registrationId") or "").strip()
     if registration_id:
         args.extend(["--bootstrap-registration-id", registration_id])
+    owner_address = str(record.get("ownerAddress") or "").strip()
+    if owner_address:
+        args.extend(["--bootstrap-owner-address", owner_address])
     owner_auth = str(bootstrap.get("ownerAuthorizationBase64") or "").strip()
     if owner_auth:
         args.extend(["--bootstrap-owner-authorization-b64", owner_auth])
@@ -516,6 +519,7 @@ class Handler(BaseHTTPRequestHandler):
                 "bootstrap_publisher_libp2p_identity_b64"
             )
             bootstrap_owner_private_key = payload.get("bootstrap_owner_private_key")
+            bootstrap_owner_address = payload.get("bootstrap_owner_address")
             bootstrap_owner_authorization_b64 = payload.get("bootstrap_owner_authorization_b64")
             bootstrap_registration_id = payload.get("bootstrap_registration_id")
             no_start = bool(payload.get("no_start"))
@@ -548,6 +552,8 @@ class Handler(BaseHTTPRequestHandler):
                 )
             if bootstrap_owner_private_key is not None:
                 args.extend(["--bootstrap-owner-private-key", str(bootstrap_owner_private_key)])
+            if bootstrap_owner_address is not None:
+                args.extend(["--bootstrap-owner-address", str(bootstrap_owner_address)])
             if bootstrap_owner_authorization_b64 is not None:
                 args.extend(
                     ["--bootstrap-owner-authorization-b64", str(bootstrap_owner_authorization_b64)]