@ethernity-cloud/sdk-js 1.1.0

package/README.md

@@ -0,0 +1,185 @@
+
+# Ethernity Cloud SDK JS
+
+This project provides a set of tools and scripts to work with the Ethernity Cloud SDK in a JavaScript environment.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Scripts](#scripts)
+- [Project Structure](#project-structure)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+
+To install the package and its dependencies, run:
+
+```sh
+npm install ethernity-cloud-sdk-js
+```
+
+## Usage
+
+After installation, you can use the provided scripts to build, publish, and initialize your project.
+
+## Pre-requisites
+The sdk requires the following to be installed on your system:
+- Node.js v20.04 or higher
+- npm
+- docker (daemon running in the background for build and publish scripts)
+
+
+## Operating System compatibility
+The sdk has been tested on the following operating systems:
+- MacOS
+- Ubuntu 20.04
+- Windows 10
+
+## Blockchain compatibility
+- Bloxberg:
+    - Testnet - tested and working
+    - Mainnet - to be provided during the following updates
+- Polyhon:
+    - Amoy Testnet - to be provided during the following updates
+    - Mainnet - to be provided during the following updates
+
+### Scripts
+
+- **Initialize**: To initialize the project, run:
+  ```sh
+  npm run ecld-init
+  ```
+  at this step, all the initial configurations will be set up and the project will be ready to be built, published and run.
+
+- **Build**: To build the project, run:
+  ```sh
+  npm run ecld-build
+  ```
+    the project will be built and the docker repository output will be stored in the `registry/` directory. This is the stage where the backend functions are added to the secure images.
+
+- **Publish**: To publish the project, run:
+  ```sh
+  npm run ecld-publish
+  ```
+  Required after build, to build and integrate the secure certificates that will be used during executions and to register the project to the Ethernity Cloud Image Register.
+
+- **Run**: To run the project, run:
+  ```sh
+  npm run start
+  ```
+  command to start the demo application and test the integration.
+
+## Project Structure
+
+```
+.gitignore
+build.js
+build.sh
+demo/
+init.js
+nodenithy/
+package.json
+postinstall.js
+publish.js
+pynithy/
+```
+
+### Notable Directories and Files
+
+- **[`build.js`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fbullet%2Fethernity%2Fethernity-cloud-sdk-js%2Fbuild.js%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/bullet/ethernity/ethernity-cloud-sdk-js/build.js")**: Script to build the project.
+- **[`init.js`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fbullet%2Fethernity%2Fethernity-cloud-sdk-js%2Finit.js%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/bullet/ethernity/ethernity-cloud-sdk-js/init.js")**: Script to initialize the project.
+- **[`publish.js`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fbullet%2Fethernity%2Fethernity-cloud-sdk-js%2Fpublish.js%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/bullet/ethernity/ethernity-cloud-sdk-js/publish.js")**: Script to publish the project.
+- **[`postinstall.js`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fbullet%2Fethernity%2Fethernity-cloud-sdk-js%2Fpostinstall.js%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/bullet/ethernity/ethernity-cloud-sdk-js/postinstall.js")**: Script that runs after the package is installed.
+- **[`nodenithy/`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fbullet%2Fethernity%2Fethernity-cloud-sdk-js%2Fnodenithy%2F%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/bullet/ethernity/ethernity-cloud-sdk-js/nodenithy/")**: Contains various scripts and modules for the project.
+- **[`pynithy/`](command:_github.copilot.openRelativePath?%5B%7B%22scheme%22%3A%22file%22%2C%22authority%22%3A%22%22%2C%22path%22%3A%22%2FUsers%2Fbullet%2Fethernity%2Fethernity-cloud-sdk-js%2Fpynithy%2F%22%2C%22query%22%3A%22%22%2C%22fragment%22%3A%22%22%7D%5D "/Users/bullet/ethernity/ethernity-cloud-sdk-js/pynithy/")**: Contains Python-related scripts and configurations.
+
+## Usage
+
+To use the SDK:
+- after installation, run `npm run ecld-init` to initialize the project
+- in you workspace, you will find the `scr/serverless` directory, this contains a `backend.js` file. This file will be imported in the dApp images to provide the backend functions for calling from the frontend of your application, eg.:
+```js
+function hello(msg='World') {
+    return "Hello "+msg;
+}
+
+module.exports = { hello };
+```
+From your frontend application, using the ethernity cloud runner library, you will be calling the function as seen in the below example, where we pass `hello("World");` to be executed on the backend which will run in the Blockchain:
+```js
+const AppCss = require('./App.css');
+import EthernityCloudRunner from "@ethernity-cloud/runner";
+import {ECEvent, ECRunner, ECStatus} from "@ethernity-cloud/runner/enums";
+import Web3 from 'web3';
+
+const PROJECT_NAME = "";
+const IPFS_ENDPOINT = "";
+
+const code = `hello("World");`;
+
+function App() {
+    const executeTask = async () => {
+        const runner = new EthernityCloudRunner();
+        // this is a server provided by Ethernity CLOUD, please bear in mind that you can use your own Decentralized Storage server
+        const ipfsAddress = IPFS_ENDPOINT;
+        runner.initializeStorage(ipfsAddress);
+        console.log(PROJECT_NAME)
+        const onTaskProgress = (e) => {
+            if (e.detail.status === ECStatus.ERROR) {
+                console.error(e.detail.message);
+            } else {
+                console.log(e.detail.message);
+            }
+        };
+
+        const onTaskCompleted = (e) => {
+            console.log(`Task Result: ${e.detail.message.result}`);
+            // display the result in page below the buttons
+            const result = document.createElement("p");
+            result.innerHTML = `Task Result: ${e.detail.message.result}`;
+            document.body.appendChild(result);
+        }
+
+        runner.addEventListener(ECEvent.TASK_PROGRESS, onTaskProgress);
+        runner.addEventListener(ECEvent.TASK_COMPLETED, onTaskCompleted);
+
+        await runner.run(PROJECT_NAME,
+                        code,
+                         '',
+                         { taskPrice: 10, cpu: 1, memory: 1, storage: 10, bandwidth: 1, duration: 1, validators: 1 });
+    };
+    const connectWallet = async () => {
+      if (window.ethereum) {
+          window.web3 = new Web3(window.ethereum);
+          try {
+              // Request account access
+              await window.ethereum.request({ method: 'eth_requestAccounts' });
+              console.log("Wallet connected");
+          } catch (error) {
+              console.error("User denied account access");
+          }
+      } else {
+          console.log('Please install MetaMask!');
+      }
+  };
+
+    return (
+        <div className="container">
+            <button className="centeredButton" onClick={executeTask}>Execute Task</button>
+            <button className="centeredButton" onClick={connectWallet}>Connect Wallet</button>
+        </div>
+    );
+}
+export default App;
+```
+- you are able to define the functions needed to be used in the backend, while making sure that the function that is script is compilable and that it exports the function that will be called from the frontend, in the above example, the `hello` function.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the AGPL-3.0 License. See the LICENSE file for details.

package/build.js

@@ -0,0 +1,22 @@
+const { execSync } = require('child_process');
+const path = require('path');
+require('dotenv').config();
+
+const serviceType = process.env.SERVICE_TYPE;
+
+if (serviceType === "Nodenithy") {
+    console.log("Adding prerequisites for Nodenithy...");
+    const scriptPath = path.resolve(__dirname, 'nodenithy/build.mjs');
+    console.log(`Running script: ${scriptPath}`);
+    execSync(`node ${scriptPath}`, { stdio: 'inherit' });
+    console.log(`Build script finished. You can now proceed to publish: npm run ecld-publish.`);
+} else if (serviceType === "Pynithy") {
+    console.log("Adding prerequisites for Pynithy...");
+    const scriptPath = path.resolve(__dirname, 'pynithy/build.mjs');
+    console.log(`Running script: ${scriptPath}`);
+    execSync(`node ${scriptPath}`, { stdio: 'inherit' });
+    console.log(`Build script finished. You can now proceed to publish: npm run ecld-publish.`);
+} else {
+    console.error("Something went wrong");
+    process.exit(1);
+}

package/init.js

@@ -0,0 +1,301 @@
+const fs = require("fs");
+const readline = require("readline");
+const { spawn, execSync } = require("child_process");
+const path = require("path");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const writeEnv = (key, value) => {
+  const envFile = ".env";
+  let content = "";
+
+  if (fs.existsSync(envFile)) {
+    content = fs.readFileSync(envFile, "utf8");
+    const regex = new RegExp(`^${key}=.*`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`);
+    } else {
+      content += `\n${key}=${value}`;
+    }
+  } else {
+    content = `${key}=${value}`;
+  }
+
+  fs.writeFileSync(envFile, content, "utf8");
+};
+
+const getProjectName = () => {
+  return new Promise((resolve) => {
+    const askProjectName = () => {
+      rl.question("Choose a name for your project: ", (projectName) => {
+        if (projectName.trim() === "") {
+          console.log(
+            "Project name cannot be blank. Please enter a valid name.",
+          );
+          askProjectName();
+        } else {
+          console.log(`You have chosen the project name: ${projectName}`);
+          resolve(projectName);
+        }
+      });
+    };
+    askProjectName();
+  });
+};
+
+const displayOptions = (options) => {
+  options.forEach((option, index) => {
+    console.log(`${index + 1}) ${option}`);
+  });
+};
+
+const promptOptions = (message, options, defaultOption) => {
+  return new Promise((resolve) => {
+    const askOption = () => {
+      displayOptions(options);
+      rl.question(message, (reply) => {
+        if (reply.trim() === "") {
+          console.log(`No option selected. Defaulting to ${defaultOption}.`);
+          resolve(defaultOption);
+        } else if (!isNaN(reply) && reply >= 1 && reply <= options.length) {
+          resolve(options[reply - 1]);
+        } else {
+          console.log(`Invalid option ${reply}. Please select a valid number.`);
+          askOption();
+        }
+      });
+    };
+    askOption();
+  });
+};
+
+const printIntro = () => {
+  const intro = `
+    ╔───────────────────────────────────────────────────────────────────────────────────────────────────────────────╗
+    │                                                                                                               │
+    │        .... -+++++++. ....                                                                                    │
+    │     -++++++++-     .++++++++.      _____ _   _                     _ _             ____ _                 _   │
+    │   .++-     ..    .++-     .++-    | ____| |_| |__   ___ _ __ _ __ (_) |_ _   _    / ___| | ___  _   _  __| |  │
+    │  --++----      .++-         ...   |  _| | __| '_ \\ / _ \\ '__| '_ \\| | __| | | |  | |   | |/ _ \\| | | |/ _\` |  │
+    │  --++----    .++-.          ...   | |___| |_| | | |  __/ |  | | | | | |_| |_| |  | |___| | (_) | |_| | (_| |  │
+    │   .++-     .+++.    .     .--.    |_____|\\__|_| |_|\\___|_|  |_| |_|_|\\__|\\__, |   \\____|_|\\___/ \\__,_|\\__,_|  │
+    │     -++++++++.    .---------.                                            |___/                                │
+    │        .... .-------. ....                                                                                    │
+    │                                                                                                               │
+    ╚───────────────────────────────────────────────────────────────────────────────────────────────────────────────╝
+                                          Welcome to the Ethernity Cloud SDK
+
+       The Ethernity Cloud SDK is a comprehensive toolkit designed to facilitate the development and management of
+      decentralized applications (dApps) and serverless binaries on the Ethernity Cloud ecosystem. Geared towards
+      developers proficient in Python or Node.js, this toolkit aims to help you effectively harness the key features
+      of the ecosystem, such as data security, decentralized processing, and blockchain-driven transparency and
+      trustless model for real-time data processing.
+      `;
+  console.log(intro);
+};
+
+const main = async () => {
+  printIntro();
+  const projectName = await getProjectName();
+  console.log();
+  const serviceTypeOptions = ["Nodenithy", "Pynithy", "Custom"];
+  const serviceType = await promptOptions(
+    "Select the type of code to be ran during the compute layer (default is Nodenithy): ",
+    serviceTypeOptions,
+    "Nodenithy",
+  );
+
+  let dockerRepoUrl, dockerLogin, dockerPassword, baseImageTag;
+  if (serviceType === "Custom") {
+    dockerRepoUrl = await new Promise((resolve) =>
+      rl.question("Enter Docker repository URL: ", resolve),
+    );
+    dockerLogin = await new Promise((resolve) =>
+      rl.question("Enter Docker Login (username): ", resolve),
+    );
+    dockerPassword = await new Promise((resolve) =>
+      rl.question("Enter Password: ", resolve),
+    );
+    baseImageTag = await new Promise((resolve) =>
+      rl.question("Enter the image tag: ", resolve),
+    );
+  }
+  console.log();
+  const blockchainNetworkOptions = [
+    "Bloxberg Mainnet",
+    "Bloxberg Testnet",
+    "Polygon Mainnet",
+    "Polygon Amoy Testnet",
+  ];
+  const blockchainNetwork = await promptOptions(
+    "On which Blockchain network do you want to have the app set up, as a starting point? (default is Bloxberg Testnet): ",
+    blockchainNetworkOptions,
+    "Bloxberg Testnet",
+  );
+  console.log();
+
+  console.log(
+    `Checking if the project name (image name) is available on the ${blockchainNetwork.replace(/ /g, "_")} network and ownership...`,
+  );
+  // const { execSync } = require('child_process');
+  // execSync(`python $(pwd)/node_modules/@ethernity-cloud/sdk-js/nodenithy/run/image_registry.py "${blockchainNetwork.replace(/ /g, "_")}" "${projectName.replace(/ /g, "-")}" v3`);
+  const scriptPath = path.resolve(__dirname, "nodenithy/run/image_registry.js");
+  // Spawn a new process to run the image_registry.js script
+  const runChildProcess = () =>
+    new Promise((resolve, reject) => {
+      const child = spawn("node", [
+        scriptPath,
+        blockchainNetwork.replace(/ /g, "_"),
+        projectName.replace(/ /g, "-"),
+        "v3",
+      ]);
+      // Handle stdout data
+      child.stdout.on("data", (data) => {
+        console.log(
+          `${data}`.replace("duplicate definition - constructor", ""),
+        );
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject();
+        }
+      });
+    });
+  await runChildProcess();
+
+  // // Handle stderr data
+  // child.stderr.on('data', (data) => {
+  //     console.error(`stderr: ${data}`);
+  // });
+
+  // Handle process exit
+  // child.on('close', (code) => {
+  //     console.log(`child process exited with code ${code}`);
+  // });
+
+  console.log();
+  const ipfsServiceOptions = ["Ethernity (best effort)", "Custom IPFS"];
+  const ipfsService = await promptOptions(
+    "Select the IPFS pinning service you want to use (default is Ethernity): ",
+    ipfsServiceOptions,
+    "Ethernity (best effort)",
+  );
+
+  let customUrl, ipfsToken;
+  if (ipfsService === "Custom IPFS") {
+    customUrl = await new Promise((resolve) =>
+      rl.question(
+        "Enter the endpoint URL for the IPFS pinning service you want to use: ",
+        resolve,
+      ),
+    );
+    ipfsToken = await new Promise((resolve) =>
+      rl.question(
+        "Enter the access token to be used when calling the IPFS pinning service: ",
+        resolve,
+      ),
+    );
+  } else {
+    customUrl = "http://ipfs.ethernity.cloud:5001";
+  }
+
+  fs.mkdirSync("src/serverless", { recursive: true });
+
+  console.log();
+  const appTemplateOptions = ["yes", "no"];
+  const useAppTemplate = await promptOptions(
+    "Do you want a 'Hello World' app template as a starting point? (default is yes): ",
+    appTemplateOptions,
+    "yes",
+  );
+
+  if (useAppTemplate === "yes") {
+    console.log("Bringing Frontend/Backend templates...");
+    if (serviceType === "Nodenithy") {
+      console.log("  src/serverless/backend.js (Hello World function)");
+      console.log(
+        "  src/ec_helloworld_example.js (Hello World function call - Frontend)",
+      );
+      // Simulate copying files
+      fs.cpSync("node_modules/@ethernity-cloud/sdk-js/nodenithy/src/", "src/", {
+        recursive: true,
+      });
+      fs.cpSync(
+        "node_modules/@ethernity-cloud/sdk-js/nodenithy/public/",
+        "public/",
+        { recursive: true },
+      );
+    } else if (serviceType === "Pynithy") {
+      console.log("  src/serverless/backend.py (Hello World function)");
+      console.log(
+        "  src/ec_helloworld_example.js (Hello World function call - Frontend)",
+      );
+      // Simulate copying files
+      fs.cpSync("node_modules/@ethernity-cloud/sdk-js/pynithy/src/", "src/", {
+        recursive: true,
+      });
+      fs.cpSync(
+        "node_modules/@ethernity-cloud/sdk-js/pynithy/public/",
+        "public/",
+        { recursive: true },
+      );
+    }
+    console.log("Installing required packages...");
+    // Simulate npm install
+    execSync(
+      "npm install @ethernity-cloud/runner@0.0.26 @testing-library/jest-dom@5.17.0 @testing-library/react@13.4.0 @testing-library/user-event@13.5.0 react@18.3.1 react-dom@18.3.1 react-scripts@5.0.1 web-vitals@2.1.4 web3@4.9.0 dotenv@16.4.5",
+      { stdio: "inherit" },
+    );
+  } else {
+    console.log(
+      "Define backend functions in src/serverless to be available for Frontend interaction.",
+    );
+  }
+
+  writeEnv("PROJECT_NAME", projectName.replace(/ /g, "_"));
+  writeEnv("SERVICE_TYPE", serviceType);
+  if (serviceType === "Custom") {
+    writeEnv("BASE_IMAGE_TAG", baseImageTag || "");
+    writeEnv("DOCKER_REPO_URL", dockerRepoUrl);
+    writeEnv("DOCKER_LOGIN", dockerLogin);
+    writeEnv("DOCKER_PASSWORD", dockerPassword);
+  } else if (serviceType === "Nodenithy") {
+    writeEnv("BASE_IMAGE_TAG", "");
+    writeEnv("DOCKER_REPO_URL", "");
+    writeEnv("DOCKER_LOGIN", "");
+    writeEnv("DOCKER_PASSWORD", "");
+  } else if (serviceType === "Pynithy") {
+    writeEnv("BASE_IMAGE_TAG", "");
+    writeEnv("DOCKER_REPO_URL", "");
+    writeEnv("DOCKER_LOGIN", "");
+    writeEnv("DOCKER_PASSWORD", "");
+  }
+  // write TRUSTED_ZONE_IMAGE {token}_{name}{networktype} with the following rules:
+  // - token should be ecld if network is polygon, etny if network is bloxberg
+  // - name should be serviceType.toLowerCase()
+  // - networktype should be "" if network contains 'mainnet' else '_testnet'
+  writeEnv(
+    "TRUSTED_ZONE_IMAGE",
+    `${blockchainNetwork.includes("Polygon") ? "ecld" : "etny"
+    }-${serviceType.toLowerCase()}${blockchainNetwork.includes("Mainnet") ? "" : "-testnet"
+    }`,
+  );
+
+
+  writeEnv("BLOCKCHAIN_NETWORK", blockchainNetwork.replace(/ /g, "_"));
+  writeEnv("IPFS_ENDPOINT", customUrl);
+  writeEnv("IPFS_TOKEN", ipfsToken || "");
+  writeEnv("VERSION", "v1");
+  console.log();
+  console.log(
+    "You can proceed to run ecld-build, once you set up the serverless functions or directly if you want to test with the provided template.",
+  );
+  rl.close();
+};
+
+main();

package/nodenithy/build/las/Dockerfile

@@ -0,0 +1,5 @@
+FROM registry.ethernity.cloud:443/debuggingdelight/ethernity-cloud-sdk-registry/sconecuratedimages/services:las as initial
+
+FROM scratch
+
+COPY --from=initial / /

package/nodenithy/build/securelock/Dockerfile.tmpl

@@ -0,0 +1,65 @@
+FROM registry.ethernity.cloud:443/debuggingdelight/ethernity-cloud-sdk-registry/ethernity/node:16.13.1-alpine3.15-scone5.8-production as release
+
+RUN apk update
+
+RUN cd /
+
+RUN apk add bash
+
+ENV SCONE_MODE=SIM
+ENV SCONE_HEAP=256M
+ENV SCONE_LOG=DEBUG
+ENV ENCLAVE_NAME_SECURELOCK=__ENCLAVE_NAME_SECURELOCK__
+ENV BUCKET_NAME=__BUCKET_NAME__
+ENV SMART_CONTRACT_ADDRESS=__SMART_CONTRACT_ADDRESS__
+ENV IMAGE_REGISTRY_ADDRESS=__IMAGE_REGISTRY_ADDRESS__
+ENV RPC_URL=__RPC_URL__
+ENV CHAIN_ID=__CHAIN_ID__
+ENV TRUSTED_ZONE_IMAGE=__TRUSTED_ZONE_IMAGE__
+
+RUN mkdir binary-fs-dir
+
+COPY ./src /etny-securelock/
+COPY scripts/* /etny-securelock/
+
+WORKDIR /etny-securelock
+RUN pwd
+RUN npm install
+RUN ls
+
+WORKDIR /
+
+RUN ["chmod", "+x", "etny-securelock/binary-fs-build.sh"]
+RUN etny-securelock/binary-fs-build.sh
+
+FROM registry.ethernity.cloud:443/debuggingdelight/ethernity-cloud-sdk-registry/sconecuratedimages/crosscompilers as build
+
+COPY --from=release /binary-fs-dir /.
+
+RUN scone gcc ./binary_fs_blob.s ./libbinary_fs_template.a -shared -o /libbinary-fs.so
+
+#
+FROM registry.ethernity.cloud:443/debuggingdelight/ethernity-cloud-sdk-registry/ethernity/node:16.13.1-alpine3.15-scone5.8-production
+
+COPY --from=build /libbinary-fs.so /lib/libbinary-fs.so
+#
+
+RUN apk update
+
+RUN apk add openssl
+
+RUN openssl genrsa -3 -out /enclave-key.pem 3072
+
+
+ENV SCONE_LOG=info
+ENV SCONE_HEAP=1024M
+ENV SCONE_ALLOW_DLOPEN=1
+ENV SCONE_EXTENSIONS_PATH=/lib/libbinary-fs.so
+
+# Enable production mode for mainnet
+# RUN scone-signer sign --key=/enclave-key.pem --env --production /usr/bin/node
+RUN rm -rf /enclave-key.pem
+
+#RUN scone cas attest scone-cas.cf 3061b9feb7fa67f3815336a085f629a13f04b0a1667c93b14ff35581dc8271e4 -GCS --only_for_testing-debug --only_for_testing-ignore-signer
+RUN ls /usr/local/bin
+ENTRYPOINT ["/usr/local/bin/node", "/etny-securelock/securelock.js"]

package/nodenithy/build/securelock/scripts/binary-fs-build.sh

@@ -0,0 +1,28 @@
+#!/bin/bash -v
+
+cd /etny-securelock
+ls
+echo "####################"
+cat .env
+echo "####################"
+
+cat securelock.js.tmpl | sed  s/"__ENCLAVE_NAME_SECURELOCK__"/"${ENCLAVE_NAME_SECURELOCK}"/g > securelock.js.tmp
+sed -i "s/__BUCKET_NAME__/${BUCKET_NAME}/g" securelock.js.tmp
+sed -i "s/__SMART_CONTRACT_ADDRESS__/${SMART_CONTRACT_ADDRESS}/g" securelock.js.tmp
+sed -i "s/__IMAGE_REGISTRY_ADDRESS__/${IMAGE_REGISTRY_ADDRESS}/g" securelock.js.tmp
+sed -i "s/__RPC_URL__/${RPC_URL}/g" securelock.js.tmp
+sed -i "s/__CHAIN_ID__/${CHAIN_ID}/g" securelock.js.tmp
+sed -i "s/__TRUSTED_ZONE_IMAGE__/${TRUSTED_ZONE_IMAGE}/g" securelock.js.tmp
+mv securelock.js.tmp securelock.js
+
+echo "starting building binary-fs..."
+EXEC=(scone binaryfs / /binary-fs-dir -v \
+  --include '/usr/local/bin/node' \
+  --include '/etny-securelock/*' \
+  --host-path=/etc/resolv.conf \
+  --host-path=/etc/hosts)
+echo "finished building binary-fs..."
+
+exec "${EXEC[@]}"
+
+exit

package/nodenithy/build/securelock/src/.env

@@ -0,0 +1,3 @@
+VERSION="v3"
+ETNY_MODE="PUBLIC_KEY"
+ETNY_ORDER_ID=10500