@ethernity-cloud/sdk-js 1.1.0

package/nodenithy/run/image_registry_runner.py

@@ -0,0 +1,71 @@
+#!/usr/local/bin/python
+
+import os
+
+from dotenv import load_dotenv
+
+from image_registry import ImageRegistry
+import re
+
+load_dotenv()
+
+try:
+    print("*********************")
+
+    def extract_certificate(certificate_string: str) -> str:
+        pattern = (
+            r"(?<=-----BEGIN CERTIFICATE-----\n)(.*?)(?=\n-----END CERTIFICATE-----)"
+        )
+        matches = re.findall(pattern, certificate_string, re.DOTALL)
+        if matches:
+            return matches[0].strip()
+        else:
+            return None  # type: ignore
+
+    def read_file_content(file_path: str) -> str:
+        with open(file_path, "r") as file:
+            content = file.read()
+        return content
+
+    secure_lock = read_file_content("certificate.securelock.crt")
+    # secure_lock = extract_certificate(secure_lock)
+    print("SECURELOCK:")
+    print(secure_lock)
+
+    trusted_zone = read_file_content("certificate.trustedzone.crt")
+    # trusted_zone = extract_certificate(trusted_zone)
+    print("TRUSTEDZONE:")
+    print(trusted_zone)
+    ipfs_hash = read_file_content("IPFS_HASH.ipfs")
+    ipfs_hash = ipfs_hash.strip()
+    ipfs_docker_compose_hash = read_file_content("IPFS_DOCKER_COMPOSE_HASH.ipfs")
+    ipfs_docker_compose_hash = ipfs_docker_compose_hash.strip()
+    print("IPFS_HASH: " + ipfs_hash)
+    imageRegistry = ImageRegistry()
+    print("PROJECT_NAME: " + os.getenv("PROJECT_NAME", ""))
+    # print("ENCLAVE_NAME_TRUSTEDZONE: " + os.getenv("ENCLAVE_NAME_TRUSTEDZONE", ""))
+    print("ENCLAVE_NAME_SECURELOCK: " + os.getenv("ENCLAVE_NAME_SECURELOCK", ""))
+    print("DEVELOPER_FEE: " + os.getenv("DEVELOPER_FEE", "10"))
+    # imageRegistry.add_trusted_zone_cert(
+    #     trusted_zone,
+    #     ipfs_hash,
+    #     os.getenv("PROJECT_NAME", ""),
+    #     ipfs_docker_compose_hash,
+    #     os.getenv("ENCLAVE_NAME_TRUSTEDZONE", ""),
+    #     os.getenv(key="DEVELOPER_FEE", default="10"),
+    # )
+    imageRegistry.add_secure_lock_and_validate_image_cert(
+        secure_lock,
+        ipfs_hash,
+        os.getenv("PROJECT_NAME", ""),
+        ipfs_docker_compose_hash,
+        os.getenv("ENCLAVE_NAME_SECURELOCK", ""),
+        os.getenv(key="DEVELOPER_FEE", default="0"),
+    )
+
+    # secure lock - addImage
+    # publishImage(hash)
+
+    print("************************")
+except Exception as e:
+    print("An exception occurred: " + str(e))

