@ethernity-cloud/sdk-js 1.5.0 → 1.5.2

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

@@ -60,6 +60,7 @@ function configure({ identityPriv, swiftStreamService, bucket, contractAddress,
   _bucket = bucket;
   _contractAddress = contractAddress;
   _provider = provider;
+  _esrLedger = [];
 }
 
 function keccak256(buf) {
@@ -157,11 +158,20 @@ function keyHash(key) {
 
 const ESR_ABI = [
   'function commit(bytes32 key, string newCID, uint256 expectedVersion)',
+  'function commitFor(address enclave, bytes32 key, string newCID, uint256 expectedVersion, uint256 relayNonce, bytes signature)',
+  'function commitDigest(address enclave, bytes32 key, string newCID, uint256 expectedVersion, uint256 relayNonce) view returns (bytes32)',
+  'function relayNonce(address enclave) view returns (uint256)',
   'function getState(address enclave, bytes32 key) view returns (string cid, uint256 version, uint64 updatedAt)',
   'function getVersion(address enclave, bytes32 key) view returns (uint256)',
   'function exists(address enclave, bytes32 key) view returns (bool)'
 ];
 
+// Order-wide ledger of signed authorizations. ESR commits do NOT pay their own
+// gas (see contracts/esr/RELAY-DESIGN.md): the enclave only SIGNS each commit
+// (commitFor); the NODE relays it and pays, and does all gas accounting. The
+// securelock does no gas math -- nothing it could claim about cost is trusted.
+let _esrLedger = [];
+
 class StateRegistry {
   constructor() {
     if (!_contractAddress) {
@@ -290,9 +300,39 @@ class StateRegistry {
   }
 
   async _sendCommit(keyHashHex, cid, expectedVersion) {
-    const contract = this._contract(this._signer());
-    const tx = await contract.commit(keyHashHex, cid, expectedVersion);
-    return tx.wait();
+    // The enclave never pays gas and does NO gas math: it SIGNS the commit
+    // (commitFor) and stages the signed authorization for the node, which
+    // relays it and pays. The trustedzone independently re-prices the whole
+    // ledger and adjudicates. Nothing the securelock could claim about cost is
+    // trusted, so it claims nothing.
+    const signer = this._signer();
+    const enclave = await signer.getAddress();
+    const contract = this._contract();
+
+    const relayNonce = await contract.relayNonce(enclave);
+    const digest = await contract.commitDigest(
+      enclave, keyHashHex, cid, expectedVersion, relayNonce);
+    // Sign the raw 32-byte digest as an eth_sign message (matches the
+    // contract's "\x19Ethereum Signed Message:\n32" recovery).
+    const signature = await signer.signMessage(ethers.utils.arrayify(digest));
+
+    const auth = {
+      enclave,
+      keyHash: keyHashHex,
+      cid,
+      expectedVersion: Number(expectedVersion),
+      relayNonce: Number(relayNonce),
+      signature
+    };
+
+    _esrLedger.push(auth);
+    await _swift.putFileContent(
+      _bucket, 'esr.authorizations.json', '',
+      Buffer.from(JSON.stringify(_esrLedger), 'utf8'));
+    await _swift.putFileContent(
+      _bucket, `esr.commit.${Number(relayNonce)}.json`, '',
+      Buffer.from(JSON.stringify(auth), 'utf8'));
+    return { relayed: true, relayNonce: Number(relayNonce) };
   }
 }
 

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

@@ -481,6 +481,40 @@ function initSwiftStreamClient() {
     return swiftStreamClient;
 }
 
+// Set as soon as the enclave object exists so the top-level catch can report a
+// failure result even when the throw happens deep inside execute().
+let currentApp = null;
+
+/**
+ * Best-effort: write a failure result so the trustedzone stops waiting.
+ *
+ * Securelock only publishes the result and its code; the trustedzone reads
+ * those and builds the signed transaction. Without them that wait runs to its
+ * timeout and the whole order stalls with no diagnosis.
+ *
+ * Guarded throughout: this runs while already handling a failure, so it must
+ * never throw or hang.
+ */
+async function reportFailure(app, err) {
+    if (!app) {
+        console.log('cannot report failure: enclave died before initialization');
+        return;
+    }
+    try {
+        // Keep a specific code if one was already set (checksum mismatch, ...).
+        if (app.task_code === undefined || app.task_code === null || app.task_code === '') {
+            app.task_code = TaskStatus.SYSTEM_ERROR;
+        }
+        if (!app.task_result) {
+            app.task_result = `ENCLAVE ERROR: ${err && err.message ? err.message : err}`;
+        }
+        await app.saveResult();
+        console.log(`failure reported (task_code=${app.task_code})`);
+    } catch (reportErr) {
+        console.log('could not report the failure result:', reportErr);
+    }
+}
+
 async function execute() {
     console.log('########################################');
     console.log('########################################');
@@ -494,6 +528,9 @@ async function execute() {
     const swiftStreamClient = initSwiftStreamClient();
 
     const app = new EtnySecureLock(swiftStreamClient);
+    // Exposed so the top-level handler can still publish a failure result if
+    // anything below throws (see reportFailure).
+    currentApp = app;
 
     // Testnet: materialize the self-signed cert/key from MR_ENCLAVE into the
     // file paths before anything reads them (harvest + decrypt). No-op on mainnet
@@ -543,5 +580,7 @@ async function execute() {
         await execute();
     } catch (e) {
         console.log(e);
+        await reportFailure(currentApp, e);
+        process.exitCode = 1;
     }
 })();

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

@@ -15,6 +15,8 @@ class TaskStatus {
     // address that was never baked into the sealed image). Reported eagerly
     // with the variable named, instead of a confusing downstream crash.
     static CONFIG_ERROR = 32;
+    static EXECUTION_TIMEOUT = 33;      // Started but produced no result within the order duration.
+    static ESR_GAS_LIMIT_EXCEEDED = 34; // ESR commits would exceed the per-order relayed-gas budget.
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethernity-cloud/sdk-js",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "A package to run ethernity cloud build scripts",
   "scripts": {
     "ecld-build": "cross-env node ./node_modules/@ethernity-cloud/sdk-js/build.js",
@@ -47,4 +47,4 @@
   },
   "author": "Alexandru Luca",
   "license": "AGPL-3.0"
-}
+}