@le-space/core 0.1.14 → 0.1.16

package/index.d.ts

@@ -320,6 +320,9 @@ declare function retainSuccessfulDeployments(args: {
     retainedRecords: RetentionRecord[];
     prunedRecords: RetentionRecord[];
     forgetHashes: string[];
+    forgottenHashes: string[];
+    outstandingForgetHashes: string[];
+    forgetStatuses: Record<string, string>;
     forgetResult: {
         sender: string;
         itemHash: string;
@@ -327,6 +330,10 @@ declare function retainSuccessfulDeployments(args: {
         httpStatus: number;
         status: _shared_aleph_shared_types.MessageStatus;
     } | null;
+    followUpForgetResults: {
+        hash: string;
+        result: Awaited<ReturnType<typeof forgetAlephMessages>>;
+    }[];
 }>;
 
 declare function createPortForwardAggregateContent(args: {

package/index.js

@@ -893,6 +893,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;
@@ -940,18 +965,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,
@@ -961,7 +1032,11 @@ async function retainSuccessfulDeployments(args) {
     retainedRecords,
     prunedRecords,
     forgetHashes,
-    forgetResult
+    forgottenHashes,
+    outstandingForgetHashes,
+    forgetStatuses,
+    forgetResult,
+    followUpForgetResults
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/core",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Reusable Aleph deployment, runtime, and guest lifecycle logic.",
   "license": "MIT",
   "type": "module",
@@ -16,6 +16,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@le-space/shared-types": "0.1.14"
+    "@le-space/shared-types": "0.1.16"
   }
 }