package/nodenithy/run/ipfs.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+export IPFS_HOME=${PWD}/ipfs
+export IPFS_PATH=${IPFS_HOME}/.ipfs
+
+export KUBO_URL="https://github.com/ipfs/kubo/releases/download/v0.17.0/kubo_v0.17.0_darwin-amd64.tar.gz"
+echo KUBO_URL=${KUBO_URL}
+
+mkdir -p ${IPFS_HOME}
+
+curl -L ${KUBO_URL} | tar xvz
+
+echo "*** KUBO Downloaded ***"
+
+if [ -d "${IPFS_PATH}" ]; then
+  killall ipfs
+  rm -fr ${IPFS_PATH}
+fi
+
+export IPFS_CMD=${PWD}/kubo/ipfs
+export REGISTRY_PATH=../../../../registry
+
+${IPFS_CMD} init
+
+sleep 20
+
+${IPFS_CMD} daemon &
+
+sleep 20
+
+${IPFS_CMD} swarm connect /ip4/31.7.188.59/tcp/4001/ipfs/QmRBc1eBt4hpJQUqHqn6eA8ixQPD3LFcUDsn6coKBQtia5
+${IPFS_CMD} bootstrap add /ip4/31.7.188.59/tcp/4001/ipfs/QmRBc1eBt4hpJQUqHqn6eA8ixQPD3LFcUDsn6coKBQtia5
+
+
+cp certificate.securelock.crt "${REGISTRY_PATH}/certificate.securelock.crt"
+cp certificate.trustedzone.crt "${REGISTRY_PATH}/certificate.trustedzone.crt"
+echo "${REGISTRY_PATH}"
+cd ${REGISTRY_PATH}
+
+#ADDING DOCKER IMAGE hash
+export IPFS_HASH=$(${IPFS_CMD} add . -r | grep added | tail -1 | awk '{print $2}')
+echo "IPFS_HASH=${IPFS_HASH}"
+
+echo ipfs pin add --progress ${IPFS_HASH}
+${IPFS_CMD} pin add --progress ${IPFS_HASH}
+
+#DOWNLOADING DOCKER IMAGE FROM IFPS HASH
+echo ipfs get  ${IPFS_HASH}
+${IPFS_CMD} get  ${IPFS_HASH}
+
+if [ -d "${IPFS_PATH}" ]; then
+  killall ipfs
+  rm -fr ${IPFS_PATH}
+fi
+
+cd -
+
+echo "${IPFS_HASH}" > "IPFS_HASH.ipfs"

package/nodenithy/run/ipfs_pre.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+
+export IPFS_HOME=${PWD}/ipfs
+export IPFS_PATH=${IPFS_HOME}/.ipfs
+
+export KUBO_URL="https://github.com/ipfs/kubo/releases/download/v0.17.0/kubo_v0.17.0_darwin-amd64.tar.gz"
+echo KUBO_URL=${KUBO_URL}
+
+mkdir -p ${IPFS_HOME}
+
+curl -L ${KUBO_URL} | tar xvz
+
+echo "*** KUBO Downloaded ***"
+
+if [ -d "${IPFS_PATH}" ]; then
+  killall ipfs
+  rm -fr ${IPFS_PATH}
+fi
+
+export IPFS_CMD=${PWD}/kubo/ipfs
+export REGISTRY_PATH=../../../../registry
+
+${IPFS_CMD} init
+
+sleep 20
+
+# Configure Kubo to use the custom IPFS API endpoint
+${IPFS_CMD} config Addresses.API /ip4/127.0.0.1/tcp/5001
+${IPFS_CMD} config --json API.HTTPHeaders.Access-Control-Allow-Origin '["*"]'
+${IPFS_CMD} config --json API.HTTPHeaders.Access-Control-Allow-Methods '["PUT", "POST", "GET"]'
+
+${IPFS_CMD} daemon &
+
+sleep 20
+
+# Connect to the custom IPFS node
+${IPFS_CMD} swarm connect /dns4/ipfs.ethernity.cloud/tcp/5001
+
+# Adding Docker Compose hash
+export IPFS_DOCKER_COMPOSE_HASH=$(${IPFS_CMD} add docker-compose-final.yml | grep added | tail -1 | awk '{print $2}')
+echo "IPFS_DOCKER_COMPOSE_HASH=${IPFS_DOCKER_COMPOSE_HASH}"
+
+echo ipfs pin add --progress ${IPFS_DOCKER_COMPOSE_HASH}
+${IPFS_CMD} pin add --progress ${IPFS_DOCKER_COMPOSE_HASH}
+
+# Downloading Docker Compose from IPFS hash
+echo ipfs get ${IPFS_DOCKER_COMPOSE_HASH}
+${IPFS_CMD} get ${IPFS_DOCKER_COMPOSE_HASH}
+
+# Remove downloaded
+rm -fr ${IPFS_DOCKER_COMPOSE_HASH}
+
+echo "${REGISTRY_PATH}"
+cd ${REGISTRY_PATH}
+
+# Adding Docker image hash
+export IPFS_HASH=$(${IPFS_CMD} add . -r | grep added | tail -1 | awk '{print $2}')
+echo "IPFS_HASH=${IPFS_HASH}"
+
+echo ipfs pin add --progress ${IPFS_HASH}
+${IPFS_CMD} pin add --progress ${IPFS_HASH}
+
+# Downloading Docker image from IPFS hash
+echo ipfs get ${IPFS_HASH}
+${IPFS_CMD} get ${IPFS_HASH}
+
+if [ -d "${IPFS_PATH}" ]; then
+  killall ipfs
+  rm -fr ${IPFS_PATH}
+fi
+
+cd -
+
+echo "${IPFS_DOCKER_COMPOSE_HASH}" > "IPFS_DOCKER_COMPOSE_HASH.ipfs"
+echo "${IPFS_HASH}" > "IPFS_HASH.ipfs"

