@ethernity-cloud/sdk-js 1.5.14 → 1.5.15

package/info.js

@@ -40,17 +40,17 @@ const NETWORKS = {
     type: 'mainnet', chainId: 8995, rpc: 'https://core.bloxberg.org',
     protocol: '0x549A6E06BB2084100148D50F51CF77a3436C3Ae7',
     imageRegistry: '0x15D73a742529C3fb11f3FA32EF7f0CC3870ACA31',
-    esr: '0x39d6f2A98f7FFF9866AAaa0EAa9aEd8bcf6f728E',
+    esr: '0xDaFa1e3CAF370765275d853cd86dDEd671Ce29Dd',
   },
   BLOXBERG_TESTNET: {
     type: 'testnet', chainId: 8995, rpc: 'https://core.bloxberg.org',
     protocol: '0x02882F03097fE8cD31afbdFbB5D72a498B41112c',
     imageRegistry: '0x15D73a742529C3fb11f3FA32EF7f0CC3870ACA31',
-    esr: '0xdfDD088b9cB998280685aF4E93DC0b37952aB08e',
+    esr: '0xD7a7Cb9cbb0Ca1adFb2B8405382f299EA1c6132f',
   },
   LITVM_LITEFORGE: {
     type: 'testnet', chainId: 0, rpc: 'https://liteforge.rpc.caldera.xyz/infra-partner-http',
-    protocol: '', imageRegistry: '', esr: '0x71a4bb5AC4c8F37ea0d9394fB29bBC06eEC28000',
+    protocol: '', imageRegistry: '', esr: '0x213aA794F29EA717B9226dF81F7317334Ac36169',
   },
 };
 
