@ethernity-cloud/sdk-js 1.4.0 → 1.5.0

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

@@ -1,201 +1,211 @@
-const fs = require("fs");
-const elliptic = require('elliptic');
-const crypto = require('crypto');
-const rs = require('jsrsasign');
-const ECKey = require('ec-key');
-const curve = new elliptic.ec('p384');
-const ascii85 = require('ascii85');
-const ethSigUtil = require('@metamask/eth-sig-util');
-const {createHash} = require('crypto');
-
-function sha256(content) {
-    return createHash('sha256').update(content).digest('hex');
-}
-
-function fileChecksum(file) {
-    const fileContent = fs.readFileSync(file, 'utf8');
-    return sha256(fileContent);
-}
-
-async function fileChecksumFromSwiftStream(swiftStreamClient, bucketName, fileName) {
-    const fileContent = await swiftStreamClient.getFileContent(bucketName, fileName);
-    //console.log(fileContent);
-    return sha256(fileContent);
-}
-
-const getPEMFromPublicFile = (publicKeyPath) => {
-    const publicKey = fs.readFileSync(publicKeyPath, 'utf8');
-    return crypto.createPublicKey(publicKey).export({type: 'spki', format: 'pem'});
-}
-
-const getPEMFromPublic = (publicKey) => {
-    return crypto.createPublicKey(publicKey).export({type: 'spki', format: 'pem'});
-}
-
-const loadCertificate = (certificate) => {
-    //console.log(certificate)
-    const publicKeyPEM = getPEMFromPublic(certificate);
-    const key = new ECKey(publicKeyPEM, 'pem');
-    //console.log(key);
-    return key;
-}
-
-function getPrivatePointFromPrivateKey(privateKeyFile) {
-    let privateKey = fs.readFileSync(privateKeyFile, 'utf8');
-    //console.log(privateKey);
-    let privateKeyHex = rs.KEYUTIL.getKey(privateKey).prvKeyHex;
-    const privateKeyObject = curve.keyFromPrivate(privateKeyHex, 'hex');
-    return privateKeyObject.getPrivate();
-}
-
-const generatePublicKey = (x, y) => {
-    const pub = {x: x, y};
-    return curve.keyFromPublic(pub, 'hex');
-}
-
-function getPublicPointFromCoords(x, y) {
-    const publicKey = generatePublicKey(x, y);
-    return publicKey.getPublic();
-}
-
-function ecc_point_to_256_bit_key(point) {
-    const value = point.getX().toString() + point.getY().toString();
-    const hash = crypto.createHash('sha256');
-    hash.update(value);
-    return hash.digest();
-}
-
-function encryptedDataToBase64Json(encryptedMsg) {
-    const key = curve.keyFromPublic(encryptedMsg.cipherTextPublicKey, 'hex');
-    const jsonObj = {
-        ciphertext: encryptedMsg.ciphertext.toString('hex'),
-        nonce: encryptedMsg.nonce.toString('hex'),
-        authTag: encryptedMsg.authTag.toString('hex'),
-        x: key.getPublic().getX(),
-        y: key.getPublic().getY()
-    };
-    const jsonString = JSON.stringify(jsonObj);
-    const binaryData = Buffer.from(jsonString, 'utf8');
-    return binaryData.toString('base64');
-}
-
-function encryptedDataFromBase64Json(base64Data) {
-    // decode the base64-encoded string back to a JSON string
-    const decodedJsonData = Buffer.from(base64Data, 'base64').toString('utf8');
-    return JSON.parse(decodedJsonData);
-}
-
-
-function encrypt(certificate, message) {
-    const key = loadCertificate(certificate);
-    return encrypt_ecc(message, generatePublicKey(key.x, key.y));
-}
-
-function encrypt_ecc(msg, publicKey) {
-    const cipherTextPrivateKey = crypto.randomBytes(32);
-    const sharedEccKey = publicKey.getPublic().mul(cipherTextPrivateKey);
-    const secretKey = ecc_point_to_256_bit_key(sharedEccKey);
-    const iv = crypto.randomBytes(16);
-    const cipher = crypto.createCipheriv('aes-256-gcm', secretKey, iv);
-    let encrypted = cipher.update(msg, 'utf8', 'hex');
-    encrypted += cipher.final('hex');
-    const cipherTextPublicKey = curve.g.mul(cipherTextPrivateKey);
-    return {
-        ciphertext: encrypted,
-        secretKey: secretKey,
-        nonce: iv,
-        authTag: cipher.getAuthTag().toString("hex"),
-        cipherTextPublicKey: cipherTextPublicKey.encode('hex')
-    };
-}
-
-function decrypt(privateKeyFile, encryptedMsg) {
-    //console.log(privateKeyFile);
-    const privatePoint = getPrivatePointFromPrivateKey(privateKeyFile);
-    return decrypt_ecc(encryptedMsg, privatePoint);
-}
-
-function decrypt_ecc(encryptedMsg, privatePoint) {
-    try {
-        const {ciphertext, nonce, authTag, x, y} = encryptedMsg;
-        const publicPoint = getPublicPointFromCoords(`${x}`, `${y}`);
-        const sharedEccKey = publicPoint.mul(privatePoint);
-        const secretKey = ecc_point_to_256_bit_key(sharedEccKey);
-
-        const decipher = crypto.createDecipheriv('aes-256-gcm', secretKey, Buffer.from(nonce, 'hex'));
-        decipher.setAuthTag(Buffer.from(authTag, 'hex'));
-        let decrypted = decipher.update(ciphertext, 'hex', 'utf8');
-        decrypted += decipher.final('utf8');
-        return decrypted;
-    } catch (e) {
-        console.log(`Error while decrypting ECC:`, e.message);
-        return false;
-    }
-}
-
-function hexToBytes(hexStr) {
-    if (hexStr.startsWith("0x")) {
-        hexStr = hexStr.slice(2);
-    }
-    return Buffer.from(hexStr, "hex");
-}
-
-function encryptWithPublicKey(publicKey, data) {
-    // Returned object contains 4 properties: version, ephemPublicKey, nonce, ciphertext
-    // Each contains data encoded using base64, version is always the same string
-    const enc = ethSigUtil.encrypt({
-        publicKey: hexToBytes(publicKey).toString('base64'),
-        data: ascii85.encode(Buffer.from(data)).toString(),
-        version: 'x25519-xsalsa20-poly1305',
-    });
-
-    // We want to store the data in smart contract, therefore we concatenate them
-    // into single Buffer
-    const buf = Buffer.concat([
-        Buffer.from(enc.ephemPublicKey, 'base64'),
-        Buffer.from(enc.nonce, 'base64'),
-        Buffer.from(enc.ciphertext, 'base64'),
-    ]);
-
-    // In smart contract we are using `bytes[112]` variable (fixed size byte array)
-    // you might need to use `bytes` type for dynamic sized array
-    // We are also using ethers.js which requires type `number[]` when passing data
-    // for argument of type `bytes` to the smart contract function
-    // Next line just converts the buffer to `number[]` required by contract function
-    // THIS LINE IS USED IN OUR ORIGINAL CODE:
-    // return buf.toJSON().data;
-
-    // Return just the Buffer to make the function directly compatible with decryptData function
-    return buf;
-}
-
-// (async () => {
-//     try {
-//         const message = 'testabc1';
-//         console.log('initial message:', message);
-//         const publicKeyPEM = getPEMFromPublic('./app/cert1-ca1-clean.crt');
-//         const ECKey = require('ec-key');
-//         const key = new ECKey(publicKeyPEM, 'pem');
-//         const encrypted_message = encrypt(key.x, key.y, message);
-//         console.log(encrypted_message);
-//         console.log(encryptedDataToBase64Json(encrypted_message));
-//         //
-//         // const encrypted_message = 'eyJjaXBoZXJ0ZXh0IjoiZTYzZTcyNDY0MWY4YWRmN2QyNjNmMTI0ZGYxZTdlYzZmNGM5NGU1NCIsIm5vbmNlIjoiYmE0YWU5YjMyOWFhZWRiM2ViZTM5MGU4YTY3YWFiNmMiLCJhdXRoVGFnIjoiOGU2NmI4NTVmNTE3N2E0NzZlMjkwNTE3Y2Q2ZDE3ZmUiLCJ4IjoiN2E1MjhhNGI5YzAzODM4Mjc0ZmFiYzVlM2RiOWQ2ZWFiNzBiZTFiMDA3YWJiOTcyYzI0YmFhNGE1ZmI4OGJjNTVmNDVlNGNkMjZjY2NhNTFhOTk3OGZkNDRhZmE1YjQ0IiwieSI6IjE5M2NjMWYwMzVmOGMxZjEzNGU4MTEzOGIyOTRiODBiZWQyYjkyMzdkZmIyOTMyOGRjOTg1MzlmMjhkNjIzMTJiYTQ2OTU2NDFkYjIyNjk0ZWUyNGFjZjQ4MjBiZDlhMSJ9';
-//         // const messageDecrypted = decrypt('./app/cert1-ca1-clean.key', encryptedDataToBase64Json(encrypted_message));
-//         // console.log('decrypted message:', messageDecrypted);
-//     } catch (e) {
-//         console.log(e);
-//     }
-//
-// })();
-
-module.exports = {
-    encryptedDataFromBase64Json,
-    encryptedDataToBase64Json,
-    encryptWithPublicKey,
-    decrypt,
-    encrypt,
-    sha256,
-    fileChecksum,
-    fileChecksumFromSwiftStream
-};
+const fs = require("fs");
+const elliptic = require('elliptic');
+const crypto = require('crypto');
+const rs = require('jsrsasign');
+const ECKey = require('ec-key');
+const curve = new elliptic.ec('p384');
+const ascii85 = require('ascii85');
+const ethSigUtil = require('@metamask/eth-sig-util');
+const {createHash} = require('crypto');
+
+function sha256(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+
+function fileChecksum(file) {
+    const fileContent = fs.readFileSync(file, 'utf8');
+    return sha256(fileContent);
+}
+
+async function fileChecksumFromSwiftStream(swiftStreamClient, bucketName, fileName) {
+    const fileContent = await swiftStreamClient.getFileContent(bucketName, fileName);
+    //console.log(fileContent);
+    return sha256(fileContent);
+}
+
+const getPEMFromPublicFile = (publicKeyPath) => {
+    const publicKey = fs.readFileSync(publicKeyPath, 'utf8');
+    return crypto.createPublicKey(publicKey).export({type: 'spki', format: 'pem'});
+}
+
+const getPEMFromPublic = (publicKey) => {
+    return crypto.createPublicKey(publicKey).export({type: 'spki', format: 'pem'});
+}
+
+const loadCertificate = (certificate) => {
+    //console.log(certificate)
+    const publicKeyPEM = getPEMFromPublic(certificate);
+    const key = new ECKey(publicKeyPEM, 'pem');
+    //console.log(key);
+    return key;
+}
+
+// Accepts EITHER a path to a PEM file or the PEM text itself.
+//
+// mainnet keeps passing a path: CAS injects the key into key_file after
+// attestation, and that flow is unchanged. On testnet the enclave self-derives
+// its key and now holds it only in memory (never writes it), so it passes the
+// PEM straight through -- nothing about the key ever reaches the filesystem.
+// Detection is on the PEM header, not on file existence, so a path that does
+// not exist still fails loudly instead of being mistaken for key material.
+function getPrivatePointFromPrivateKey(privateKeyOrFile) {
+    const value = String(privateKeyOrFile || '');
+    const privateKey = value.includes('-----BEGIN')
+        ? value
+        : fs.readFileSync(value, 'utf8');
+    let privateKeyHex = rs.KEYUTIL.getKey(privateKey).prvKeyHex;
+    const privateKeyObject = curve.keyFromPrivate(privateKeyHex, 'hex');
+    return privateKeyObject.getPrivate();
+}
+
+const generatePublicKey = (x, y) => {
+    const pub = {x: x, y};
+    return curve.keyFromPublic(pub, 'hex');
+}
+
+function getPublicPointFromCoords(x, y) {
+    const publicKey = generatePublicKey(x, y);
+    return publicKey.getPublic();
+}
+
+function ecc_point_to_256_bit_key(point) {
+    const value = point.getX().toString() + point.getY().toString();
+    const hash = crypto.createHash('sha256');
+    hash.update(value);
+    return hash.digest();
+}
+
+function encryptedDataToBase64Json(encryptedMsg) {
+    const key = curve.keyFromPublic(encryptedMsg.cipherTextPublicKey, 'hex');
+    const jsonObj = {
+        ciphertext: encryptedMsg.ciphertext.toString('hex'),
+        nonce: encryptedMsg.nonce.toString('hex'),
+        authTag: encryptedMsg.authTag.toString('hex'),
+        x: key.getPublic().getX(),
+        y: key.getPublic().getY()
+    };
+    const jsonString = JSON.stringify(jsonObj);
+    const binaryData = Buffer.from(jsonString, 'utf8');
+    return binaryData.toString('base64');
+}
+
+function encryptedDataFromBase64Json(base64Data) {
+    // decode the base64-encoded string back to a JSON string
+    const decodedJsonData = Buffer.from(base64Data, 'base64').toString('utf8');
+    return JSON.parse(decodedJsonData);
+}
+
+
+function encrypt(certificate, message) {
+    const key = loadCertificate(certificate);
+    return encrypt_ecc(message, generatePublicKey(key.x, key.y));
+}
+
+function encrypt_ecc(msg, publicKey) {
+    const cipherTextPrivateKey = crypto.randomBytes(32);
+    const sharedEccKey = publicKey.getPublic().mul(cipherTextPrivateKey);
+    const secretKey = ecc_point_to_256_bit_key(sharedEccKey);
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-gcm', secretKey, iv);
+    let encrypted = cipher.update(msg, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    const cipherTextPublicKey = curve.g.mul(cipherTextPrivateKey);
+    return {
+        ciphertext: encrypted,
+        secretKey: secretKey,
+        nonce: iv,
+        authTag: cipher.getAuthTag().toString("hex"),
+        cipherTextPublicKey: cipherTextPublicKey.encode('hex')
+    };
+}
+
+function decrypt(privateKeyFile, encryptedMsg) {
+    //console.log(privateKeyFile);
+    const privatePoint = getPrivatePointFromPrivateKey(privateKeyFile);
+    return decrypt_ecc(encryptedMsg, privatePoint);
+}
+
+function decrypt_ecc(encryptedMsg, privatePoint) {
+    try {
+        const {ciphertext, nonce, authTag, x, y} = encryptedMsg;
+        const publicPoint = getPublicPointFromCoords(`${x}`, `${y}`);
+        const sharedEccKey = publicPoint.mul(privatePoint);
+        const secretKey = ecc_point_to_256_bit_key(sharedEccKey);
+
+        const decipher = crypto.createDecipheriv('aes-256-gcm', secretKey, Buffer.from(nonce, 'hex'));
+        decipher.setAuthTag(Buffer.from(authTag, 'hex'));
+        let decrypted = decipher.update(ciphertext, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    } catch (e) {
+        console.log(`Error while decrypting ECC:`, e.message);
+        return false;
+    }
+}
+
+function hexToBytes(hexStr) {
+    if (hexStr.startsWith("0x")) {
+        hexStr = hexStr.slice(2);
+    }
+    return Buffer.from(hexStr, "hex");
+}
+
+function encryptWithPublicKey(publicKey, data) {
+    // Returned object contains 4 properties: version, ephemPublicKey, nonce, ciphertext
+    // Each contains data encoded using base64, version is always the same string
+    const enc = ethSigUtil.encrypt({
+        publicKey: hexToBytes(publicKey).toString('base64'),
+        data: ascii85.encode(Buffer.from(data)).toString(),
+        version: 'x25519-xsalsa20-poly1305',
+    });
+
+    // We want to store the data in smart contract, therefore we concatenate them
+    // into single Buffer
+    const buf = Buffer.concat([
+        Buffer.from(enc.ephemPublicKey, 'base64'),
+        Buffer.from(enc.nonce, 'base64'),
+        Buffer.from(enc.ciphertext, 'base64'),
+    ]);
+
+    // In smart contract we are using `bytes[112]` variable (fixed size byte array)
+    // you might need to use `bytes` type for dynamic sized array
+    // We are also using ethers.js which requires type `number[]` when passing data
+    // for argument of type `bytes` to the smart contract function
+    // Next line just converts the buffer to `number[]` required by contract function
+    // THIS LINE IS USED IN OUR ORIGINAL CODE:
+    // return buf.toJSON().data;
+
+    // Return just the Buffer to make the function directly compatible with decryptData function
+    return buf;
+}
+
+// (async () => {
+//     try {
+//         const message = 'testabc1';
+//         console.log('initial message:', message);
+//         const publicKeyPEM = getPEMFromPublic('./app/cert1-ca1-clean.crt');
+//         const ECKey = require('ec-key');
+//         const key = new ECKey(publicKeyPEM, 'pem');
+//         const encrypted_message = encrypt(key.x, key.y, message);
+//         console.log(encrypted_message);
+//         console.log(encryptedDataToBase64Json(encrypted_message));
+//         //
+//         // const encrypted_message = 'eyJjaXBoZXJ0ZXh0IjoiZTYzZTcyNDY0MWY4YWRmN2QyNjNmMTI0ZGYxZTdlYzZmNGM5NGU1NCIsIm5vbmNlIjoiYmE0YWU5YjMyOWFhZWRiM2ViZTM5MGU4YTY3YWFiNmMiLCJhdXRoVGFnIjoiOGU2NmI4NTVmNTE3N2E0NzZlMjkwNTE3Y2Q2ZDE3ZmUiLCJ4IjoiN2E1MjhhNGI5YzAzODM4Mjc0ZmFiYzVlM2RiOWQ2ZWFiNzBiZTFiMDA3YWJiOTcyYzI0YmFhNGE1ZmI4OGJjNTVmNDVlNGNkMjZjY2NhNTFhOTk3OGZkNDRhZmE1YjQ0IiwieSI6IjE5M2NjMWYwMzVmOGMxZjEzNGU4MTEzOGIyOTRiODBiZWQyYjkyMzdkZmIyOTMyOGRjOTg1MzlmMjhkNjIzMTJiYTQ2OTU2NDFkYjIyNjk0ZWUyNGFjZjQ4MjBiZDlhMSJ9';
+//         // const messageDecrypted = decrypt('./app/cert1-ca1-clean.key', encryptedDataToBase64Json(encrypted_message));
+//         // console.log('decrypted message:', messageDecrypted);
+//     } catch (e) {
+//         console.log(e);
+//     }
+//
+// })();
+
+module.exports = {
+    encryptedDataFromBase64Json,
+    encryptedDataToBase64Json,
+    encryptWithPublicKey,
+    decrypt,
+    encrypt,
+    sha256,
+    fileChecksum,
+    fileChecksumFromSwiftStream
+};

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

@@ -34,7 +34,29 @@ function ___etny_result___(data) {
     return [0, data];
 }
 
+// Names of *_ADDRESS-style enclave config vars that are set but EMPTY.
+// The enclave is sealed: env can only come from the image, so a present-but-
+// empty required value is always a build/render defect, never a runtime
+// choice. ESR_* vars only exist when the project enabled ESR at build time.
+function emptyRequiredConfig() {
+    const required = ['ESR_CONTRACT_ADDRESS'];
+    return required.filter(
+        (name) => name in process.env && !String(process.env[name]).trim()
+    );
+}
+
 function executeTask(payload, input) {
+    const missing = emptyRequiredConfig();
+    if (missing.length) {
+        return [
+            TaskStatus.CONFIG_ERROR,
+            'ENCLAVE CONFIG ERROR: required value(s) empty inside the enclave: ' +
+            missing.join(', ') +
+            ' | The enclave is sealed, so this value had to be baked at build' +
+            ' time and was not. Re-run ecld-build (it validates ESR config)' +
+            ' and republish.'
+        ];
+    }
     if (backendImportError !== null) {
         return [
             TaskStatus.IMPORT_ERROR,

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

@@ -24,6 +24,7 @@ const contract_abi = require('./pox_abi');
 const image_registry_abi = require('./image_registry_abi');
 const {sha256} = require("./etny_crypto");
 const {generateCertFromMrEnclave} = require("./self_sign");
+const esr_wallet = require("./esr_wallet");
 
 // Baked per network by CI (render_network.sh): "mainnet" | "testnet". On testnet
 // the enclave self-signs its cert from MR_ENCLAVE (non-CAS mode); on mainnet the
@@ -43,6 +44,10 @@ class EtnySecureLock {
 
     setInitializers() {
         this.is_valid_client_data = true;
+        // Testnet holds the self-derived identity key HERE, in memory only, and
+        // never writes it. Stays null on mainnet, where CAS injects the key into
+        // key_file and every consumer reads that path exactly as before.
+        this.identity_private_key_pem = null;
         this.key_file = "/private/__ENCLAVE_NAME_SECURELOCK__/key.pem";
         this.cert_file = "/app/__ENCLAVE_NAME_SECURELOCK__/cert.pem";
         this.pub_cert_file = "/app/__ENCLAVE_NAME_SECURELOCK__/enclave_pub_cert.pem";
@@ -230,7 +235,7 @@ class EtnySecureLock {
             const encryptedBase64 = await this.swiftStreamService.getFileContent(bucketName, objectName);
 
             const encryptedTuple = etny_crypto.encryptedDataFromBase64Json(encryptedBase64);
-            const decryptedResult = etny_crypto.decrypt(this.key_file, encryptedTuple);
+            const decryptedResult = etny_crypto.decrypt(this.privateKeyMaterial(), encryptedTuple);
             return decryptedResult.toString();
         } catch (e) {
             console.log(`Failed to get ${objectName} file`);
@@ -282,37 +287,68 @@ class EtnySecureLock {
     }
 
     resetPrivateCertFile() {
-        //console.log('Resetting the cert file');
+        // Wipes the CAS-injected key from disk after it has been loaded
+        // (mainnet PRODUCTION hygiene). On testnet the key was never written --
+        // it lives only in memory -- so there is nothing on disk to wipe and the
+        // truncate/read below would throw on a file that does not exist.
+        //
+        // The in-memory key is deliberately NOT cleared here: waitForPayloadAndInput
+        // still needs it later to decrypt the payload/input, which runs after
+        // create() has called this. Clearing it would break the task on testnet only.
+        if (this.identity_private_key_pem) {
+            return;
+        }
         try {
-            // const fd = fs.openSync(this.private_key_file, 'w+');
             fs.truncate(this.key_file, 0, function () {
                 //console.log('Private certificate file was cleaned.')
             });
-            // fs.closeSync(fd);
         } catch (e) {
             //console.log('Error while removing the private key file content', e);
         }
-        const content = fs.readFileSync(this.key_file, 'utf8');
-        //console.log('cert file content', content, '##################');
+        try {
+            fs.readFileSync(this.key_file, 'utf8');
+        } catch (e) {
+            // Nothing to read back; the wipe above is what mattered.
+        }
     }
 
     // Testnet non-CAS mode: derive a deterministic self-signed cert/key from this
-    // enclave's MR_ENCLAVE and write them to the paths the rest of the code reads
-    // (key_file for decrypt, cert_file for savePublicCert). No-op on mainnet,
-    // where CAS injects the cert/key into those same paths. Idempotent: the key
-    // is a pure function of MR_ENCLAVE so it is identical across restarts.
+    // enclave's identity. The CERTIFICATE is written (it is public, and
+    // savePublicCert reads it back to publish it); the PRIVATE KEY is kept ONLY
+    // in memory and never touches the filesystem.
+    //
+    // Why memory-only: on testnet there is no CAS and no attestation, so nothing
+    // provisions or protects the key from outside the enclave. Not writing it at
+    // all removes every at-rest attack on it outright, instead of relying on the
+    // file protection being keyed by something trustworthy on this path.
+    //
+    // MAINNET IS UNCHANGED: this method returns immediately there, CAS still
+    // injects cert+key into key_file/cert_file, and every consumer still reads
+    // key_file exactly as before (this.identity_private_key_pem stays null, and
+    // privateKeyMaterial() falls back to the path).
+    //
+    // Idempotent: the key is a pure function of the enclave identity, so it is
+    // identical across restarts without needing to persist it.
     generateSelfSignedCertIfTestnet() {
         if (NETWORK_TYPE !== "testnet") return;
         console.log("[SecureLock] TESTNET: self-signing certificate from MR_ENCLAVE (no CAS) [TESTNET-INSECURE]");
         const {privateKeyPem, certPem, mrEnclaveHex} = generateCertFromMrEnclave("SecureLock Enclave");
         console.log(`[SecureLock] MR_ENCLAVE: ${mrEnclaveHex}`);
-        for (const f of [this.key_file, this.cert_file, this.pub_cert_file]) {
+        for (const f of [this.cert_file, this.pub_cert_file]) {
             try { fs.mkdirSync(require('path').dirname(f), {recursive: true}); } catch (e) {}
         }
-        fs.writeFileSync(this.key_file, privateKeyPem);
+        // Private key: memory only. Deliberately NOT written to this.key_file.
+        this.identity_private_key_pem = privateKeyPem;
         fs.writeFileSync(this.cert_file, certPem);
     }
 
+    // The enclave's identity private key, in whatever form this network provides
+    // it: the in-memory PEM on testnet, or the CAS-injected key_file path on
+    // mainnet. etny_crypto accepts either, so callers do not branch on network.
+    privateKeyMaterial() {
+        return this.identity_private_key_pem || this.key_file;
+    }
+
     async savePublicCert() {
         try {
             const content = await fs.promises.readFile(this.cert_file, 'utf8');
@@ -321,12 +357,46 @@ class EtnySecureLock {
             console.log(`PUBLIC_KEY:`);
             console.log(content);
 
+            // ESR (RFC §5.2): emit the enclave's ESR wallet ADDRESS on the same
+            // harvest channel as the cert, so publish (or the remote extraction
+            // service) can capture it. It MUST be derived here rather than by the
+            // service: on mainnet the identity key is CAS-provisioned and exists
+            // only inside this enclave, so nobody outside can compute the address.
+            // Only the address is emitted — the private key never leaves.
+            this.emitEsrWalletAddress();
+
             await this.swiftStreamService.putFileContent(this.etny_bucket, 'cert.pem', this.pub_cert_file);
         } catch (err) {
             console.error(err);
         }
     }
 
+    // ESR wallet address emission (RFC §5.2). Gated on ESR_CONTRACT_ADDRESS being
+    // set, exactly like the Python securelock, so non-ESR images print nothing.
+    // Derived from the enclave's own identity private key (the certificate key);
+    // only the ADDRESS is logged, never the key. Any failure is reported as
+    // ESR_WALLET_ERROR and never breaks cert harvest or a task.
+    emitEsrWalletAddress() {
+        if (!String(process.env.ESR_CONTRACT_ADDRESS || "").trim()) return;
+        try {
+            // The identity key the enclave actually holds: the CAS-provisioned
+            // key_file on mainnet (nothing in-enclave can re-derive it), or the
+            // in-memory PEM on testnet (never written to disk). Hashed as-is,
+            // matching the Python SDK.
+            const identityPriv = this.identity_private_key_pem
+                || fs.readFileSync(this.key_file, 'utf8');
+            const esrAddress = esr_wallet.deriveWalletAddress(identityPriv);
+            console.log(`ESR_WALLET_ADDRESS: ${esrAddress}`);
+            if (!esr_wallet.isSecretIdentity(NETWORK_TYPE)) {
+                console.warn(esr_wallet.INSECURE_IDENTITY_WARNING);
+            }
+        } catch (e) {
+            // Never let ESR derivation break harvest/a task: report it the way
+            // every other enclave-side config problem is reported.
+            console.error(`ESR_WALLET_ERROR: ${e && e.message ? e.message : e}`);
+        }
+    }
+
     async saveResult() {
         try {
             await this.getTrustedZonePublicKey();
@@ -342,6 +412,37 @@ class EtnySecureLock {
         }
     }
 
+    // Make StateRegistry usable from payload code, if ESR is enabled.
+    //
+    // Wires ecld_state to this enclave's identity key, the SwiftStream client
+    // and bucket the node shares with us, the registry address baked in at build
+    // time, and the provider. Payload code then just does:
+    //
+    //     const {StateRegistry} = require('./ecld_state');
+    //     await new StateRegistry().commit('key', s => ...);
+    //
+    // No-op when ESR is disabled, so non-ESR enclaves are unaffected. Never
+    // throws: a setup problem must not stop the task from running -- payload
+    // code that then uses StateRegistry gets a clear error from the registry
+    // itself rather than a task that died before starting.
+    configureStateRegistry() {
+        const contractAddress = String(process.env.ESR_CONTRACT_ADDRESS || "").trim();
+        if (!contractAddress) return;
+        try {
+            const ecld_state = require("./ecld_state");
+            ecld_state.configure({
+                identityPriv: this.identity_private_key_pem || fs.readFileSync(this.key_file, 'utf8'),
+                swiftStreamService: this.swiftStreamService,
+                bucket: this.etny_bucket,
+                contractAddress: contractAddress,
+                provider: this.w3,
+            });
+            console.log(`StateRegistry ready (ESR ${contractAddress})`);
+        } catch (e) {
+            console.error(`ESR_STATE_ERROR: could not configure StateRegistry: ${e && e.message ? e.message : e}`);
+        }
+    }
+
     async execute() {
         const payload_data = await this.getFileContentAndDecrypt(this.etny_bucket, this.payload);
         const input_data = await this.getFileContentAndDecrypt(this.etny_bucket, this.input);
@@ -355,6 +456,8 @@ class EtnySecureLock {
             return false;
         }
 
+        this.configureStateRegistry();
+
         const task_result = executeTask(payload_data, input_data);
         console.log('TASK RESULT (code, data):', task_result);
         this.task_code = task_result[0];