package/nodenithy/run/public_key_service.js

@@ -0,0 +1,90 @@
+const axios = require('axios');
+const fs = require('fs');
+const { Command } = require('commander');
+const program = new Command();
+
+const BASE_URL = "https://publickey.ethernity.cloud";
+
+async function submitIpfsHash(hash, enclaveName, protocolVersion, network, templateVersion, dockerComposerHash) {
+    const url = `${BASE_URL}/api/addHash`;
+    const payload = {
+        hash: hash,
+        enclave_name: enclaveName,
+        protocol_version: protocolVersion,
+        network: network,
+        template_version: templateVersion,
+        docker_composer_hash: dockerComposerHash,
+    };
+    try {
+        const response = await axios.post(url, payload);
+        // console.log(`response: ${response}`);
+        return response.data;
+    } catch (error) {
+        console.error("Error:", error.response ? error.response.data : error.message);
+        process.exit(1);
+    }
+}
+
+async function checkIpfsHashStatus(hash) {
+    const url = `${BASE_URL}/api/checkHash/${hash}`;
+    try {
+        const response = await axios.get(url);
+        return response.data;
+    } catch (error) {
+        console.error("Error:", error.response ? error.response.data : error.message);
+        process.exit(1);
+    }
+}
+
+program
+    .requiredOption('--enclave_name <enclaveName>', 'Enclave name')
+    .requiredOption('--protocol_version <protocolVersion>', 'Protocol version')
+    .requiredOption('--network <network>', 'Network')
+    .requiredOption('--template_version <templateVersion>', 'Template version');
+
+program.parse(process.argv);
+
+const options = program.opts();
+const enclaveName = options.enclave_name;
+const protocolVersion = options.protocol_version;
+const network = options.network.toLowerCase().split("_")[1];
+const templateVersion = options.template_version;
+
+const hhash = fs.readFileSync('IPFS_HASH.ipfs', 'utf8').trim();
+const dockerComposerHash = fs.readFileSync('IPFS_DOCKER_COMPOSE_HASH.ipfs', 'utf8').trim();
+
+console.log("IPFS Hash:", hhash);
+console.log("Enclave Name:", enclaveName);
+console.log("Protocol Version:", protocolVersion);
+console.log("Network:", network);
+console.log("Template Version:", templateVersion);
+console.log("Docker Composer Hash:", dockerComposerHash);
+
+(async () => {
+    // Submit IPFS Hash
+    const submitResponse = await submitIpfsHash(hhash, enclaveName, protocolVersion, network, templateVersion, dockerComposerHash);
+    console.log("Submit IPFS Hash Response:", submitResponse);
+
+    // Check IPFS Hash Status
+    while (true) {
+        const checkResponse = await checkIpfsHashStatus(hhash);
+        if ("publicKey" in checkResponse) {
+            if (checkResponse.publicKey === 0) {
+                console.log(`Public key not available yet. Queue position: ${checkResponse.queuePosition || 'Unknown'}`);
+            } else if (checkResponse.publicKey === -1) {
+                console.log("Hash is not derived from Eternity Cloud SDK.");
+                process.exit(1);
+            } else {
+                console.log("Public Key:", checkResponse.publicKey);
+                // Save public key to file
+                fs.writeFileSync('PUBLIC_KEY.txt', checkResponse.publicKey);
+                break;
+            }
+        } else {
+            console.log("Unexpected response:", checkResponse);
+            process.exit(1);
+        }
+
+        await new Promise(resolve => setTimeout(resolve, 10000)); // Wait for 10 seconds before checking again
+    }
+})();

package/nodenithy/run/public_key_service.py

