@ethernity-cloud/sdk-js 1.7.15 → 1.7.20

package/README.md

@@ -44,9 +44,9 @@ The sdk has been tested on the following operating systems:
       `ecld-publish` registers the image in the ImageRegistry
       (ECImageRegistryV3, `0xa372a6e1...`) before anything discloses its
       name, which makes the name the publishing wallet's; then registers the
-      securelock session on-chain in the SessionRegistry (`0x44442968...`, see
+      securelock session on-chain in the SessionRegistry (`0x78f0c5E9...`, see
       `cas/config.js`), which takes it only from that wallet, resolves a CAS
-      from the ValidatorRegistry (`0x0014aB10...`, or `ECLD_CAS_ADDR=host:port`)
+      from the ValidatorRegistry (`0x8CC8B1dc...`, or `ECLD_CAS_ADDR=host:port`)
       for the compose and the certificate harvest, takes the trustedzone
       session name from the ImageRegistry, and links the session to the
       published image. `ecld-build` signs the securelock `--production`.

package/nodenithy/build/securelock/Dockerfile.tmpl

@@ -63,8 +63,9 @@ RUN openssl genrsa -3 -out /enclave-key.pem 3072
 # scone-signer below (SCONE embeds defaults for anything not signed explicitly;
 # any drift makes SCONE recompute + debug re-sign the enclave at load, which CAS
 # rejects on mainnet). Values mirror the publish/run docker-compose securelock
-# service (SCONE_HEAP=1024M, SCONE_STACK=4M, dlopen=1, extensions=libbinary-fs).
-ENV SCONE_HEAP=1024M
+# service (SCONE_HEAP as build.mjs's MEMORY_TO_ALLOCATE, SCONE_STACK=4M,
+# dlopen=1, extensions=libbinary-fs).
+ENV SCONE_HEAP=__MEMORY_TO_ALLOCATE__
 ENV SCONE_STACK=4M
 ENV SCONE_ALLOW_DLOPEN=1
 ENV SCONE_EXTENSIONS_PATH=/lib/libbinary-fs.so

package/nodenithy/build/securelock/src/ecld_state.js

@@ -72,6 +72,7 @@ function configure({ identityPriv, swiftStreamService, bucket, contractAddress,
   _provider = provider;
   _esrLedger = [];
   _taskNonces = {};
+  _taskWrites = {};
   _taskRelayNonces = {};
   _taskLedger = {};
   _taskCaller = normAddr(caller);
@@ -116,6 +117,13 @@ class StateNonceError extends Error {}
 // task code 38 (ESR_COMMIT_LIMIT_EXCEEDED).
 const MAX_COMMITS_PER_TASK = 256;
 
+// How long a read waits for the node to stage a state object the chain names
+// before the task fails, and how often it looks for it: the node writes the
+// objects pinned on it within seconds of the order's start and the ones it has
+// to fetch from the network as they arrive.
+const STATE_STAGE_WAIT_MS = 120000;
+const STATE_STAGE_POLL_MS = 2000;
+
 class StateLimitError extends Error {}
 
 function unwrapStored(stored) {
@@ -260,15 +268,86 @@ function stateKey() {
   return keccak256(Buffer.concat([Buffer.from(DOMAIN_SEP_STATE, 'utf8'), material]));
 }
 
+// A state object is stored as the node's Kubo stores it with `add
+// --cid-version=1 --raw-leaves` and its default chunker: in raw sha256 blocks
+// of BLOCK_SIZE bytes (the last one shorter), a single block as it is, several
+// under a balanced UnixFS tree of at most LINKS_PER_NODE blocks per node.
+// unixfsCid() computes the resulting CID from the bytes, so the enclave
+// commits a CID it derived itself rather than one a node handed it, and the
+// node stores the object under that CID (mvp-pox-node utils.py unixfs_cid).
+const BLOCK_SIZE = 262144;
+const LINKS_PER_NODE = 174;
+
+function cidB32(cid) {
+  return 'b' + base32Encode(cid).toLowerCase().replace(/=+$/, '');
+}
+
+function pbVarint(n) {
+  const out = [];
+  for (;;) {
+    const byte = n % 128;
+    n = Math.floor(n / 128);
+    if (n === 0) {
+      out.push(byte);
+      return Buffer.from(out);
+    }
+    out.push(byte | 0x80);
+  }
+}
+
+// A protobuf field: varint (wire 0) or length-delimited (wire 2).
+function pbField(number, wire, payload) {
+  const tag = pbVarint(number * 8 + wire);
+  return wire === 2 ? Buffer.concat([tag, pbVarint(payload.length), payload]) : Buffer.concat([tag, payload]);
+}
+
+// CIDv1, codec raw (0x55), sha2-256 (0x12, 32 bytes).
+function pbRawCid(content) {
+  return Buffer.concat([Buffer.from([0x01, 0x55, 0x12, 0x20]), crypto.createHash('sha256').update(content).digest()]);
+}
+
+// A dag-pb UnixFS File node over `children`, each [cid, tsize, filesize];
+// returns [cid, tsize, filesize]. Links come before Data in dag-pb; a link
+// carries the child's CID, an empty Name and its Tsize, the size of the
+// child's subtree; Data is UnixFS Type=File(2), filesize, blocksizes.
+function pbFileNode(children) {
+  const links = Buffer.concat(children.map(([cid, tsize]) =>
+    pbField(2, 2, Buffer.concat([pbField(1, 2, cid), pbField(2, 2, Buffer.alloc(0)), pbField(3, 0, pbVarint(tsize))]))));
+  const filesize = children.reduce((n, [, , size]) => n + size, 0);
+  const data = Buffer.concat([pbField(1, 0, pbVarint(2)), pbField(3, 0, pbVarint(filesize)),
+    ...children.map(([, , size]) => pbField(4, 0, pbVarint(size)))]);
+  const block = Buffer.concat([links, pbField(1, 2, data)]);
+  const cid = Buffer.concat([Buffer.from([0x01, 0x70, 0x12, 0x20]), crypto.createHash('sha256').update(block).digest()]);
+  return [cid, block.length + children.reduce((n, [, tsize]) => n + tsize, 0), filesize];
+}
+
 /**
- * CIDv1/raw/sha2-256 for `content`, computed without touching IPFS.
- * Matches `ipfs add --cid-version=1 --raw-leaves`, which is what lets the
- * enclave commit a CID it derived itself rather than one a node handed it.
+ * The CID the node's Kubo gives `content`: the raw block's CID up to one
+ * block, else the root of the balanced UnixFS tree over the blocks,
+ * LINKS_PER_NODE to a node, every node full but the last.
+ */
+function unixfsCid(content, blockSize = BLOCK_SIZE) {
+  const buf = Buffer.isBuffer(content) ? content : Buffer.from(content);
+  if (buf.length <= blockSize) return cidB32(pbRawCid(buf));
+  let nodes = [];
+  for (let i = 0; i < buf.length; i += blockSize) {
+    const chunk = buf.subarray(i, i + blockSize);
+    nodes.push([pbRawCid(chunk), chunk.length, chunk.length]);
+  }
+  while (nodes.length > 1) {
+    const next = [];
+    for (let i = 0; i < nodes.length; i += LINKS_PER_NODE) next.push(pbFileNode(nodes.slice(i, i + LINKS_PER_NODE)));
+    nodes = next;
+  }
+  return cidB32(nodes[0][0]);
+}
+
+/**
+ * CIDv1/raw/sha2-256 for `content`: its CID as one raw block, which is its CID
+ * through the node's Kubo up to BLOCK_SIZE bytes.
  */
 function cidv1Raw(content) {
-  const digest = crypto.createHash('sha256').update(content).digest();
-  const raw = Buffer.concat([Buffer.from([0x01, 0x55, 0x12, 0x20]), digest]);
-  return 'b' + base32Encode(raw).toLowerCase().replace(/=+$/, '');
+  return cidB32(pbRawCid(content));
 }
 
 // RFC4648 base32, no padding stripped here (the caller strips it).
@@ -356,6 +435,12 @@ let _esrLedger = [];
 // even before the node's relay lands on-chain.
 let _taskNonces = {};
 
+// Per-task memo of this task's last commit per key, [acl, data, version, cid]
+// as the chain shows them once the node's relay lands. A read prefers it while
+// the chain still shows an older version, so get() after commit() returns the
+// committed state and a second commit to the key builds on the first.
+let _taskWrites = {};
+
 // Per-task memo of the NEXT relay nonce per key hash, so multiple commits to
 // the same key within one task sign sequential relay nonces even while the
 // node is still relaying the earlier ones.
@@ -429,6 +514,10 @@ class StateRegistry {
   /** [acl, data, version, cid] for `key`; NO permission check here. */
   async _readContainer(key, fallback = {}) {
     const [cid, version] = await this._contract().getState(this.walletAddress, keyHash(key));
+    const own = _taskWrites[key];
+    if (own && own[2] > Number(version || 0)) {
+      return own;
+    }
     if (!version || !cid) {
       return [null, fallback, 0, null];
     }
@@ -579,7 +668,7 @@ class StateRegistry {
 
       const blob = encrypt(Buffer.from(JSON.stringify(stored), 'utf8'));
       // Compute the CID from OUR bytes — never accept one from the node.
-      const cid = cidv1Raw(blob);
+      const cid = unixfsCid(blob);
 
       // Hand the blob and the CID to the node for pinning. It verifies the CID
       // matches; it does not get to choose it. Fire-and-forget.
@@ -597,6 +686,7 @@ class StateRegistry {
         // results): this is what the chain shows once the relay lands.
         ledgerRecord(key, currentVersion + 1, cid, newData);
         _taskNonces[key] = finalNonce;
+        _taskWrites[key] = [nextAcl, newData, currentVersion + 1, cid];
         return [nextAcl, newData];
       } catch (e) {
         const msg = String(e && e.message ? e.message : e);
@@ -623,22 +713,40 @@ class StateRegistry {
    * the node stages state objects in the bucket. That makes the node the
    * delivery path but not a trusted one: content is checked against the CID the
    * chain records, so a substituted blob is rejected rather than decrypted.
+   *
+   * The node stages it as state.<cid>.enc, within seconds of the order's start
+   * when the object is pinned on it and as it arrives when it has to fetch it
+   * from the network, so the object is looked for every STATE_STAGE_POLL_MS
+   * for up to STATE_STAGE_WAIT_MS. state.<key>.enc is the last blob a commit
+   * of this key published, which matches only while no later commit was
+   * published; one that does not match is passed over.
    */
   async _fetch(key, cid) {
-    for (const name of [`state.${key}.enc`, `state.${cid}.enc`]) {
-      // eslint-disable-next-line no-await-in-loop
-      const data = await _swift.getFileContentBytes(_bucket, name).catch(() => null);
-      if (data && data.length) {
-        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-        if (cidv1Raw(buf) !== cid) {
-          throw new Error(
-            `State object ${name} does not match the committed CID ${cid} — refusing to use it`
-          );
+    const deadline = Date.now() + STATE_STAGE_WAIT_MS;
+    let mismatched = [];
+    for (;;) {
+      mismatched = [];
+      for (const name of [`state.${cid}.enc`, `state.${key}.enc`]) {
+        // eslint-disable-next-line no-await-in-loop
+        const data = await _swift.getFileContentBytes(_bucket, name).catch(() => null);
+        if (data && data.length) {
+          const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+          if (unixfsCid(buf) === cid) {
+            return buf;
+          }
+          mismatched.push(name);
         }
-        return buf;
       }
+      if (Date.now() >= deadline) break;
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise((resolve) => { setTimeout(resolve, STATE_STAGE_POLL_MS); });
+    }
+    if (mismatched.length) {
+      throw new Error(
+        `State object ${mismatched.join(' and ')} does not match the committed CID ${cid} — refusing to use it`
+      );
     }
-    throw new Error(`Could not read state object for '${key}' (${cid})`);
+    throw new Error(`Could not read state object for '${key}' (${cid}): not staged within ${STATE_STAGE_WAIT_MS / 1000} s`);
   }
 
   async _sendCommit(keyHashHex, cid, expectedVersion, ownerAddr = null, nonce = 0) {
@@ -815,6 +923,7 @@ module.exports = {
   StatePermissionError,
   StateNonceError,
   StateLimitError,
+  unixfsCid,
   esrGrant,
   esrRevoke,
   esrSetPublicRead,

package/nodenithy/build.mjs

@@ -265,7 +265,12 @@ let dockerfileSecureContent = dockerfileSecureTemplate.replace(/__ENCLAVE_NAME_S
 
 // Amount of enclave heap to allocate (SCONE_HEAP). Kept in sync with the
 // run/docker-compose securelock service; overridable via ECLD_MEMORY_TO_ALLOCATE.
+// 1024M: with 256M or 512M the node runtime exhausts the protected heap
+// reserving its V8 code range at start, before the securelock runs.
 const MEMORY_TO_ALLOCATE = (process.env.ECLD_MEMORY_TO_ALLOCATE || '1024M').trim();
+// Read back by ecld-publish (run.js), which renders it into the composes'
+// securelock service.
+writeEnv('MEMORY_TO_ALLOCATE', MEMORY_TO_ALLOCATE);
 
 // CRITICAL (mainnet DCAP): sign /usr/local/bin/node -- the binary the enclave
 // actually EXECUTES (ENTRYPOINT + the run/publish compose command both run
@@ -297,6 +302,7 @@ const signedMrenclaveStep =
 // securelock is signed debug with the same explicit params.
 const cas = casConfig.casProvisioned(templateName, isMainnet);
 dockerfileSecureContent = dockerfileSecureContent
+  .replace(/__MEMORY_TO_ALLOCATE__/g, MEMORY_TO_ALLOCATE)
   .replace('__SCONE_SIGN__', `RUN scone-signer sign ${signFlags}${cas ? ' --production' : ''} /usr/local/bin/node`)
   .replace('__SIGNED_MRENCLAVE__', signedMrenclaveStep);
 

package/nodenithy/run/docker-compose-final.yml.tmpl

@@ -36,9 +36,10 @@ services:
       - SCONE_CAS_ADDR=scone-cas.cf  # __CAS_ONLY__
       - SCONE_LAS_ADDR=las  # __CAS_ONLY__
       - SCONE_CONFIG_ID=__ENCLAVE_NAME_SECURELOCK__/application  # __CAS_ONLY__
-      - SCONE_HEAP=1024M
-      # Must match the --stack the securelock binary was signed with (build.mjs),
-      # otherwise SCONE recomputes MRENCLAVE at load and re-signs as debug.
+      # Must match the --heap and --stack the securelock binary was signed with
+      # (build.mjs), otherwise SCONE recomputes MRENCLAVE at load and re-signs
+      # as debug. The heap is the build's MEMORY_TO_ALLOCATE (.env).
+      - SCONE_HEAP=__MEMORY_TO_ALLOCATE__
       - SCONE_STACK=4M
       - SCONE_LOG=DEBUG
       - SCONE_ALLOW_DLOPEN=1
@@ -55,8 +56,8 @@ services:
     container_name: etny-trustedzone
     privileged: true
     image: localhost:5000/etny-trustedzone
-    entrypoint: ""
-    command: [ "/usr/local/bin/node", "/etny-trustedzone/trustedzone.js" ]
+    # No command: the image's ENTRYPOINT runs node with the flags the
+    # trustedzone was built and measured with (etny-nodenithy Dockerfile.tmpl).
     environment:
       - SCONE_CAS_ADDR=scone-cas.cf  # __CAS_ONLY__
       - SCONE_LAS_ADDR=las  # __CAS_ONLY__

package/nodenithy/run/docker-compose.yml.tmpl

@@ -39,9 +39,10 @@ services:
       - SCONE_CAS_ADDR=scone-cas.cf  # __CAS_ONLY__
       - SCONE_LAS_ADDR=las  # __CAS_ONLY__
       - SCONE_CONFIG_ID=__ENCLAVE_NAME_SECURELOCK__/application  # __CAS_ONLY__
-      - SCONE_HEAP=1024M
-      # Must match the --stack the securelock binary was signed with (build.mjs),
-      # otherwise SCONE recomputes MRENCLAVE at load and re-signs as debug.
+      # Must match the --heap and --stack the securelock binary was signed with
+      # (build.mjs), otherwise SCONE recomputes MRENCLAVE at load and re-signs
+      # as debug. The heap is the build's MEMORY_TO_ALLOCATE (.env).
+      - SCONE_HEAP=__MEMORY_TO_ALLOCATE__
       - SCONE_STACK=4M
       - SCONE_LOG=DEBUG
       - SCONE_ALLOW_DLOPEN=1
@@ -54,14 +55,14 @@ services:
     container_name: etny-trustedzone
     privileged: true
     image: localhost:5000/etny-trustedzone
-    entrypoint: ""
-    command: [ "/usr/local/bin/node", "/etny-trustedzone/trustedzone.js" ]
+    # No command: the image's ENTRYPOINT runs node with the flags the
+    # trustedzone was built and measured with (etny-nodenithy Dockerfile.tmpl).
     environment:
       - SCONE_CAS_ADDR=scone-cas.cf  # __CAS_ONLY__
       - SCONE_LAS_ADDR=las  # __CAS_ONLY__
       - SCONE_CONFIG_ID=__ENCLAVE_NAME_TRUSTEDZONE__/application  # __CAS_ONLY__
-      # The heap the trustedzone was measured and registered with: 1024M for
-      # every testnet trustedzone (etny-nodenithy v3/run/docker-compose.yml).
+      # The heap the trustedzone was signed with: the SCONE_HEAP of the
+      # bundled trustedzone image (run.js reads it from the image).
       - SCONE_HEAP=__TRUSTEDZONE_HEAP__
       - SCONE_LOG=DEBUG
       - SCONE_ALLOW_DLOPEN=1

package/nodenithy/run/public_key_service.js

@@ -5,7 +5,8 @@
 // registries) is queued by the service's registry watcher from the
 // ImageRegistered event, with this publish's IPFS peer; the hash is posted to
 // /api/addHash only when that row has not appeared within
-// CHAIN_ROW_GRACE_SECONDS. Other images are posted at once.
+// CHAIN_ROW_GRACE_SECONDS, or when the service holds a failed extraction of
+// the image. Other images are posted at once.
 const axios = require('axios');
 const fs = require('fs');
 const { Command } = require('commander');
@@ -14,6 +15,14 @@ const BASE_URL = "https://publickey.ethernity.cloud";
 // The watcher polls the registries every 30 s.
 const CHAIN_ROW_GRACE_SECONDS = 180;
 const POLL_SECONDS = 10;
+// A failed extraction is recorded against the hash with publicKey -1 and a
+// reason, and a new submission of the hash runs it again. The service answers
+// the old record for a moment after a submission, so a failed answer is taken
+// as the outcome only once this long has passed since this publish submitted.
+const RESUBMIT_GRACE_SECONDS = 60;
+
+// The service's record of an extraction that failed.
+const failed = (answer) => answer !== null && answer.publicKey === -1;
 
 async function submitIpfsHash(hash, enclaveName, protocolVersion, network, templateVersion, dockerComposerHash) {
     const url = `${BASE_URL}/api/addHash`;
@@ -48,9 +57,10 @@ async function checkIpfsHashStatus(hash) {
     }
 }
 
-// Queues the image as described above and returns the service's first
-// answer for it. `submit`, `check`, `sleep` and `now` are the functions
-// above and the clock, replaceable for tests.
+// Queues the image as described above and returns the service's first answer
+// for it (`answer`, null right after a submission) and whether this publish
+// posted the hash (`submitted`). `submit`, `check`, `sleep` and `now` are the
+// functions above and the clock, replaceable for tests.
 async function queueImage({ hash, chainRegistered, submitArgs, submit = submitIpfsHash, check = checkIpfsHashStatus,
     sleep = (s) => new Promise((resolve) => setTimeout(resolve, s * 1000)), now = () => Date.now() / 1000,
     log = console.log, graceSeconds = CHAIN_ROW_GRACE_SECONDS, pollSeconds = POLL_SECONDS }) {
@@ -58,7 +68,11 @@ async function queueImage({ hash, chainRegistered, submitArgs, submit = submitIp
         const deadline = now() + graceSeconds;
         while (true) {
             const answer = await check(hash);
-            if (answer !== null) return answer;
+            if (failed(answer)) {
+                log(`The service's previous extraction of this image failed (${answer.reason || "no reason reported"}); submitting the hash again`);
+                break;
+            }
+            if (answer !== null) return { answer, submitted: false };
             if (now() >= deadline) {
                 log(`The certificate service has not picked the registration up from the chain in ${graceSeconds} s; submitting the hash`);
                 break;
@@ -69,7 +83,7 @@ async function queueImage({ hash, chainRegistered, submitArgs, submit = submitIp
     }
     const submitResponse = await submit(hash, ...submitArgs);
     log("Submit IPFS Hash Response:", submitResponse);
-    return null;
+    return { answer: null, submitted: true };
 }
 
 async function main() {
@@ -98,10 +112,12 @@ async function main() {
     console.log("Template Version:", templateVersion);
     console.log("Docker Composer Hash:", dockerComposerHash);
 
-    let checkResponse = await queueImage({
+    const queued = await queueImage({
         hash: hhash, chainRegistered: Boolean(options.chainRegistered),
         submitArgs: [enclaveName, protocolVersion, network, templateVersion, dockerComposerHash],
     });
+    let checkResponse = queued.answer;
+    const submittedAt = queued.submitted ? Date.now() / 1000 : null;
 
     // The service answers publicKey 0 while the image is queued or running
     // (with status, percent and queuePosition), -1 when the extraction failed
@@ -119,10 +135,15 @@ async function main() {
                 } else {
                     console.log(`Public key not available yet. Queue position: ${checkResponse.queuePosition ?? 'Unknown'}`);
                 }
-            } else if (checkResponse.publicKey === -1) {
-                console.log(`Public key extraction failed: ${checkResponse.reason || "reason not reported by the service"}`);
-                console.log("Fix the cause (keep the image pinned, build with the current SDK) and publish again: a new submission of the same hash runs the extraction again.");
-                process.exit(1);
+            } else if (failed(checkResponse)) {
+                if (submittedAt !== null && Date.now() / 1000 - submittedAt < RESUBMIT_GRACE_SECONDS) {
+                    // The record of the run before this publish's submission.
+                    console.log("The service still answers its previous record; waiting for the new run");
+                } else {
+                    console.log(`Public key extraction failed: ${checkResponse.reason || "reason not reported by the service"}`);
+                    console.log("Fix the cause (keep the image pinned, build with the current SDK) and publish again: a new submission of the same hash runs the extraction again.");
+                    process.exit(1);
+                }
             } else {
                 console.log("Public Key:", checkResponse.publicKey);
                 // Save public key to file
@@ -152,4 +173,4 @@ async function main() {
 
 if (require.main === module) main();
 
-module.exports = { queueImage, CHAIN_ROW_GRACE_SECONDS, POLL_SECONDS };
+module.exports = { queueImage, CHAIN_ROW_GRACE_SECONDS, POLL_SECONDS, RESUBMIT_GRACE_SECONDS };

package/nodenithy/run.js

@@ -113,12 +113,28 @@ const extractSignedMrenclave = (service) => {
     }
 };
 
+// The heap the trustedzone was signed with: the SCONE_HEAP of the image the
+// build bundled (etny-nodenithy's Dockerfile sets it to the --heap it signs
+// with). The compose must name the same value, or SCONE recomputes the
+// measurement at load and the CAS refuses the enclave.
+const trustedZoneHeapOfImage = (image) => {
+    const env = execSync(`docker image inspect ${image} --format "{{range .Config.Env}}{{println .}}{{end}}"`,
+        { stdio: ['pipe', 'pipe', 'pipe'] }).toString();
+    const m = env.match(/^SCONE_HEAP=(\S+)$/m);
+    if (!m) throw new Error(`${image} carries no SCONE_HEAP in its environment`);
+    return m[1];
+};
+
 const main = async () => {
     process.env.NODE_NO_WARNINGS = 1
-    // Every testnet trustedzone was measured and registered with a 1024M heap
-    // (etny-nodenithy v3/run/docker-compose.yml). The mainnet session named
-    // below comes from the features/v3 branches, which ran it with 256M.
-    const trustedZoneHeap = isMainnet ? '256M' : '1024M';
+    const trustedZoneHeap = trustedZoneHeapOfImage('localhost:5000/etny-trustedzone');
+    console.log(`Trustedzone heap: ${trustedZoneHeap}`);
+    // The securelock heap ecld-build signed it with (part of MRENCLAVE).
+    const memory = (process.env.MEMORY_TO_ALLOCATE || '').trim();
+    if (!memory) {
+        console.error("Error: MEMORY_TO_ALLOCATE is not set in .env; run ecld-build first.");
+        process.exit(1);
+    }
 
     // Where the image goes. An IPFS API of the application's own
     // (IPFS_ENDPOINT, with IPFS_TOKEN as its Authorization header when set)
@@ -208,7 +224,8 @@ const main = async () => {
             return;
         }
         const content = casConfig.renderCompose(fs.readFileSync(template, 'utf8'), cas, unsafe)
-            .replace(/__TRUSTEDZONE_HEAP__/g, trustedZoneHeap);
+            .replace(/__TRUSTEDZONE_HEAP__/g, trustedZoneHeap)
+            .replace(/__MEMORY_TO_ALLOCATE__/g, memory);
         fs.writeFileSync(file, content, 'utf8');
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethernity-cloud/sdk-js",
-  "version": "1.7.15",
+  "version": "1.7.20",
   "description": "A package to run ethernity cloud build scripts",
   "scripts": {
     "test": "node --test \"test/**/*.test.js\"",
@@ -40,7 +40,7 @@
     "!**/*.pyc"
   ],
   "dependencies": {
-    "@ethernity-cloud/runner": "^0.6.11",
+    "@ethernity-cloud/runner": "^0.6.12",
     "acorn": "^8.11.0",
     "adm-zip": "^0.5.14",
     "axios": "^1.7.2",

package/pynithy/build/securelock/src/ecld_state.py

@@ -46,6 +46,7 @@ import hashlib
 import io
 import json
 import os
+import time
 
 DOMAIN_SEP_STATE = b"ethernity-cloud/esr-encryption/v1"
 
@@ -75,6 +76,11 @@ _task_ledger = {}
 # get_nonce() right after a commit in the SAME task returns the fresh value
 # even though the node's relay (and thus the chain) has not landed yet.
 _task_nonces = {}
+# Per-task memo of this task's last commit per key, (acl, data, version, cid)
+# as the chain shows them once the node's relay lands. A read prefers it while
+# the chain still shows an older version, so get() after commit() returns the
+# committed state and a second commit to the key builds on the first.
+_task_writes = {}
 # Per-task memo of the NEXT relay nonce per key hash (hex), so multiple
 # commits to the same key within one task sign sequential relay nonces even
 # while the node is still relaying the earlier ones.
@@ -312,7 +318,7 @@ def configure(identity_priv, swift_stream_service, bucket, contract_address,
     value from the client payload or the node's .env.
     """
     global _identity_priv, _swift, _bucket, _contract_address, _web3, _esr_evidence
-    global _task_ledger, _task_nonces, _task_relay_nonces, _task_caller
+    global _task_ledger, _task_nonces, _task_writes, _task_relay_nonces, _task_caller
     _identity_priv = identity_priv
     _swift = swift_stream_service
     _bucket = bucket
@@ -320,6 +326,7 @@ def configure(identity_priv, swift_stream_service, bucket, contract_address,
     _web3 = web3
     _task_ledger = {}
     _task_nonces = {}
+    _task_writes = {}
     _task_relay_nonces = {}
     _esr_evidence = []
     _task_caller = _norm_addr(caller)
@@ -357,6 +364,13 @@ class StatePermissionError(RuntimeError):
 # 0x00 = 1 commit ... 0xFF = 256; an all-zero root means no commits at all).
 MAX_COMMITS_PER_TASK = 256
 
+# How long a read waits for the node to stage a state object the chain names
+# before the task fails, and how often it looks for it: the node writes the
+# objects pinned on it within seconds of the order's start and the ones it
+# has to fetch from the network as they arrive.
+STATE_STAGE_WAIT_SECONDS = 120
+STATE_STAGE_POLL_SECONDS = 2
+
 
 class StateLimitError(RuntimeError):
     """Raised when a task tries to make more than MAX_COMMITS_PER_TASK state
@@ -478,15 +492,77 @@ def looks_like_cid(value) -> bool:
     return False
 
 
-def cidv1_raw(content: bytes) -> str:
-    """CIDv1/raw/sha2-256 for `content`, computed without touching IPFS.
+# A state object is stored as the node's Kubo stores it with `add
+# --cid-version=1 --raw-leaves` and its default chunker: in raw sha256 blocks
+# of BLOCK_SIZE bytes (the last one shorter), a single block as it is, several
+# under a balanced UnixFS tree of at most LINKS_PER_NODE blocks per node.
+# unixfs_cid() computes the resulting CID from the bytes, so the enclave
+# commits a CID it derived itself rather than one a node handed it, and the
+# node stores the object under that CID (mvp-pox-node utils.py unixfs_cid).
+BLOCK_SIZE = 262144
+LINKS_PER_NODE = 174
 
-    Matches `ipfs add --cid-version=1 --raw-leaves`, which is what lets the
-    enclave commit a CID it derived itself rather than one a node handed it.
-    """
-    digest = hashlib.sha256(content).digest()
-    raw = bytes([0x01, 0x55, 0x12, 0x20]) + digest
-    return "b" + base64.b32encode(raw).decode("ascii").lower().rstrip("=")
+
+def _cid_b32(cid: bytes) -> str:
+    return "b" + base64.b32encode(cid).decode("ascii").lower().rstrip("=")
+
+
+def _pb_varint(n: int) -> bytes:
+    out = bytearray()
+    while True:
+        byte = n & 0x7F
+        n >>= 7
+        if n:
+            out.append(byte | 0x80)
+        else:
+            out.append(byte)
+            return bytes(out)
+
+
+def _pb_field(number: int, wire: int, payload: bytes) -> bytes:
+    """A protobuf field: varint (wire 0) or length-delimited (wire 2)."""
+    tag = _pb_varint((number << 3) | wire)
+    return tag + (_pb_varint(len(payload)) + payload if wire == 2 else payload)
+
+
+def _pb_raw_cid(content: bytes) -> bytes:
+    """CIDv1, codec raw (0x55), sha2-256 (0x12, 32 bytes)."""
+    return bytes([0x01, 0x55, 0x12, 0x20]) + hashlib.sha256(content).digest()
+
+
+def _pb_file_node(children):
+    """A dag-pb UnixFS File node over `children`, each (cid, tsize, filesize);
+    returns (cid, tsize, filesize). Links come before Data in dag-pb; a link
+    carries the child's CID, an empty Name and its Tsize, the size of the
+    child's subtree; Data is UnixFS Type=File(2), filesize, blocksizes."""
+    links = b"".join(
+        _pb_field(2, 2, _pb_field(1, 2, cid) + _pb_field(2, 2, b"") + _pb_field(3, 0, _pb_varint(tsize)))
+        for cid, tsize, _ in children)
+    filesize = sum(size for _, _, size in children)
+    data = _pb_field(1, 0, _pb_varint(2)) + _pb_field(3, 0, _pb_varint(filesize))
+    data += b"".join(_pb_field(4, 0, _pb_varint(size)) for _, _, size in children)
+    block = links + _pb_field(1, 2, data)
+    cid = bytes([0x01, 0x70, 0x12, 0x20]) + hashlib.sha256(block).digest()
+    return cid, len(block) + sum(tsize for _, tsize, _ in children), filesize
+
+
+def unixfs_cid(content: bytes, block_size: int = BLOCK_SIZE) -> str:
+    """The CID the node's Kubo gives `content`: the raw block's CID up to one
+    block, else the root of the balanced UnixFS tree over the blocks,
+    LINKS_PER_NODE to a node, every node full but the last."""
+    if len(content) <= block_size:
+        return _cid_b32(_pb_raw_cid(content))
+    nodes = [(_pb_raw_cid(content[i:i + block_size]), len(content[i:i + block_size]), len(content[i:i + block_size]))
+             for i in range(0, len(content), block_size)]
+    while len(nodes) > 1:
+        nodes = [_pb_file_node(nodes[i:i + LINKS_PER_NODE]) for i in range(0, len(nodes), LINKS_PER_NODE)]
+    return _cid_b32(nodes[0][0])
+
+
+def cidv1_raw(content: bytes) -> str:
+    """CIDv1/raw/sha2-256 for `content`: its CID as one raw block, which is
+    its CID through the node's Kubo up to BLOCK_SIZE bytes."""
+    return _cid_b32(_pb_raw_cid(content))
 
 
 # AES-GCM nonce length, pinned explicitly. PyCryptodome defaults to 16 bytes
@@ -601,6 +677,9 @@ class StateRegistry:
         contract = self._contract()
         cid, version, _updated = contract.functions.getState(
             self.wallet_address, _key_hash(key)).call()
+        own = _task_writes.get(key)
+        if own is not None and own[2] > int(version or 0):
+            return own
         if not version or not cid:
             return None, default, 0, None
         if not looks_like_cid(cid):
@@ -747,7 +826,7 @@ class StateRegistry:
 
             blob = _encrypt(json.dumps(stored, separators=(",", ":")).encode("utf-8"))
             # Compute the CID from OUR bytes -- never accept one from the node.
-            cid = cidv1_raw(blob)
+            cid = unixfs_cid(blob)
 
             # Hand the blob and the CID to the node for pinning. It verifies the
             # CID matches; it does not get to choose it. Fire-and-forget: the
@@ -766,6 +845,7 @@ class StateRegistry:
                 # The ledger records the DATA -- the ACL never leaves in results.
                 _ledger_record(key, current_version + 1, cid, new_data)
                 _task_nonces[key] = final_nonce
+                _task_writes[key] = (new_acl, new_data, current_version + 1, cid)
                 return new_acl, new_data
             except Exception as e:
                 # A version race means someone else committed first: re-read and
@@ -805,17 +885,34 @@ class StateRegistry:
         delivery path -- but not a trusted one: the content is checked against
         the CID the chain records, so a substituted or corrupted blob is
         rejected rather than decrypted and returned as state.
+
+        The node stages it as state.<cid>.enc, within seconds of the order's
+        start when the object is pinned on it and as it arrives when it has
+        to fetch it from the network, so the object is looked for every
+        STATE_STAGE_POLL_SECONDS for up to STATE_STAGE_WAIT_SECONDS.
+        state.<key>.enc is the last blob a commit of this key published,
+        which matches only while no later commit was published; one that
+        does not match is passed over.
         """
-        candidates = (f"state.{key}.enc", f"state.{cid}.enc")
-        for name in candidates:
-            ok, data = _swift.get_file_content_bytes(_bucket, name)
-            if ok and data:
-                if cidv1_raw(data) != cid:
-                    raise RuntimeError(
-                        f"State object {name} does not match the committed CID "
-                        f"{cid} -- refusing to use it")
-                return data
-        raise RuntimeError(f"Could not read state object for '{key}' ({cid})")
+        deadline = time.monotonic() + STATE_STAGE_WAIT_SECONDS
+        while True:
+            mismatched = []
+            for name in (f"state.{cid}.enc", f"state.{key}.enc"):
+                ok, data = _swift.get_file_content_bytes(_bucket, name)
+                if ok and data:
+                    if unixfs_cid(data) == cid:
+                        return data
+                    mismatched.append(name)
+            if time.monotonic() >= deadline:
+                break
+            time.sleep(STATE_STAGE_POLL_SECONDS)
+        if mismatched:
+            raise RuntimeError(
+                f"State object {' and '.join(mismatched)} does not match the "
+                f"committed CID {cid} -- refusing to use it")
+        raise RuntimeError(
+            f"Could not read state object for '{key}' ({cid}): not staged "
+            f"within {STATE_STAGE_WAIT_SECONDS} s")
 
     def _send_commit(self, key_hash: bytes, cid: str, expected_version: int,
                      owner_addr: str = None, nonce: int = 0):

package/pynithy/build.mjs

@@ -156,7 +156,7 @@ const casProvisioned = casConfig.casProvisioned(templateName, isMainnet);
 
 // Enclave heap (SCONE_HEAP). Part of the measurement: publish runs the
 // securelock with the value recorded here.
-const MEMORY_TO_ALLOCATE = (process.env.ECLD_MEMORY_TO_ALLOCATE || process.env.MEMORY_TO_ALLOCATE || '1024M').trim();
+const MEMORY_TO_ALLOCATE = (process.env.ECLD_MEMORY_TO_ALLOCATE || process.env.MEMORY_TO_ALLOCATE || '256M').trim();
 writeEnv('MEMORY_TO_ALLOCATE', MEMORY_TO_ALLOCATE);
 
 runCommand('docker pull registry:2');

package/pynithy/run/public_key_service.js

@@ -5,7 +5,8 @@
 // registries) is queued by the service's registry watcher from the
 // ImageRegistered event, with this publish's IPFS peer; the hash is posted to
 // /api/addHash only when that row has not appeared within
-// CHAIN_ROW_GRACE_SECONDS. Other images are posted at once.
+// CHAIN_ROW_GRACE_SECONDS, or when the service holds a failed extraction of
+// the image. Other images are posted at once.
 const axios = require('axios');
 const fs = require('fs');
 const { Command } = require('commander');
@@ -14,6 +15,14 @@ const BASE_URL = "https://publickey.ethernity.cloud";
 // The watcher polls the registries every 30 s.
 const CHAIN_ROW_GRACE_SECONDS = 180;
 const POLL_SECONDS = 10;
+// A failed extraction is recorded against the hash with publicKey -1 and a
+// reason, and a new submission of the hash runs it again. The service answers
+// the old record for a moment after a submission, so a failed answer is taken
+// as the outcome only once this long has passed since this publish submitted.
+const RESUBMIT_GRACE_SECONDS = 60;
+
+// The service's record of an extraction that failed.
+const failed = (answer) => answer !== null && answer.publicKey === -1;
 
 async function submitIpfsHash(hash, enclaveName, protocolVersion, network, templateVersion, dockerComposerHash) {
     const url = `${BASE_URL}/api/addHash`;
@@ -48,9 +57,10 @@ async function checkIpfsHashStatus(hash) {
     }
 }
 
-// Queues the image as described above and returns the service's first
-// answer for it. `submit`, `check`, `sleep` and `now` are the functions
-// above and the clock, replaceable for tests.
+// Queues the image as described above and returns the service's first answer
+// for it (`answer`, null right after a submission) and whether this publish
+// posted the hash (`submitted`). `submit`, `check`, `sleep` and `now` are the
+// functions above and the clock, replaceable for tests.
 async function queueImage({ hash, chainRegistered, submitArgs, submit = submitIpfsHash, check = checkIpfsHashStatus,
     sleep = (s) => new Promise((resolve) => setTimeout(resolve, s * 1000)), now = () => Date.now() / 1000,
     log = console.log, graceSeconds = CHAIN_ROW_GRACE_SECONDS, pollSeconds = POLL_SECONDS }) {
@@ -58,7 +68,11 @@ async function queueImage({ hash, chainRegistered, submitArgs, submit = submitIp
         const deadline = now() + graceSeconds;
         while (true) {
             const answer = await check(hash);
-            if (answer !== null) return answer;
+            if (failed(answer)) {
+                log(`The service's previous extraction of this image failed (${answer.reason || "no reason reported"}); submitting the hash again`);
+                break;
+            }
+            if (answer !== null) return { answer, submitted: false };
             if (now() >= deadline) {
                 log(`The certificate service has not picked the registration up from the chain in ${graceSeconds} s; submitting the hash`);
                 break;
@@ -69,7 +83,7 @@ async function queueImage({ hash, chainRegistered, submitArgs, submit = submitIp
     }
     const submitResponse = await submit(hash, ...submitArgs);
     log("Submit IPFS Hash Response:", submitResponse);
-    return null;
+    return { answer: null, submitted: true };
 }
 
 async function main() {
@@ -98,10 +112,12 @@ async function main() {
     console.log("Template Version:", templateVersion);
     console.log("Docker Composer Hash:", dockerComposerHash);
 
-    let checkResponse = await queueImage({
+    const queued = await queueImage({
         hash: hhash, chainRegistered: Boolean(options.chainRegistered),
         submitArgs: [enclaveName, protocolVersion, network, templateVersion, dockerComposerHash],
     });
+    let checkResponse = queued.answer;
+    const submittedAt = queued.submitted ? Date.now() / 1000 : null;
 
     // The service answers publicKey 0 while the image is queued or running
     // (with status, percent and queuePosition), -1 when the extraction failed
@@ -119,10 +135,15 @@ async function main() {
                 } else {
                     console.log(`Public key not available yet. Queue position: ${checkResponse.queuePosition ?? 'Unknown'}`);
                 }
-            } else if (checkResponse.publicKey === -1) {
-                console.log(`Public key extraction failed: ${checkResponse.reason || "reason not reported by the service"}`);
-                console.log("Fix the cause (keep the image pinned, build with the current SDK) and publish again: a new submission of the same hash runs the extraction again.");
-                process.exit(1);
+            } else if (failed(checkResponse)) {
+                if (submittedAt !== null && Date.now() / 1000 - submittedAt < RESUBMIT_GRACE_SECONDS) {
+                    // The record of the run before this publish's submission.
+                    console.log("The service still answers its previous record; waiting for the new run");
+                } else {
+                    console.log(`Public key extraction failed: ${checkResponse.reason || "reason not reported by the service"}`);
+                    console.log("Fix the cause (keep the image pinned, build with the current SDK) and publish again: a new submission of the same hash runs the extraction again.");
+                    process.exit(1);
+                }
             } else {
                 console.log("Public Key:", checkResponse.publicKey);
                 // Save public key to file
@@ -152,4 +173,4 @@ async function main() {
 
 if (require.main === module) main();
 
-module.exports = { queueImage, CHAIN_ROW_GRACE_SECONDS, POLL_SECONDS };
+module.exports = { queueImage, CHAIN_ROW_GRACE_SECONDS, POLL_SECONDS, RESUBMIT_GRACE_SECONDS };

package/test.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /* ecld-test — run a Nodenithy payload locally, without SGX, exactly as the
  * enclave would.
  *