@le-space/node 0.1.14 → 0.1.16

package/index.d.ts

@@ -160,6 +160,26 @@ interface JsonFetchLikeResponse {
 }
 type JsonFetchLike = (url: string, init?: RequestInit) => Promise<JsonFetchLikeResponse>;
 
+declare function forgetAlephMessages(args: {
+    sender: string;
+    hashes?: string[];
+    aggregates?: string[];
+    reason?: string;
+    signer: MessageSigner;
+    hasher: MessageHasher;
+    fetch: JsonFetchLike;
+    channel?: string;
+    apiHost?: string;
+    sync?: boolean;
+    now?: number;
+}): Promise<{
+    sender: string;
+    itemHash: string;
+    response: _shared_aleph_shared_types.AlephBroadcastResponse;
+    httpStatus: number;
+    status: _shared_aleph_shared_types.MessageStatus;
+}>;
+
 interface RetentionRecord {
     instance_item_hash: string;
     rootfs_item_hash: string;
@@ -197,6 +217,9 @@ declare function retainSuccessfulDeployments(args: {
     retainedRecords: RetentionRecord[];
     prunedRecords: RetentionRecord[];
     forgetHashes: string[];
+    forgottenHashes: string[];
+    outstandingForgetHashes: string[];
+    forgetStatuses: Record<string, string>;
     forgetResult: {
         sender: string;
         itemHash: string;
@@ -204,6 +227,10 @@ declare function retainSuccessfulDeployments(args: {
         httpStatus: number;
         status: _shared_aleph_shared_types.MessageStatus;
     } | null;
+    followUpForgetResults: {
+        hash: string;
+        result: Awaited<ReturnType<typeof forgetAlephMessages>>;
+    }[];
 }>;
 
 declare function buildScaffoldDeployResult(env?: NodeJS.ProcessEnv): DeployOutputResult;

package/index.js

@@ -948,6 +948,31 @@ async function publishAggregateKey(args) {
     httpStatus
   };
 }
+async function fetchMessageStatus(args) {
+  const requestUrl = new URL(`/api/v0/messages/${args.hash}`, args.apiHost ?? "https://api2.aleph.im");
+  const response = await args.fetch(requestUrl.toString(), { cache: "no-cache" });
+  if (response.status === 404) return "missing";
+  if (!response.ok) return "unknown";
+  const payload = await response.json();
+  return asString3(payload?.status) ?? "unknown";
+}
+async function classifyForgetHashes(args) {
+  const statuses = {};
+  for (const hash of args.hashes) {
+    statuses[hash] = await fetchMessageStatus({
+      hash,
+      fetch: args.fetch,
+      apiHost: args.apiHost
+    });
+  }
+  const forgottenHashes = args.hashes.filter((hash) => statuses[hash] === "forgotten");
+  const outstandingForgetHashes = args.hashes.filter((hash) => statuses[hash] !== "forgotten");
+  return {
+    forgottenHashes,
+    outstandingForgetHashes,
+    statuses
+  };
+}
 async function retainSuccessfulDeployments(args) {
   const keepCount = Math.max(0, Number.parseInt(String(args.keepCount ?? 0), 10) || 0);
   const aggregateKey = asString3(args.aggregateKey) ?? SUCCESSFUL_DEPLOYMENTS_AGGREGATE_KEY;
@@ -995,18 +1020,64 @@ async function retainSuccessfulDeployments(args) {
     now: args.now
   });
   let forgetResult = null;
+  let followUpForgetResults = [];
+  let forgottenHashes = [];
+  let outstandingForgetHashes = [];
+  let forgetStatuses = {};
   if (forgetHashes.length > 0) {
-    forgetResult = await forgetAlephMessages({
-      sender: args.sender,
+    const initiallyOutstanding = await classifyForgetHashes({
       hashes: forgetHashes,
-      reason: args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`,
-      signer: args.signer,
-      hasher: args.hasher,
       fetch: args.fetch,
-      channel: args.channel,
-      apiHost: args.apiHost,
-      now: args.now
+      apiHost: args.apiHost
     });
+    forgottenHashes = initiallyOutstanding.forgottenHashes;
+    outstandingForgetHashes = initiallyOutstanding.outstandingForgetHashes;
+    forgetStatuses = initiallyOutstanding.statuses;
+    if (outstandingForgetHashes.length > 0) {
+      forgetResult = await forgetAlephMessages({
+        sender: args.sender,
+        hashes: outstandingForgetHashes,
+        reason: args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`,
+        signer: args.signer,
+        hasher: args.hasher,
+        fetch: args.fetch,
+        channel: args.channel,
+        apiHost: args.apiHost,
+        now: args.now
+      });
+      let postBatch = await classifyForgetHashes({
+        hashes: forgetHashes,
+        fetch: args.fetch,
+        apiHost: args.apiHost
+      });
+      forgottenHashes = postBatch.forgottenHashes;
+      outstandingForgetHashes = postBatch.outstandingForgetHashes;
+      forgetStatuses = postBatch.statuses;
+      if (outstandingForgetHashes.length > 0) {
+        for (const hash of outstandingForgetHashes) {
+          const result = await forgetAlephMessages({
+            sender: args.sender,
+            hashes: [hash],
+            reason: args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`,
+            signer: args.signer,
+            hasher: args.hasher,
+            fetch: args.fetch,
+            channel: args.channel,
+            apiHost: args.apiHost,
+            now: args.now
+          });
+          followUpForgetResults.push({ hash, result });
+        }
+        postBatch = await classifyForgetHashes({
+          hashes: forgetHashes,
+          fetch: args.fetch,
+          apiHost: args.apiHost
+        });
+        forgottenHashes = postBatch.forgottenHashes;
+        outstandingForgetHashes = postBatch.outstandingForgetHashes;
+        forgetStatuses = postBatch.statuses;
+      }
+    }
   }
   return {
     sender: args.sender,
@@ -1016,7 +1087,11 @@ async function retainSuccessfulDeployments(args) {
     retainedRecords,
     prunedRecords,
     forgetHashes,
-    forgetResult
+    forgottenHashes,
+    outstandingForgetHashes,
+    forgetStatuses,
+    forgetResult,
+    followUpForgetResults
   };
 }
 
@@ -2098,7 +2173,8 @@ async function runActionMode(env = process.env, hooks = {}) {
       `- Keep count: \`${payload.keepCount}\``,
       `- Retained deployments: \`${payload.retainedRecords?.length ?? 0}\``,
       `- Pruned deployments: \`${payload.prunedRecords?.length ?? 0}\``,
-      `- Forgotten hashes: \`${(payload.forgetHashes ?? []).length}\``
+      `- Forgotten hashes: \`${(payload.forgottenHashes ?? payload.forgetHashes ?? []).length}\``,
+      `- Outstanding forget hashes: \`${(payload.outstandingForgetHashes ?? []).length}\``
     ], env);
     stdout(`${JSON.stringify(payload)}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/node",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Node and GitHub Actions adapters for shared Aleph tooling.",
   "license": "MIT",
   "type": "module",
@@ -16,9 +16,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@le-space/core": "0.1.14",
-    "@le-space/shared-types": "0.1.14",
-    "@le-space/rootfs": "0.1.14",
+    "@le-space/core": "0.1.16",
+    "@le-space/shared-types": "0.1.16",
+    "@le-space/rootfs": "0.1.16",
     "ethers": "^6.15.0"
   }
 }

package/reference/uc-go-peer/rootfs/uc-go-peer-autotls-refresh.service

@@ -16,6 +16,9 @@ Environment=AUTOTLS_CADDY_READY_FILE=/etc/default/uc-go-peer.caddy-ready
 Environment=SERVICE_NAME=uc-go-peer.service
 Environment=WS_BACKEND_PORT=9097
 ExecStart=/usr/bin/python3 /usr/local/sbin/uc-go-peer-autotls-refresh.py
+Restart=on-failure
+RestartSec=43200
+StartLimitIntervalSec=0
 StandardOutput=journal
 StandardError=journal