@@ -202,8 +202,9 @@ async function esrQuery(prov, name, net, args) {
     return {
       enclave: args.enclave, key: args.key, nonce: n,
       note: 'last accepted idempotency nonce (PUBLIC data, free eth_call); '
-        + '0 = no guarded commit yet. Pass any greater value to commit() to '
-        + 'guard against duplicates; the contract enforces in-order per key',
+        + '0 = no guarded commit yet. Pass EXACTLY nonce + 1 to commit() to '
+        + 'guard against duplicates; the contract enforces the sequence '
+        + 'strictly per key (no gaps, no reuse)',
     };
   }
   if (sub === 'state') {

package/nodenithy/build/securelock/.ecld-test-stage/ecld_state.js

@@ -435,14 +435,14 @@ class StateRegistry {
 
   /**
    * The last accepted idempotency nonce for `key` (0 if none was ever used).
-   * A dApp that wants duplicate suppression reads this, picks a greater value
-   * (e.g. +1, or a timestamp), and passes it to commit(..., { nonce }).
+   * A dApp that wants duplicate suppression reads this and passes
+   * getNonce(key) + 1 to commit(..., { nonce }) -- the contract accepts
+   * EXACTLY the next value in sequence, nothing else.
    *
    * The nonce is PUBLIC data: the registry records it on-chain next to the
    * version, and anyone can read it with a free eth_call (getNonce) -- so no
    * read-ACL applies here, and web3 clients see the same value via the
-   * runner's esrNonce. Use opaque monotonic values (a counter or a
-   * timestamp), never secret-derived ones.
+   * runner's esrNonce.
    *
    * Reads the chain (authoritative, post-relay), merged with this task's
    * own accepted commits so `commit(..., { nonce: N }); getNonce()` returns N
@@ -463,9 +463,10 @@ class StateRegistry {
   async commit(key, mutate, opts = 3) {
     // Back-compat: the third arg used to be `attempts` (a number); it may now
     // also be { attempts, nonce }. `nonce` is an idempotency guard the dApp
-    // controls: it must be STRICTLY GREATER than the last accepted nonce for
-    // the key (see getNonce). A duplicate or stale nonce throws
-    // StateNonceError and the state is NOT changed.
+    // controls: it must be EXACTLY the last accepted nonce for the key + 1
+    // (see getNonce; the sequence is 1, 2, 3, ... with no gaps and no
+    // reuse). Anything else throws StateNonceError and the state is NOT
+    // changed.
     const { attempts = 3, nonce = null } =
       typeof opts === 'number' ? { attempts: opts } : (opts || {});
     const transform = async (acl, data) => {
@@ -502,10 +503,11 @@ class StateRegistry {
         const n = Math.trunc(nonce);
         // eslint-disable-next-line no-await-in-loop
         const storedNonce = await this.getNonce(key);
-        if (n <= storedNonce) {
+        if (n !== storedNonce + 1) {
           throw new StateNonceError(
-            `nonce ${n} was already used for state key '${key}' (last accepted: ` +
-              `${storedNonce}); duplicate commit suppressed, state unchanged`
+            `nonce ${n} is out of sequence for state key '${key}' (last accepted: ` +
+              `${storedNonce}, expected: ${storedNonce + 1}); commit suppressed, ` +
+              'state unchanged'
           );
         }
       }

package/nodenithy/build/securelock/.ecld-test-stage/esr_local.js

@@ -128,9 +128,9 @@ class MemContract {
   }
 
   // ---- the on-chain commitFor, applied locally ----
-  // Idempotency nonces are enforced IN ORDER per (enclave, key), exactly like
-  // the contract: nonce != 0 must be strictly greater than the stored value
-  // (gaps allowed) or NonceOutOfOrder is thrown; nonce == 0 preserves it.
+  // Idempotency nonces are enforced strictly sequentially per (enclave, key),
+  // exactly like the contract: nonce != 0 must be EXACTLY the stored value + 1
+  // (no gaps, no reuse) or NonceOutOfOrder is thrown; nonce == 0 preserves it.
   applyCommit(enclave, keyHash, cid, expectedVersion, nonce = 0) {
     const k = key(enclave, keyHash);
     const entry = this._entries[k] || {};
@@ -141,7 +141,7 @@ class MemContract {
     let storedNonce = Number(entry.nonce || 0);
     const n = Number(nonce || 0);
     if (n !== 0) {
-      if (n <= storedNonce) {
+      if (n !== storedNonce + 1) {
         throw new Error(`NonceOutOfOrder: stored ${storedNonce}, given ${n}`);
       }
       storedNonce = n;

package/nodenithy/build/securelock/.ecld-test-stage/nonce_ladder.js

@@ -38,43 +38,55 @@ async function main() {
   st = await r.get('counter');
   if (st.n !== 1) throw new Error('duplicate mutated state');
 
-  // 3. next nonce and a gap both accepted (in order, gaps allowed)
+  // 3. exactly +1 accepted; a gap (skip-ahead) is rejected
   await r.commit('counter', (s) => ({ n: s.n + 1 }), { nonce: 2 });
-  await r.commit('counter', (s) => ({ n: s.n + 1 }), { nonce: 10 });
   st = await r.get('counter');
-  if (st.n !== 3 || (await r.getNonce('counter')) !== 10) throw new Error('step3');
-  console.log('3. in-order nonces 2 then 10 (gap) ok, getNonce()==10');
+  if (st.n !== 2 || (await r.getNonce('counter')) !== 2) throw new Error('step3a');
+  threw = false;
+  try {
+    await r.commit('counter', (s) => ({ n: s.n + 1 }), { nonce: 10 });
+  } catch (e) {
+    if (!(e instanceof StateNonceError)) throw e;
+    threw = true;
+  }
+  if (!threw) throw new Error('gap accepted');
+  console.log('3. nonce=2 (+1) accepted, gap nonce=10 rejected ok');
 
   // 4. nonce-less commit preserves the stored nonce
   await r.commit('counter', (s) => ({ ...s, note: 'free' }));
-  if ((await r.getNonce('counter')) !== 10) throw new Error('step4');
+  if ((await r.getNonce('counter')) !== 2) throw new Error('step4');
   console.log('4. nonce-less commit preserves stored nonce ok');
 
-  // 5. out-of-order (lower, non-zero) nonce rejected
+  // 5. stale (reused) nonce rejected; the exact next one still works
   threw = false;
   try {
-    await r.commit('counter', (s) => s, { nonce: 5 });
+    await r.commit('counter', (s) => s, { nonce: 1 });
   } catch (e) {
     if (!(e instanceof StateNonceError)) throw e;
     threw = true;
   }
   if (!threw) throw new Error('stale accepted');
-  console.log('5. out-of-order nonce=5 rejected ok');
+  await r.commit('counter', (s) => ({ ...s, step: 3 }), { nonce: 3 });
+  if ((await r.getNonce('counter')) !== 3) throw new Error('step5');
+  console.log('5. stale nonce=1 rejected, next nonce=3 accepted ok');
 
   // 6. contract-side (registry) enforcement, bypassing the SDK pre-check
   const mc = new MemContract(null);
   const kh = '0x' + '11'.repeat(32);
-  mc.applyCommit('0xE', kh, 'cid1', 0, 7);
-  threw = false;
-  try {
-    mc.applyCommit('0xE', kh, 'cid2', 1, 7);
-  } catch (e) {
-    if (!/NonceOutOfOrder/.test(String(e.message))) throw e;
-    threw = true;
-    console.log('6. contract-side in-order enforcement ok:', e.message);
+  mc.applyCommit('0xE', kh, 'cid1', 0, 1);
+  for (const bad of [1, 3]) { // reuse and gap both violate the +1 rule
+    threw = false;
+    try {
+      mc.applyCommit('0xE', kh, 'cid2', 1, bad);
+    } catch (e) {
+      if (!/NonceOutOfOrder/.test(String(e.message))) throw e;
+      threw = true;
+    }
+    if (!threw) throw new Error('registry accepted nonce ' + bad);
   }
-  if (!threw) throw new Error('registry accepted stale nonce');
-  if (Number(await mc.getNonce('0xE', kh)) !== 7) throw new Error('getNonce view');
+  mc.applyCommit('0xE', kh, 'cid2', 1, 2);
+  if (Number(await mc.getNonce('0xE', kh)) !== 2) throw new Error('getNonce view');
+  console.log('6. contract-side +1 enforcement ok (reuse and gap both revert)');
 
   // 7. chain-first getNonce after a task-memo wipe (fresh process/other task)
   delete require.cache[require.resolve(path.join(__dirname, 'ecld_state.js'))];
@@ -82,8 +94,8 @@ async function main() {
   esrLocal.install(ecld2, { caller: A, filePrefix: 'st' });
   const r2 = new ecld2.StateRegistry();
   const n2 = await r2.getNonce('counter');
-  if (n2 !== 10) throw new Error('step7 got ' + n2);
-  console.log('7. chain-first getNonce()==10 after reload (public read, no memo) ok');
+  if (n2 !== 3) throw new Error('step7 got ' + n2);
+  console.log('7. chain-first getNonce()==3 after reload (public read, no memo) ok');
 
   // 8. public: nonce read needs no ACL -- content read stays denied for B
   delete require.cache[require.resolve(path.join(__dirname, 'ecld_state.js'))];

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

@@ -435,14 +435,14 @@ class StateRegistry {
 
   /**
    * The last accepted idempotency nonce for `key` (0 if none was ever used).
-   * A dApp that wants duplicate suppression reads this, picks a greater value
-   * (e.g. +1, or a timestamp), and passes it to commit(..., { nonce }).
+   * A dApp that wants duplicate suppression reads this and passes
+   * getNonce(key) + 1 to commit(..., { nonce }) -- the contract accepts
+   * EXACTLY the next value in sequence, nothing else.
    *
    * The nonce is PUBLIC data: the registry records it on-chain next to the
    * version, and anyone can read it with a free eth_call (getNonce) -- so no
    * read-ACL applies here, and web3 clients see the same value via the
-   * runner's esrNonce. Use opaque monotonic values (a counter or a
-   * timestamp), never secret-derived ones.
+   * runner's esrNonce.
    *
    * Reads the chain (authoritative, post-relay), merged with this task's
    * own accepted commits so `commit(..., { nonce: N }); getNonce()` returns N
@@ -463,9 +463,10 @@ class StateRegistry {
   async commit(key, mutate, opts = 3) {
     // Back-compat: the third arg used to be `attempts` (a number); it may now
     // also be { attempts, nonce }. `nonce` is an idempotency guard the dApp
-    // controls: it must be STRICTLY GREATER than the last accepted nonce for
-    // the key (see getNonce). A duplicate or stale nonce throws
-    // StateNonceError and the state is NOT changed.
+    // controls: it must be EXACTLY the last accepted nonce for the key + 1
+    // (see getNonce; the sequence is 1, 2, 3, ... with no gaps and no
+    // reuse). Anything else throws StateNonceError and the state is NOT
+    // changed.
     const { attempts = 3, nonce = null } =
       typeof opts === 'number' ? { attempts: opts } : (opts || {});
     const transform = async (acl, data) => {
@@ -502,10 +503,11 @@ class StateRegistry {
         const n = Math.trunc(nonce);
         // eslint-disable-next-line no-await-in-loop
         const storedNonce = await this.getNonce(key);
-        if (n <= storedNonce) {
+        if (n !== storedNonce + 1) {
           throw new StateNonceError(
-            `nonce ${n} was already used for state key '${key}' (last accepted: ` +
-              `${storedNonce}); duplicate commit suppressed, state unchanged`
+            `nonce ${n} is out of sequence for state key '${key}' (last accepted: ` +
+              `${storedNonce}, expected: ${storedNonce + 1}); commit suppressed, ` +
+              'state unchanged'
           );
         }
       }

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

@@ -128,9 +128,9 @@ class MemContract {
   }
 
   // ---- the on-chain commitFor, applied locally ----
-  // Idempotency nonces are enforced IN ORDER per (enclave, key), exactly like
-  // the contract: nonce != 0 must be strictly greater than the stored value
-  // (gaps allowed) or NonceOutOfOrder is thrown; nonce == 0 preserves it.
+  // Idempotency nonces are enforced strictly sequentially per (enclave, key),
+  // exactly like the contract: nonce != 0 must be EXACTLY the stored value + 1
+  // (no gaps, no reuse) or NonceOutOfOrder is thrown; nonce == 0 preserves it.
   applyCommit(enclave, keyHash, cid, expectedVersion, nonce = 0) {
     const k = key(enclave, keyHash);
     const entry = this._entries[k] || {};
@@ -141,7 +141,7 @@ class MemContract {
     let storedNonce = Number(entry.nonce || 0);
     const n = Number(nonce || 0);
     if (n !== 0) {
-      if (n <= storedNonce) {
+      if (n !== storedNonce + 1) {
         throw new Error(`NonceOutOfOrder: stored ${storedNonce}, given ${n}`);
       }
       storedNonce = n;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethernity-cloud/sdk-js",
-  "version": "1.5.14",
+  "version": "1.5.15",
   "description": "A package to run ethernity cloud build scripts",
   "scripts": {
     "ecld-build": "cross-env node ./node_modules/@ethernity-cloud/sdk-js/build.js",