@@ -0,0 +1,107 @@
+import requests
+import time
+import argparse
+
+BASE_URL = "https://publickey.ethernity.cloud"
+
+
+def submit_ipfs_hash(
+    hhash,
+    enclave_name,
+    protocol_version,
+    network,
+    template_version,
+    docker_composer_hash,
+):
+    url = f"{BASE_URL}/api/addHash"
+    payload = {
+        "hash": hhash,
+        "enclave_name": enclave_name,
+        "protocol_version": protocol_version,
+        "network": network,
+        "template_version": template_version,
+        "docker_composer_hash": docker_composer_hash,
+    }
+    response = requests.post(url, json=payload)
+    print(f"response:{response}")
+    if response.status_code == 200:
+        return response.json()
+    else:
+        print("Error:", response.con)
+        exit(1)
+
+
+def check_ipfs_hash_status(hash):
+    url = f"{BASE_URL}/api/checkHash/{hash}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        return response.json()
+    else:
+        print("Error:", response.json())
+        exit(1)
+
+
+if __name__ == "__main__":
+    # Example usage
+    # python3 ./public_key_service.py --enclave_name ${ENCLAVE_NAME_SECURELOCK} --protocol_version ${VERSION} --network ${BLOCKCHAIN_NETWORK} --template_version ${VERSION}
+
+    # read enclave_name, protocol_version, network, template_version from command line arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--enclave_name", help="Enclave name", required=True)
+    parser.add_argument("--protocol_version", help="Protocol version", required=True)
+    parser.add_argument("--network", help="Network", required=True)
+    parser.add_argument("--template_version", help="Template version", required=True)
+
+    args = parser.parse_args()
+    enclave_name = args.enclave_name
+    protocol_version = args.protocol_version
+    network = args.network.lower().split("_")[1]
+    template_version = args.template_version
+
+    hhash = ""
+    with open("IPFS_HASH.ipfs", "r") as f:
+        hhash = f.read().strip()
+    docker_composer_hash = ""
+    with open("IPFS_DOCKER_COMPOSE_HASH.ipfs", "r") as f:
+        docker_composer_hash = f.read().strip()
+
+    print("IPFS Hash:", hhash)
+    print("Enclave Name:", enclave_name)
+    print("Protocol Version:", protocol_version)
+    print("Network:", network)
+    print("Template Version:", template_version)
+    print("Docker Composer Hash:", docker_composer_hash)
+
+    # Submit IPFS Hash
+    submit_response = submit_ipfs_hash(
+        hhash,
+        enclave_name,
+        protocol_version,
+        network,
+        template_version,
+        docker_composer_hash,
+    )
+    print("Submit IPFS Hash Response:", submit_response)
+
+    # Check IPFS Hash Status
+    while True:
+        check_response = check_ipfs_hash_status(hhash)
+        if "publicKey" in check_response:
+            if check_response["publicKey"] == 0:
+                print(
+                    f"Public key not available yet. Queue position: {check_response.get('queuePosition', 'Unknown')}"
+                )
+            elif check_response["publicKey"] == -1:
+                print("Hash is not derived from Eternity Cloud SDK.")
+                exit(1)
+            else:
+                print("Public Key:", check_response["publicKey"])
+                # save public key to file
+                with open("PUBLIC_KEY.txt", "w") as f:
+                    f.write(check_response["publicKey"])
+                break
+        else:
+            print("Unexpected response:", check_response)
+            exit(1)
+
+        time.sleep(10)  # Wait for 10 seconds before checking again

package/nodenithy/run/swift_stream_service.py

