@ethernity-cloud/sdk-js 1.5.1 → 1.5.4

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/etny_exec.js

@@ -88,24 +88,29 @@ function exec(payload, input, globals = null) {
 
         // return [TaskStatus.SUCCESS, 'TASK EXECUTED SUCCESSFULLY'];
     } catch (error) {
+        // A task returns its result by RETURNING (via ___etny_result___), not by
+        // throwing, so anything caught here is a genuine failure. In every branch
+        // deliver the FULL stack trace to the data owner AS THE RESULT (visible in
+        // their runner output) and never crash the enclave -- always return a
+        // normal [code, data] tuple so the trustedzone stops waiting. Honor the
+        // embedded-result SUCCESS (code 0) case first.
+        try {
+            if (error && error.args && error.args[0] && error.args[0][0] === 0) {
+                return [TaskStatus.SUCCESS, error.args[0][1]];
+            }
+        } catch (e) { /* fall through to failure reporting */ }
+
+        const detail = (error && (error.stack || error.message)) || String(error);
+        console.error('Error in payload execution -- full stack follows:\n' + detail);
+
         if (error instanceof ReferenceError) {
-            return [TaskStatus.SYSTEM_ERROR, error.message];
+            return [TaskStatus.SYSTEM_ERROR, 'SYSTEM_ERROR (ReferenceError): ' + detail];
         } else if (error instanceof EvalError) {
-            return [TaskStatus.KEY_ERROR, error.message];
+            return [TaskStatus.KEY_ERROR, 'KEY_ERROR (EvalError): ' + detail];
         } else if (error instanceof SyntaxError) {
-            return [TaskStatus.SYNTAX_WARNING, error.message];
-        } else if (error instanceof Error) {
-            try {
-                if (error.args[0][0] === 0) {
-                    return [TaskStatus.SUCCESS, error.args[0][1]];
-                } else {
-                    return [TaskStatus.BASE_EXCEPTION, error.args[0]];
-                }
-            } catch (e) {
-                return [TaskStatus.BASE_EXCEPTION, error.message];
-            }
+            return [TaskStatus.SYNTAX_WARNING, 'SYNTAX_WARNING (SyntaxError): ' + detail];
         } else {
-            return [TaskStatus.BASE_EXCEPTION, error.message];
+            return [TaskStatus.BASE_EXCEPTION, 'BASE_EXCEPTION: ' + detail];
         }
     }
 }

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/nodenithy/build/trustedzone/src/etny_exec.js

@@ -27,24 +27,29 @@ function exec(payload, input, globals = null) {
 
         // return [TaskStatus.SUCCESS, 'TASK EXECUTED SUCCESSFULLY'];
     } catch (error) {
+        // A task returns its result by RETURNING (via ___etny_result___), not by
+        // throwing, so anything caught here is a genuine failure. In every branch
+        // deliver the FULL stack trace to the data owner AS THE RESULT (visible in
+        // their runner output) and never crash the enclave -- always return a
+        // normal [code, data] tuple so the trustedzone stops waiting. Honor the
+        // embedded-result SUCCESS (code 0) case first.
+        try {
+            if (error && error.args && error.args[0] && error.args[0][0] === 0) {
+                return [TaskStatus.SUCCESS, error.args[0][1]];
+            }
+        } catch (e) { /* fall through to failure reporting */ }
+
+        const detail = (error && (error.stack || error.message)) || String(error);
+        console.error('Error in payload execution -- full stack follows:\n' + detail);
+
         if (error instanceof ReferenceError) {
-            return [TaskStatus.SYSTEM_ERROR, error.message];
+            return [TaskStatus.SYSTEM_ERROR, 'SYSTEM_ERROR (ReferenceError): ' + detail];
         } else if (error instanceof EvalError) {
-            return [TaskStatus.KEY_ERROR, error.message];
+            return [TaskStatus.KEY_ERROR, 'KEY_ERROR (EvalError): ' + detail];
         } else if (error instanceof SyntaxError) {
-            return [TaskStatus.SYNTAX_WARNING, error.message];
-        } else if (error instanceof Error) {
-            try {
-                if (error.args[0][0] === 0) {
-                    return [TaskStatus.SUCCESS, error.args[0][1]];
-                } else {
-                    return [TaskStatus.BASE_EXCEPTION, error.args[0]];
-                }
-            } catch (e) {
-                return [TaskStatus.BASE_EXCEPTION, error.message];
-            }
+            return [TaskStatus.SYNTAX_WARNING, 'SYNTAX_WARNING (SyntaxError): ' + detail];
         } else {
-            return [TaskStatus.BASE_EXCEPTION, error.message];
+            return [TaskStatus.BASE_EXCEPTION, 'BASE_EXCEPTION: ' + detail];
         }
     }
 }

package/nodenithy/build/validator/src/etny_exec.js

@@ -25,24 +25,29 @@ function exec(payload, input, globals = null) {
 
         // return [TaskStatus.SUCCESS, 'TASK EXECUTED SUCCESSFULLY'];
     } catch (error) {
+        // A task returns its result by RETURNING (via ___etny_result___), not by
+        // throwing, so anything caught here is a genuine failure. In every branch
+        // deliver the FULL stack trace to the data owner AS THE RESULT (visible in
+        // their runner output) and never crash the enclave -- always return a
+        // normal [code, data] tuple so the trustedzone stops waiting. Honor the
+        // embedded-result SUCCESS (code 0) case first.
+        try {
+            if (error && error.args && error.args[0] && error.args[0][0] === 0) {
+                return [TaskStatus.SUCCESS, error.args[0][1]];
+            }
+        } catch (e) { /* fall through to failure reporting */ }
+
+        const detail = (error && (error.stack || error.message)) || String(error);
+        console.error('Error in payload execution -- full stack follows:\n' + detail);
+
         if (error instanceof ReferenceError) {
-            return [TaskStatus.SYSTEM_ERROR, error.message];
+            return [TaskStatus.SYSTEM_ERROR, 'SYSTEM_ERROR (ReferenceError): ' + detail];
         } else if (error instanceof EvalError) {
-            return [TaskStatus.KEY_ERROR, error.message];
+            return [TaskStatus.KEY_ERROR, 'KEY_ERROR (EvalError): ' + detail];
         } else if (error instanceof SyntaxError) {
-            return [TaskStatus.SYNTAX_WARNING, error.message];
-        } else if (error instanceof Error) {
-            try {
-                if (error.args[0][0] === 0) {
-                    return [TaskStatus.SUCCESS, error.args[0][1]];
-                } else {
-                    return [TaskStatus.BASE_EXCEPTION, error.args[0]];
-                }
-            } catch (e) {
-                return [TaskStatus.BASE_EXCEPTION, error.message];
-            }
+            return [TaskStatus.SYNTAX_WARNING, 'SYNTAX_WARNING (SyntaxError): ' + detail];
         } else {
-            return [TaskStatus.BASE_EXCEPTION, error.message];
+            return [TaskStatus.BASE_EXCEPTION, 'BASE_EXCEPTION: ' + detail];
         }
     }
 }