@ethernity-cloud/sdk-js 1.1.0

package/nodenithy/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/nodenithy/run/image_registry.py

@@ -0,0 +1,327 @@
+import os, sys
+
+from web3 import Web3
+from web3.middleware import geth_poa_middleware
+from eth_account import Account
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+PRIVATE_KEY = os.getenv("PRIVATE_KEY", "")
+
+BLOCKCHAIN_NETWORK = os.getenv("BLOCKCHAIN_NETWORK", "Bloxberg_Testnet")
+
+NETWORK_RPC = "https://bloxberg.ethernity.cloud"
+IMAGE_REGISTRY_ADDRESS = "0x15D73a742529C3fb11f3FA32EF7f0CC3870ACA31"  # Bloxberg
+CHAIN_ID = 8995
+GAS = 9000000
+GAS_PRICE = 1
+
+
+def set_vars(network: str = "") -> None:
+    global BLOCKCHAIN_NETWORK
+    global IMAGE_REGISTRY_ADDRESS
+    global NETWORK_RPC
+    global CHAIN_ID
+    global GAS
+    global GAS_PRICE
+    if "Bloxberg" in BLOCKCHAIN_NETWORK:
+        if "Mainnet" in BLOCKCHAIN_NETWORK:
+            IMAGE_REGISTRY_ADDRESS = "0x15D73a742529C3fb11f3FA32EF7f0CC3870ACA31"
+        else:
+            IMAGE_REGISTRY_ADDRESS = "0x15D73a742529C3fb11f3FA32EF7f0CC3870ACA31"
+    elif "Polygon" in BLOCKCHAIN_NETWORK:
+        if "Mainnet" in BLOCKCHAIN_NETWORK:
+            NETWORK_RPC = "https://polygon-pokt.nodies.app"
+            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
+
+
+set_vars()
+
+
+def is_string_private_key(private_key: str) -> str:
+    try:
+        _acct = Account.privateKeyToAccount(private_key)
+        return "OK"
+    except Exception as e:
+        return str(e)
+
+
+def check_acount_balance() -> int:
+    try:
+        _acct = Account.privateKeyToAccount(PRIVATE_KEY)
+        web3_provider = NETWORK_RPC
+        w3 = Web3(Web3.HTTPProvider(web3_provider))
+        w3.middleware_onion.inject(geth_poa_middleware, layer=0)
+
+        address = _acct.address
+        balance = w3.eth.getBalance(address)
+        return Web3.fromWei(balance, "ether")  # type: ignore
+    except Exception as e:
+        print(e)
+        return 0
+
+
+class ImageRegistry:
+    def __init__(self) -> None:
+        self.acct = None  # type: ignore
+        if PRIVATE_KEY:
+            self.acct = Account.privateKeyToAccount(PRIVATE_KEY)
+
+        image_registry_abi = self.__read_contract_abi("image_registry.abi")
+        self.image_registry_address = IMAGE_REGISTRY_ADDRESS
+
+        self.web3_provider = NETWORK_RPC
+        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: str) -> str:
+        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: str,
+        ipfs_hash: str,
+        image_name: str,
+        docker_compose_hash: str,
+        enclave_name_trustedzone: str,
+        fee: str,
+    ) -> None:
+        print("Adding trusted zone cert to image registry")
+        nonce = self.w3.eth.getTransactionCount(self.acct.address)
+        print(f"Nonce: {nonce}")
+        print("ipfs_hash: ", ipfs_hash)
+        print("cert_content: ", cert_content)
+        print("image_name: ", image_name)
+        print("docker_compose_hash: ", docker_compose_hash)
+        print("enclave_name_trustedzone: ", enclave_name_trustedzone)
+        print("fee: ", fee)
+        unicorn_txn = self.image_registry.functions.addTrustedZoneImage(
+            ipfs_hash,
+            cert_content,
+            "v3",
+            image_name,
+            docker_compose_hash,
+            enclave_name_trustedzone,
+            fee,
+        ).buildTransaction(
+            {
+                "gas": GAS,
+                "chainId": CHAIN_ID,
+                "nonce": nonce,
+                "gasPrice": self.w3.toWei("1", "mwei") if GAS_PRICE == 1 else GAS_PRICE,
+            }
+        )
+
+        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: str,
+        ipfs_hash: str,
+        image_name: str,
+        docker_compose_hash: str,
+        enclave_name_securelock: str,
+        fee: str,
+    ) -> None:
+        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,
+            int(fee),
+        ).buildTransaction(
+            {
+                "gas": GAS,
+                "chainId": CHAIN_ID,
+                "nonce": nonce,
+                "gasPrice": self.w3.toWei("1", "mwei") if GAS_PRICE == 1 else GAS_PRICE,
+            }
+        )
+        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: str) -> None:
+        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": GAS,
+                "chainId": CHAIN_ID,
+                "nonce": nonce,
+                "gasPrice": self.w3.toWei("1", "mwei") if GAS_PRICE == 1 else GAS_PRICE,
+            }
+        )
+        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: str,
+        ipfs_hash: str,
+        image_name: str,
+        docker_compose_hash: str,
+        enclave_name_securelock: str,
+        fee: str,
+    ) -> None:
+        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: str) -> None:
+        cert = self.image_registry.caller().getTrustedZoneImageCertPublicKey(
+            image_ipfs_hash
+        )
+        print(cert)
+
+    def get_secure_lock_cert(self, image_ipfs_hash: str) -> None:
+        cert = self.image_registry.caller().getImageCertPublicKey(image_ipfs_hash)
+        print(cert)
+
+    def get_image_details(self, image_ipfs_hash: str) -> list:
+        imageDetails = self.image_registry.caller().imageDetails(image_ipfs_hash)
+        return imageDetails
+
+    def get_latest_image_version_public_key(
+        self, image_name: str, image_version: str
+    ) -> list:
+        imageVersionPublicKey = (
+            self.image_registry.caller().getLatestImageVersionPublicKey(
+                image_name, image_version
+            )
+        )
+        return imageVersionPublicKey
+
+
+if __name__ == "__main__":
+    try:
+        network_name = sys.argv[1]
+        project_name = sys.argv[2]
+        version = sys.argv[3]
+        if network_name and project_name:
+            BLOCKCHAIN_NETWORK = network_name
+    except Exception as e:
+        print(e)
+        exit(0)
+
+    private_key = ""
+    try:
+        private_key = sys.argv[4]
+    except:
+        pass
+    set_vars(network_name)
+
+    image_registry = ImageRegistry()
+    try:
+        imageHash = image_registry.get_latest_image_version_public_key(
+            project_name, version
+        )[0]
+        imageOwner = image_registry.get_image_details(imageHash)[0]
+
+        if private_key:
+            if is_string_private_key(private_key) == "OK":
+                # check if the imageOwner is the same as the private key owner
+                _acct = Account.privateKeyToAccount(private_key)
+                # print("private key account address:" + _acct.address)
+                if imageOwner != _acct.address:
+                    print(
+                        f"!!! Image: '{project_name}' Version: '{version}' is owned by '{imageOwner}'.\nYou are not the account holder of the image.\nPlease change the project name and try again.\n"
+                    )
+                    exit(1)
+
+        # print(f"Image Owner: {imageOwner}")
+        if imageOwner:
+            print(
+                f"Image: '{project_name}' Version: '{version}' 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"
+            )
+            exit(0)
+    except Exception as e:
+        # print(e)
+        pass
+
+    print(
+        f"Image: '{project_name}' Version: '{version}' is available on the {network_name} blockchain."
+    )