@@ -0,0 +1,212 @@
+import os
+
+from minio import Minio
+from minio.error import S3Error
+
+
+class SwiftStreamService:
+
+    def __init__(self, endpoint: str, access_key: str, secret_key: str):
+        self.client = Minio(
+            endpoint=endpoint,
+            access_key=access_key,
+            secret_key=secret_key,
+            secure=False,
+        )
+
+    def create_bucket(self, bucket_name: str) -> (bool, str):
+        try:
+            if not self.client.bucket_exists(bucket_name):
+                self.client.make_bucket(bucket_name)
+            else:
+                return False, f"Bucket, {bucket_name} already exists!"
+        except S3Error as err:
+            return False, err
+
+        return True, f"Bucket, {bucket_name} successfully created!"
+
+    def delete_bucket(self, bucket_name: str) -> (bool, str):
+        try:
+            if self.client.bucket_exists(bucket_name):
+                file_objects = self.client.list_objects(bucket_name)
+                if file_objects.size() == 0:
+                    self.client.remove_bucket(bucket_name)
+                else:
+                    for file_object in file_objects:
+                        self.delete_file(bucket_name, file_object)
+                    self.client.remove_bucket(bucket_name)
+            else:
+                return False, f"Bucket, {bucket_name} does not exists!"
+        except S3Error as err:
+            return False, err
+
+        return True, f"Bucket, {bucket_name} successfully deleted!"
+
+    def delete_file(self, bucket_name: str, file_name: str) -> (bool, str):
+        try:
+            self.client.remove_object(bucket_name, file_name)
+        except S3Error as err:
+            return False, err
+
+        return True, f"File, {file_name} successfully deleted!"
+
+    def delete_files(self, bucket_name: str, list_of_files: list[str]) -> (bool, str):
+        try:
+            errors = self.client.remove_objects(bucket_name, list_of_files)
+            for error in errors:
+                print(f"[Error] Error occurred when deleting file: {error}!")
+        except S3Error as err:
+            return False, err
+
+        return True, f"Files, {list_of_files} successfully deleted!"
+
+    def upload_file(
+        self, bucket_name: str, file_name: str, file_path: str
+    ) -> (bool, str):
+        try:
+            if self.client.bucket_exists(bucket_name):
+                self.client.fput_object(bucket_name, file_name, file_path)
+            else:
+                self.create_bucket(bucket_name)
+                self.client.fput_object(bucket_name, file_name, file_path)
+        except S3Error as err:
+            return False, err
+
+        return True, f"{file_path} is successfully uploaded to bucket {bucket_name}."
+
+    def upload_files(
+        self, bucket_name: str, list_of_files: list[str], upload_file_paths: list[str]
+    ) -> (bool, str):
+        try:
+            if self.client.bucket_exists(bucket_name):
+                for file_idx in range(len(upload_file_paths)):
+                    self.client.fput_object(
+                        bucket_name,
+                        list_of_files[file_idx],
+                        upload_file_paths[file_idx],
+                    )
+            else:
+                self.create_bucket(bucket_name)
+                for file_idx in range(len(upload_file_paths)):
+                    self.client.fput_object(
+                        bucket_name,
+                        list_of_files[file_idx],
+                        upload_file_paths[file_idx],
+                    )
+        except S3Error as err:
+            return False, err
+
+        return (
+            True,
+            f"{upload_file_paths} are successfully uploaded to bucket {bucket_name}.",
+        )
+
+    def download_file(
+        self, bucket_name: str, file_name: str, file_path: str
+    ) -> (bool, str):
+        try:
+            if self.client.bucket_exists(bucket_name):
+                self.client.fget_object(bucket_name, file_name, file_path)
+            else:
+                return False, f"Bucket, {bucket_name} does not exists!"
+        except S3Error as err:
+            return False, err
+
+        return (
+            True,
+            f"File, {file_name} from bucket {bucket_name} was downloaded in {file_path}.",
+        )
+
+    def download_files(
+        self, bucket_name: str, list_of_files: list[str], download_file_paths: list[str]
+    ) -> (bool, str):
+        try:
+            if self.client.bucket_exists(bucket_name):
+                for file_idx in range(len(list_of_files)):
+                    self.client.fget_object(
+                        bucket_name,
+                        list_of_files[file_idx],
+                        download_file_paths[file_idx],
+                    )
+            else:
+                return False, f"Bucket, {bucket_name} does not exists!"
+        except S3Error as err:
+            return False, err
+
+        return (
+            True,
+            f"{download_file_paths} are successfully uploaded to bucket {bucket_name}.",
+        )
+
+    def get_file_content_bytes(self, bucket_name: str, file_name: str) -> (bool, bytes):
+        response = None
+        try:
+            response = self.client.get_object(bucket_name, file_name)
+            _d = b""
+            for data in response.stream(amt=1024 * 1024):
+                _d = _d + data
+
+        except S3Error as err:
+            return False, err
+        finally:
+            if not response:
+                response.close()
+                response.release_conn()
+        return True, _d
+
+    def get_file_content(self, bucket_name: str, file_name: str) -> (bool, str):
+        status, content = self.get_file_content_bytes(bucket_name, file_name)
+        if status:
+            return True, content.decode("utf-8")
+        return status, content
+
+    def put_file_content(
+        self,
+        bucket_name: str,
+        object_name: str,
+        object_path: str,
+        object_data: object = None,
+    ) -> (bool, str):
+        try:
+            if object_data is not None:
+                self.client.put_object(
+                    bucket_name, object_name, object_data, len(object_data.getbuffer())
+                )
+            else:
+                object_stat = os.stat(object_path)
+                with open(object_path, "rb") as file_data:
+                    self.client.put_object(
+                        bucket_name, object_name, file_data, object_stat.st_size
+                    )
+                file_data.close()
+        except S3Error as err:
+            return False, err
+
+        return True, f"{object_name} is successfully uploaded to bucket {bucket_name}."
+
+    def is_object_in_bucket(self, bucket_name: str, object_name: str) -> (bool, str):
+        found = False
+        try:
+            result = self.client.stat_object(bucket_name, object_name)
+            if result:
+                found = True
+        except S3Error as err:
+            return False, err
+
+        if found:
+            return found, f"{object_name} exists inside {bucket_name}."
+        else:
+            return found, f"{object_name} doesn't exists inside {bucket_name}."
+
+    def _list_buckets(self) -> None:
+        buckets = self.client.list_buckets()
+        for bucket in buckets:
+            print(bucket.name, bucket.creation_date)
+
+    def _list_objects(self, bucket_name: str) -> None:
+        objects = self.client.list_objects(bucket_name)
+        for obj in objects:
+            print("-> ", obj.object_name, obj.owner_name)
+
+    def _is_bucket(self, bucket_name: str) -> bool:
+        return self.client.bucket_exists(bucket_name)

