@ethernity-cloud/sdk-js 1.1.0

package/pynithy/run/image_registry.js

@@ -0,0 +1,372 @@
+const Web3 = require('web3');
+const { ethers } = require('ethers');
+const { Account } = require('eth-lib/lib/account');
+const { config } = require('dotenv');
+const fs = require('fs');
+const path = require('path');
+
+config();
+
+const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
+let BLOCKCHAIN_NETWORK = process.env.BLOCKCHAIN_NETWORK || "Bloxberg_Testnet";
+let NETWORK_RPC = "https://bloxberg.ethernity.cloud";
+let IMAGE_REGISTRY_ADDRESS = "0x15D73a742529C3fb11f3FA32EF7f0CC3870ACA31"; // bloxberg testnet
+let CHAIN_ID = 8995;
+let GAS = 9000000;
+let GAS_PRICE = 1;
+
+function setVars(network = "") {
+    if (BLOCKCHAIN_NETWORK.includes("Bloxberg")) {
+        IMAGE_REGISTRY_ADDRESS = "0x15D73a742529C3fb11f3FA32EF7f0CC3870ACA31";
+    } else if (BLOCKCHAIN_NETWORK.includes("Polygon")) {
+        if (BLOCKCHAIN_NETWORK.includes("Mainnet")) {
+            NETWORK_RPC = "https://polygon-rpc.com";
+            IMAGE_REGISTRY_ADDRESS = "0x689f3806874d3c8A973f419a4eB24e6fBA7E830F";
+            CHAIN_ID = 137;
+            GAS = 20000000;
+            GAS_PRICE = 40500500010;
+        } else {
+            NETWORK_RPC = "https://rpc-amoy.polygon.technology";
+            IMAGE_REGISTRY_ADDRESS = "0xF7F4eEb3d9a64387F4AcEb6d521b948E6E2fB049";
+            CHAIN_ID = 80002;
+            GAS = 20000000;
+            GAS_PRICE = 1300000010;
+        }
+    }
+}
+
+setVars();
+
+function isStringPrivateKey(privateKey) {
+    try {
+        let key = privateKey;
+        if (!key.startsWith("0x")) {
+            key = `0x${privateKey}`;
+        }
+
+        Web3.eth.accounts.privateKeyToAccount(key);
+        return "OK";
+    } catch (e) {
+        return e.toString();
+    }
+}
+
+async function checkAccountBalance() {
+    try {
+        const web3 = new ethers.providers.JsonRpcProvider(NETWORK_RPC);
+        const account = new ethers.Wallet(PRIVATE_KEY, this.provider);
+        const balance = await web3.getBalance(account.address);
+        return Web3.utils.fromWei(balance, 'ether');
+    } catch (e) {
+        console.error(e);
+        return 0;
+    }
+}
+
+class ImageRegistry {
+    constructor() {
+        try {
+            this.imageRegistryAbi = this.readContractAbi('image_registry.abi');
+            this.imageRegistryAddress = IMAGE_REGISTRY_ADDRESS;
+            console.log("imageRegistryAddress: ", this.imageRegistryAddress);
+            this.provider = new ethers.providers.JsonRpcProvider(NETWORK_RPC);
+
+            if (PRIVATE_KEY) {
+                this.acct = new ethers.Wallet(PRIVATE_KEY, this.provider);
+            } else {
+                const _privateKey = new ethers.Wallet.createRandom().privateKey;
+                this.acct = new ethers.Wallet(_privateKey, this.provider);
+            }
+            this.imageRegistryContract = new ethers.Contract(
+                this.imageRegistryAddress,
+                this.imageRegistryAbi,
+                this.acct
+            );
+        } catch (e) {
+            console.error(e);
+        }
+    }
+
+    readContractAbi(contractName) {
+        const filePath = path.join(__dirname, contractName);
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+
+    async addTrustedZoneCert(certContent, ipfsHash, imageName, dockerComposeHash, enclaveNameTrustedZone, fee) {
+        console.log("Adding trusted zone cert to image registry");
+        const nonce = await this.provider.getTransactionCount(this.acct.address);
+
+        const unicornTxn = this.imageRegistryContract.addTrustedZoneImage(
+            ipfsHash, certContent, "v3", imageName, dockerComposeHash, enclaveNameTrustedZone, fee
+        ).send({
+            gas: GAS,
+            chainId: CHAIN_ID,
+            nonce: nonce,
+            gasPrice: GAS_PRICE === 1 ? ethers.utils.parseUnits('1', 'mwei') : GAS_PRICE
+        });
+
+        console.log("transaction status: ", receipt.status);
+        console.log("transaction receipt: ", receipt);
+        if (receipt.status === 1) {
+            console.log("Adding trusted zone cert transaction was successful!");
+        } else {
+            console.log("Adding trusted zone cert transaction was UNSUCCESSFUL!");
+        }
+        const signedTxn = await this.acct.signTransaction(unicornTxn);
+        const receipt = await this.provider.sendTransaction(signedTxn.rawTransaction);
+    }
+
+    async addSecureLockImageCert(certContent, ipfsHash, imageName, version, dockerComposeHash, enclaveNameSecureLock, fee) {
+        try {
+            console.log("Adding secure lock image cert to image registry");
+            // Fetch current nonce
+            if (BLOCKCHAIN_NETWORK.includes("Polygon")) {
+                console.log("Polygon Mainnet");
+                let nonce = await this.provider.getTransactionCount(this.acct.address, 'pending');
+                // Fetch current gas price and increase it
+                let gasPrice = await this.provider.getGasPrice();
+                gasPrice = gasPrice.mul(ethers.BigNumber.from(110)).div(ethers.BigNumber.from(100));
+                const unicornTxn = await this.imageRegistryContract.addImage(
+                    ipfsHash, certContent, version, imageName, dockerComposeHash, enclaveNameSecureLock, fee,
+                    {
+                        nonce: nonce,
+                        gasPrice: gasPrice,
+                    });
+                // console.log("Transaction: ", unicornTxn);
+                const receipt = await this.imageRegistryContract.provider.waitForTransaction(unicornTxn.hash);
+
+                // console.log("transaction status: ", receipt.status);
+                console.log("transaction receipt: ", unicornTxn.hash);
+                if (receipt.status === 1) {
+                    console.log("Adding secure lock image cert transaction was successful!");
+                } else {
+                    // console.log("receipt.status", receipt.status)
+                    console.log("Image certificates already exist for this image!");
+                }
+            } else {
+                const unicornTxn = await this.imageRegistryContract.addImage(
+                    ipfsHash, certContent, version, imageName, dockerComposeHash, enclaveNameSecureLock, fee);
+                // console.log("Transaction: ", unicornTxn);
+                const receipt = await this.imageRegistryContract.provider.waitForTransaction(unicornTxn.hash);
+
+                // console.log("transaction status: ", receipt.status);
+                console.log("transaction receipt: ", unicornTxn.hash);
+                if (receipt.status === 1) {
+                    console.log("Adding secure lock image cert transaction was successful!");
+                } else {
+                    // console.log("receipt.status", receipt.status)
+                    console.log("Image certificates already exist for this image!");
+                }
+            }
+
+            // console.log("this.acct.address: ", this.acct.address);
+            // console.log("private key", PRIVATE_KEY);
+            // console.log('Getting nonce');
+            // const nonce = await this.imageRegistryContract.provider.getTransactionCount(this.acct.address);
+
+
+            // const signedTxn = await this.acct.signTransaction(unicornTxn);
+            // const receipt = await this.provider.sendTransaction(signedTxn.rawTransaction);
+        } catch (e) {
+            // console.error(e);
+            console.log("Image certificates already exist for this image!");
+        }
+    }
+
+    async getImagePublicKeyCert(ipfsHash) {
+        try {
+            console.log("Getting image cert from image registry");
+            // console.log("this.acct.address: ", this.acct.address);
+            // console.log("private key", PRIVATE_KEY);
+            // console.log('Getting nonce');
+            // const nonce = await this.imageRegistryContract.provider.getTransactionCount(this.acct.address);
+            const unicornTxn = await this.imageRegistryContract.getImageCertPublicKey(ipfsHash);
+            console.log("unicornTxn: ", unicornTxn);
+            // const receipt = await this.imageRegistryContract.provider.waitForTransaction(unicornTxn.hash);
+
+            // console.log("transaction status: ", receipt.status);
+            // // console.log("transaction receipt: ", unicornTxn);
+            // if (receipt.status === 1) {
+            //     console.log("");
+            // } else {
+            //     console.log("Adding secure lock image cert transaction was UNSUCCESSFUL!");
+            // }
+            // const signedTxn = await this.acct.signTransaction(unicornTxn);
+            // const receipt = await this.provider.sendTransaction(signedTxn.rawTransaction);
+        } catch (e) {
+            console.error(e);
+            console.log("Getting image cert transaction was UNSUCCESSFUL!");
+        }
+    }
+
+    async validateSecureLockImageCert(certContent, ipfsHash, imageName, dockerComposeHash, enclaveNameSecureLock, fee) {
+        console.log("Validating secure lock image cert in image registry");
+        const nonce = await this.provider.getTransactionCount(this.acct.address);
+        const unicornTxn = this.imageRegistryContract.validateSecureLockImage(
+            ipfsHash, certContent, "v3", imageName, dockerComposeHash, enclaveNameSecureLock, fee
+        ).send({
+            gas: GAS,
+            chainId: CHAIN_ID,
+            nonce: nonce,
+            gasPrice: GAS_PRICE === 1 ? ethers.utils.parseUnits('1', 'mwei') : GAS_PRICE
+        });
+
+        console.log("transaction status: ", receipt.status);
+        console.log("transaction receipt: ", receipt);
+        if (receipt.status === 1) {
+            console.log("Validating secure lock image cert transaction was successful!");
+        } else {
+            console.log("Validating secure lock image cert transaction was UNSUCCESSFUL!");
+        }
+        const signedTxn = await this.acct.signTransaction(unicornTxn);
+        const receipt = await this.provider.sendTransaction(signedTxn.rawTransaction);
+    }
+
+    async addSecureLockAndValidateImageCert(certContent, ipfsHash, imageName, dockerComposeHash, enclaveNameSecureLock, fee) {
+        console.log("Adding and validating secure lock image cert in image registry");
+        const nonce = await this.provider.getTransactionCount(this.acct.address);
+        const unicornTxn = this.imageRegistryContract.addSecureLockAndValidateImage(
+            ipfsHash, certContent, "v3", imageName, dockerComposeHash, enclaveNameSecureLock, fee
+        ).send({
+            gas: GAS,
+            chainId: CHAIN_ID,
+            nonce: nonce,
+            gasPrice: GAS_PRICE === 1 ? ethers.utils.parseUnits('1', 'mwei') : GAS_PRICE
+        });
+
+        console.log("transaction status: ", receipt.status);
+        console.log("transaction receipt: ", receipt);
+        if (receipt.status === 1) {
+            console.log("Adding and validating secure lock image cert transaction was successful!");
+        } else {
+            console.log("Adding and validating secure lock image cert transaction was UNSUCCESSFUL!");
+        }
+        const signedTxn = await this.acct.signTransaction(unicornTxn);
+        const receipt = await this.provider.sendTransaction(signedTxn.rawTransaction);
+    }
+
+    async getTrustedZoneCert(ipfsHash) {
+        const cert = await this.imageRegistryContract.getTrustedZoneCert(ipfsHash);
+        return cert;
+    }
+
+    async getSecureLockCert(ipfsHash) {
+        const cert = await this.imageRegistryContract.getSecureLockCert(ipfsHash);
+        return cert;
+    }
+
+    async getImageDetails(ipfsHash) {
+        try {
+            const details = await this.imageRegistryContract.imageDetails(ipfsHash);
+            return details;
+        } catch (e) {
+            return ['', '', ''];
+        }
+    }
+
+    async _getLatestImageVersionPublicKey(projectName, version) {
+        try {
+            // console.log("Getting latest image version public key");
+            const publicKey = await this.imageRegistryContract.getLatestImageVersionPublicKey(projectName, version);
+            // console.log("public key: ", publicKey);
+            return publicKey;
+        } catch (e) {
+            // console.error(e);
+            return ['', '', ''];
+        }
+    }
+}
+
+(async () => {
+    try {
+        const [networkName, projectName, version, privateKey, action] = process.argv.slice(2);
+        if (action === "validateAddress") {
+            if (privateKey) {
+                console.log(isStringPrivateKey(privateKey));
+            }
+            process.exit(0);
+        }
+        if (networkName && projectName) {
+            BLOCKCHAIN_NETWORK = networkName;
+        }
+        setVars(networkName);
+        if (action === "checkBalance") {
+            const balance = await checkAccountBalance();
+            console.log(`${balance} gas`);
+            process.exit(0);
+        }
+        if (action === 'getTrustedZoneCert') {
+            const imageRegistry = new ImageRegistry();
+            const public = (await imageRegistry._getLatestImageVersionPublicKey(projectName, version))[1]
+            console.log(public);
+            return public;
+        }
+
+        const imageRegistry = new ImageRegistry();
+        if (action === 'registerSecureLockImage') {
+            const secureLock = fs.readFileSync("./registry/certificate.securelock.crt", 'utf8');
+            // console.log("SECURELOCK:", secureLock);
+            const ipfsHash = process.env.IPFS_HASH || "";
+            console.log(`ipfsHash: ${ipfsHash}`);
+            const ipfsDockerComposeHash = process.env.IPFS_DOCKER_COMPOSE_HASH || "";
+            console.log(`ipfsDockerComposeHash: ${ipfsDockerComposeHash}`);
+            const imageName = process.env.PROJECT_NAME || "";
+            console.log(`imageName: ${imageName}`);
+            const enclaveVersion = process.env.VERSION || "";
+            const enclaveNameSecureLock = process.env.ENCLAVE_NAME_SECURELOCK || "";
+            console.log(`enclaveNameSecureLock: ${enclaveNameSecureLock}`);
+            const fee = process.env.DEVELOPER_FEE || "0";
+            console.log(`fee: ${fee}`);
+
+            // Register the SAME build under two registry version keys:
+            //   "v3"           -> the moving "latest" pointer the runner resolves by
+            //                     default (getLatestImageVersionPublicKey(name,"v3")).
+            //                     This MUST be "v3" (the protocol version), NOT the
+            //                     enclave/template VERSION -- registering under the
+            //                     VERSION (e.g. "21") wrote the pointer where the
+            //                     runner never looks, so it kept using a stale image.
+            //   <VERSION>      -> an immutable per-version entry (e.g. "22") so this
+            //                     exact build can be pinned/rolled back to later.
+            // The contract stores each (name,version) channel append-only.
+            const versionKeys = ["v3"];
+            if (enclaveVersion && enclaveVersion !== "v3") versionKeys.push(enclaveVersion);
+            for (const versionKey of versionKeys) {
+                console.log(`Registering securelock under version '${versionKey}'`);
+                await imageRegistry.addSecureLockImageCert(secureLock, ipfsHash, imageName, versionKey, ipfsDockerComposeHash, enclaveNameSecureLock, fee);
+            }
+            process.exit(0);
+        }
+        if (action === 'getImagePublicKey') {
+            const ipfsHash = process.env.IPFS_HASH || "";
+            await imageRegistry.getImagePublicKeyCert(ipfsHash);
+            process.exit(0);
+        }
+        console.log(`Checking image: '${projectName}' on the ${networkName} blockchain...`);
+        const imageHash = (await imageRegistry._getLatestImageVersionPublicKey(projectName, version))[0];
+        console.log(`Image hash: ${imageHash}`);
+        if (!imageHash) {
+            console.log(`Image: '${projectName}' is available on the ${networkName} blockchain.`);
+            process.exit(0);
+        }
+        const imageOwner = (await imageRegistry.getImageDetails(imageHash))[0];
+
+        if (privateKey) {
+            if (isStringPrivateKey(privateKey) === "OK") {
+                const account = Account.fromPrivate(privateKey);
+                if (imageOwner !== account.address) {
+                    console.log(`!!! Image: '${projectName}' is owned by '${imageOwner}'.\nYou are not the account holder of the image.\nPlease change the project name and try again.\n`);
+                    process.exit(1);
+                }
+            }
+        }
+
+        if (imageOwner) {
+            console.log(`Image: '${projectName}' is owned by '${imageOwner}'.\nIf you are not the account holder, you will not be able to publish your project with the current name. Please change the project name and try again.\n`);
+            process.exit(0);
+        }
+
+        console.log(`Image: '${projectName}' is available on the ${networkName} blockchain.`);
+    } catch (e) {
+        process.exit(0);
+    }
+})();

package/pynithy/run/image_registry.py

@@ -0,0 +1,139 @@
+import os
+
+from web3 import Web3
+from web3.middleware import geth_poa_middleware
+from eth_account import Account
+
+privatekey = "abf7fc132da9391d9926918d772d50c0e5d6c81817f1e26d54789037ce23b625"
+
+
+class ImageRegistry:
+    def __init__(self):
+        self.acct = Account.privateKeyToAccount(privatekey)
+        image_registry_abi = self.__read_contract_abi('image_registry.abi')
+        self.image_registry_address = "0x15D73a742529C3fb11f3FA32EF7f0CC3870ACA31"
+
+        self.web3_provider = "https://bloxberg.ethernity.cloud"
+        self.w3 = Web3(Web3.HTTPProvider(self.web3_provider))
+        self.w3.middleware_onion.inject(geth_poa_middleware, layer=0)
+
+        self.image_registry = self.w3.eth.contract(address=self.w3.toChecksumAddress(self.image_registry_address),
+                                                   abi=image_registry_abi)
+
+    def __read_contract_abi(self, contract_name):
+        f = open(os.path.dirname(os.path.realpath(__file__)) + f'/{contract_name}')
+        contract_abi = f.read()
+        f.close()
+        return contract_abi
+
+    # (string memory ipfsHash, string memory publicKey, string memory version, string memory imageName, string memory dockerComposeHash)
+    def add_trusted_zone_cert(self, cert_content, ipfs_hash, image_name, docker_compose_hash, enclave_name_trustedzone, fee):
+        print('Adding trusted zone cert to image registry')
+        nonce = self.w3.eth.getTransactionCount(self.acct.address)
+        unicorn_txn = self.image_registry.functions.addTrustedZoneImage(
+            ipfs_hash, cert_content, 'v3', image_name, docker_compose_hash, enclave_name_trustedzone, fee
+        ).buildTransaction({
+            'gas': 9000000,
+            'chainId': 8995,
+            'nonce': nonce,
+            'gasPrice': self.w3.toWei("1", "mwei"),
+        })
+
+        signed_txn = self.w3.eth.account.sign_transaction(unicorn_txn, private_key=self.acct.key)
+        self.w3.eth.sendRawTransaction(signed_txn.rawTransaction)
+        # self.transaction = unicorn_tx signed
+        hash = self.w3.toHex(self.w3.sha3(signed_txn.rawTransaction))
+
+        try:
+            receipt = self.w3.eth.waitForTransactionReceipt(hash)
+        except Exception as e:
+            print(f'An error occurred while sending transaction', e)
+            raise
+
+        print('transaction status: ', receipt.status)
+        print('transaction receipt: ', receipt)
+        if receipt.status == 1:
+            print("Adding trusted zone cert transaction was successful!")
+        else:
+            print("Adding trusted zone cert  transaction was UNSUCCESSFUL!")
+
+    def add_secure_lock_image_cert(self, cert_content, ipfs_hash, image_name, docker_compose_hash, enclave_name_securelock, fee):
+        print('Adding secure lock cert to image registry')
+        nonce = self.w3.eth.getTransactionCount(self.acct.address)
+        unicorn_txn = self.image_registry.functions.addImage(
+            ipfs_hash, cert_content, 'v3', image_name, docker_compose_hash, enclave_name_securelock, fee
+        ).buildTransaction({
+            'gas': 9000000,
+            'chainId': 8995,
+            'nonce': nonce,
+            'gasPrice': self.w3.toWei("1", "mwei"),
+        })
+        signed_txn = self.w3.eth.account.sign_transaction(unicorn_txn, private_key=self.acct.key)
+        self.w3.eth.sendRawTransaction(signed_txn.rawTransaction)
+        # self.transaction = unicorn_tx signed
+        hash = self.w3.toHex(self.w3.sha3(signed_txn.rawTransaction))
+
+        try:
+            receipt = self.w3.eth.waitForTransactionReceipt(hash)
+        except Exception as e:
+            print(f'An error occurred while sending transaction', e)
+            raise
+
+        print('transaction status: ', receipt.status)
+        print('transaction receipt: ', receipt)
+        if receipt.status == 1:
+            print("Adding secure lock transaction was successful!")
+        else:
+            print("Adding secure lock transaction was UNSUCCESSFUL!")
+
+    def validate_secure_lock_image_cert(self, ipfs_hash):
+        print('Validating secure lock cert to image registry')
+        nonce = self.w3.eth.getTransactionCount(self.acct.address)
+        unicorn_txn = self.image_registry.functions.validateImage(
+            ipfs_hash
+        ).buildTransaction({
+            'gas': 9000000,
+            'chainId': 8995,
+            'nonce': nonce,
+            'gasPrice': self.w3.toWei("1", "mwei"),
+        })
+        signed_txn = self.w3.eth.account.sign_transaction(unicorn_txn, private_key=self.acct.key)
+        self.w3.eth.sendRawTransaction(signed_txn.rawTransaction)
+        # self.transaction = unicorn_tx signed
+        hash = self.w3.toHex(self.w3.sha3(signed_txn.rawTransaction))
+
+        try:
+            receipt = self.w3.eth.waitForTransactionReceipt(hash)
+        except Exception as e:
+            print(f'An error occurred while sending transaction', e)
+            raise
+
+        print('transaction status: ', receipt.status)
+        print('transaction receipt: ', receipt)
+        if receipt.status == 1:
+            print("Validating secure lock cert transaction was successful!")
+        else:
+            print("Validating secure lock cert transaction was UNSUCCESSFUL!")
+
+    def add_secure_lock_and_validate_image_cert(self, cert_content, ipfs_hash, image_name, docker_compose_hash, enclave_name_securelock, fee):
+        self.add_secure_lock_image_cert(cert_content, ipfs_hash, image_name, docker_compose_hash, enclave_name_securelock, fee)
+        self.validate_secure_lock_image_cert(ipfs_hash)
+
+    def get_trusted_zone_cert(self, image_ipfs_hash):
+        cert = self.image_registry.caller().getTrustedZoneImageCertPublicKey(image_ipfs_hash)
+        print(cert)
+
+    def get_secure_lock_cert(self, image_ipfs_hash):
+        cert = self.image_registry.caller().getImageCertPublicKey(image_ipfs_hash)
+        print(cert)
+
+
+if __name__ == '__main__':
+    image_registry = ImageRegistry()
+
+    # image_registry.add_trusted_zone_cert('cert-content', 'ipfs-hash')
+
+    # image_registry.add_secure_lock_and_validate_image_cert('cert-content', 'ipfs-hash')
+
+    image_registry.get_trusted_zone_cert('QmVPSWaDkSwMYjHd9G8SMrCwRH2KuXHzEWSnXQ7N7YsgvJ')
+    image_registry.get_secure_lock_cert('QmVPSWaDkSwMYjHd9G8SMrCwRH2KuXHzEWSnXQ7N7YsgvJ')

package/pynithy/run/image_registry_runner.py

@@ -0,0 +1,45 @@
+#!/usr/local/bin/python
+
+import os
+
+from image_registry import ImageRegistry
+import re
+
+try:
+    print("*********************")
+
+    def extract_certificate(certificate_string):
+        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
+
+
+    def read_file_content(file_path):
+        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()
+    imageRegistry.add_trusted_zone_cert(trusted_zone, ipfs_hash, 'etny-pynithy-testnet', ipfs_docker_compose_hash, os.getenv("ENCLAVE_NAME_TRUSTEDZONE"), 10)
+    imageRegistry.add_secure_lock_and_validate_image_cert(secure_lock, ipfs_hash, 'etny-pynithy-testnet', ipfs_docker_compose_hash, os.getenv("ENCLAVE_NAME_SECURELOCK"), 0)
+    print("************************")
+except Exception as e:
+    print("An exception occurred: " + str(e))

package/pynithy/run/ipfs.sh

@@ -0,0 +1,89 @@
+#!/bin/sh
+
+apk add wget tar git screen
+
+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_linux-386.tar.gz"
+echo KUBO_URL=${KUBO_URL}
+
+echo "git clone https://ci:${CI_ACCESS_TOKEN}@gitlab.ethernity.cloud/etny-node/etny-hash-packages.git ${CI_PROJECT_DIR}/etny-hash-packages"
+git clone https://ci:${CI_ACCESS_TOKEN}@gitlab.ethernity.cloud/etny-node/etny-hash-packages.git ${CI_PROJECT_DIR}/etny-hash-packages
+
+git -C ${CI_PROJECT_DIR}/etny-hash-packages config --local user.email "ci@ethernity.cloud"
+git -C ${CI_PROJECT_DIR}/etny-hash-packages config --local user.name "CI/CD"
+
+mkdir -p ${IPFS_HOME}
+
+wget -qO- ${KUBO_URL} | tar xvz
+
+# wget -qO- ${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
+
+${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
+
+#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}"
+
+cp certificate.securelock.crt "${REGISTRY_PATH}/certificate.securelock.crt"
+cp certificate.trustedzone.crt "${REGISTRY_PATH}/certificate.trustedzone.crt"
+echo "${REGISTRY_PATH}"
+cd ${REGISTRY_PATH}
+
+echo ipfs pin add --progress ${IPFS_DOCKER_COMPOSE_HASH}
+${IPFS_CMD} pin add --progress ${IPFS_DOCKER_COMPOSE_HASH}
+
+#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 COMPOSE FROM IFPS HASH
+echo ipfs get ${IPFS_DOCKER_COMPOSE_HASH}
+${IPFS_CMD} get ${IPFS_DOCKER_COMPOSE_HASH}
+
+#DOWNLOADING DOCKER IMAGE FROM IFPS HASH
+echo ipfs get  ${IPFS_HASH}
+${IPFS_CMD} get  ${IPFS_HASH}
+
+
+#ADD DOCKER IMAGE to GIT
+echo touch ${CI_PROJECT_DIR}/etny-hash-packages/etny-pynithy/v3/${IPFS_HASH}
+touch ${CI_PROJECT_DIR}/etny-hash-packages/etny-pynithy/v3/${IPFS_HASH}
+
+#Add DOCKER COMPOSE  to GIT
+echo touch ${CI_PROJECT_DIR}/etny-hash-packages/etny-pynithy/v3/docker/${IPFS_DOCKER_COMPOSE_HASH}
+touch ${CI_PROJECT_DIR}/etny-hash-packages/etny-pynithy/v3/docker/${IPFS_DOCKER_COMPOSE_HASH}
+
+#ADDING CERTIFICATE TO GIT
+mv certificate.securelock.crt "${CI_PROJECT_DIR}/etny-hash-packages/etny-pynithy/v3/cert/securelock/${IPFS_HASH}.crt"
+cat "${CI_PROJECT_DIR}/etny-hash-packages/etny-pynithy/v3/cert/securelock/${IPFS_HASH}.crt"
+
+mv certificate.trustedzone.crt "${CI_PROJECT_DIR}/etny-hash-packages/etny-pynithy/v3/cert/trustedzone/${IPFS_HASH}.crt"
+cat "${CI_PROJECT_DIR}/etny-hash-packages/etny-pynithy/v3/cert/trustedzone/${IPFS_HASH}.crt"
+
+cd -
+
+echo "${IPFS_HASH}" > "IPFS_HASH.ipfs"
+echo "${IPFS_DOCKER_COMPOSE_HASH}" > "IPFS_DOCKER_COMPOSE_HASH.ipfs"