package/nodenithy/run/swiftstream.py

@@ -0,0 +1,37 @@
+#!/usr/local/bin/python
+
+from minio import Minio
+from minio.error import S3Error
+from swift_stream_service import SwiftStreamService
+
+try:
+    print("*********************")
+    print("Initializing SwiftStream Service from python...")
+    swiftStreamClient = SwiftStreamService(
+        "docker:9000", "swiftstreamadmin", "swiftstreamadmin"
+    )
+    print("Initialized SwiftStream Service successfully")
+    print("*********************")
+    swiftStreamClient.create_bucket("etny-nodenithy-v3")
+
+    swiftStreamClient.upload_file("etny-nodenithy-v3", ".env", "./.env")
+
+    print(swiftStreamClient.is_object_in_bucket("etny-nodenithy-v3", ".env"))
+
+    status, content = swiftStreamClient.get_file_content("etny-nodenithy-v3", ".env")
+
+    print("************************")
+    print("Status %s" % status)
+    print("Content %s" % content)
+    print("************************")
+
+    status, content = swiftStreamClient.get_file_content_bytes(
+        "etny-nodenithy-v3", ".env"
+    )
+
+    print("************************")
+    print("Status %s" % status)
+    print("Content %s" % content)
+    print("************************")
+except:
+    print("An exception occurred")

package/nodenithy/run/swiftstream1.py

@@ -0,0 +1,27 @@
+#!/usr/local/bin/python
+
+from minio import Minio
+from minio.error import S3Error
+from swift_stream_service import SwiftStreamService
+
+try:
+    print("*********************")
+    print("Initializing SwiftStream Service from python...")
+    swiftStreamClient = SwiftStreamService(
+        "localhost:9000", "swiftstreamadmin", "swiftstreamadmin"
+    )
+    print("Initialized SwiftStream Service successfully")
+    print("*********************")
+
+    status, content = swiftStreamClient.get_file_content(
+        "etny-nodenithy-v2", "result11.txt"
+    )
+
+    # status, content = swiftStreamClient.get_file_content_bytes("etny-nodenithy-v2", "result11.txt")
+
+    print("************************")
+    print("Status %s" % status)
+    print("Content %s" % content)
+    print("************************")
+except Exception as e:
+    print("An exception occurred" + str(e))