Introducing Smart Contracts to BlockCerts

README.md

@@ -2,10 +2,14 @@
 [![PyPI version](https://badge.fury.io/py/cert-issuer.svg)](https://badge.fury.io/py/cert-issuer)
 
 
+
 # cert-issuer
 
 The cert-issuer project issues blockchain certificates by creating a transaction from the issuing institution to the
-recipient on the Bitcoin blockchain that includes the hash of the certificate itself. 
+recipient on the Bitcoin blockchain that includes the hash of the certificate itself.
+
+## What's special about this fork?
+See our [documentation](docs/ethereum_smart_contract.md).
 
 ## Web resources
 For development or testing using web requests, check out the documentation at [docs/web_resources.md](./docs/web_resources.md).
@@ -189,14 +193,18 @@ Decide which chain (Bitcoin or Ethereum) to issue to and follow the steps. The b
 By default, cert-issuer issues to the Bitcoin blockchain. Run the default setup script if this is the mode you want:
 ```
 python setup.py install
-
 ```
 
 To issue to the ethereum blockchain, run the following:
 ```
-python setup.py experimental --blockchain=ethereum
+python setup.py install experimental --blockchain=ethereum
+```
 
+To issue to the ethereum blockchain using the smart contract backend, run the following:
+```
+python setup.py install experimental --blockchain=ethereum_smart_contract
 ```
+For more information on the smart contract backend reference the [complete documentation](docs/ethereum_smart_contract.md).
 
 ### Create a Bitcoin issuing address
 

cert_issuer/blockchain_handlers/bitcoin/transaction_handlers.py

@@ -50,7 +50,7 @@ def ensure_balance(self):
             logging.error(error_message)
             raise InsufficientFundsError(error_message)
 
-    def issue_transaction(self, blockchain_bytes):
+    def issue_transaction(self, blockchain_bytes, app_config):
         op_return_value = b2h(blockchain_bytes)
         prepared_tx = self.create_transaction(blockchain_bytes)
         signed_tx = self.sign_transaction(prepared_tx)

cert_issuer/blockchain_handlers/ethereum/transaction_handlers.py

@@ -54,7 +54,7 @@ def ensure_balance(self):
             logging.error(error_message)
             raise InsufficientFundsError(error_message)
 
-    def issue_transaction(self, blockchain_bytes):
+    def issue_transaction(self, blockchain_bytes, app_config):
         eth_data_field = b2h(blockchain_bytes)
         prepared_tx = self.create_transaction(blockchain_bytes)
         signed_tx = self.sign_transaction(prepared_tx)

cert_issuer/blockchain_handlers/ethereum_sc/__init__.py

@@ -0,0 +1,96 @@
+import logging
+import os
+
+from cert_core import BlockchainType
+from cert_core import Chain, UnknownChainError
+
+from cert_issuer.certificate_handlers import CertificateBatchHandler, CertificateV2Handler
+from cert_issuer.blockchain_handlers.ethereum_sc.connectors import EthereumSCServiceProviderConnector
+from cert_issuer.blockchain_handlers.ethereum_sc.ens import ENSConnector
+from cert_issuer.blockchain_handlers.ethereum_sc.signer import EthereumSCSigner
+from cert_issuer.blockchain_handlers.ethereum_sc.transaction_handlers import EthereumSCTransactionHandler
+from cert_issuer.merkle_tree_generator import MerkleTreeGenerator
+from cert_issuer.models import MockTransactionHandler
+from cert_issuer.signer import FileSecretManager
+from cert_issuer.errors import ENSEntryError, MissingArgumentError
+
+
+class EthereumTransactionCostConstants(object):
+    def __init__(self, recommended_gas_price, recommended_gas_limit):
+        self.recommended_gas_price = recommended_gas_price
+        self.recommended_gas_limit = recommended_gas_limit
+        logging.info('Set cost constants to recommended_gas_price=%f, recommended_gas_limit=%f',
+                     self.recommended_gas_price, self.recommended_gas_limit)
+
+    """
+    The below methods currently only use the supplied gasprice/limit.
+    These values can also be better estimated via a call to the Ethereum blockchain.
+    """
+
+    def get_recommended_max_cost(self):
+        return self.recommended_gas_price * self.recommended_gas_limit
+
+    def get_gas_price(self):
+        return self.recommended_gas_price
+
+    def get_gas_limit(self):
+        return self.recommended_gas_limit
+
+
+def initialize_signer(app_config):
+    path_to_secret = os.path.join(app_config.usb_name, app_config.key_file)
+
+    if app_config.chain.blockchain_type == BlockchainType.ethereum:
+        signer = EthereumSCSigner(ethereum_chain=app_config.chain)
+    elif app_config.chain == Chain.mockchain:
+        signer = None
+    else:
+        raise UnknownChainError(app_config.chain)
+    secret_manager = FileSecretManager(signer=signer, path_to_secret=path_to_secret,
+                                       safe_mode=app_config.safe_mode, issuing_address=app_config.issuing_address)
+    return secret_manager
+
+
+def instantiate_connector(app_config, cost_constants):
+    # if contr_addr is not set explicitly (recommended), get it from ens entry
+    ens = ENSConnector(app_config)
+    contr_addr = ens.get_addr()
+
+    if contr_addr == "0x0000000000000000000000000000000000000000":
+        raise ENSEntryError(f"Resolved address {contr_addr} from ENS entry {app_config.ens_name}")
+
+    app_config.contract_address = contr_addr
+
+    connector = EthereumSCServiceProviderConnector(app_config, contr_addr, cost_constants=cost_constants)
+    return connector
+
+def check_necessary_arguments(app_config):
+    # required arguments only for smart_contract method
+    if app_config.ens_name is None:
+        raise MissingArgumentError("Missing argument ens_name, check your config file.")
+    if app_config.node_url is None:
+        raise MissingArgumentError("Missing argument node_url, check your config file.")
+
+    # required only if revoke is set
+    if app_config.revoke is True and app_config.revocation_list_file is None:
+        raise MissingArgumentError("Missing argument revocation_list_file, check your config file.")
+
+def instantiate_blockchain_handlers(app_config):
+    check_necessary_arguments(app_config)
+
+    issuing_address = app_config.issuing_address
+    chain = app_config.chain
+    secret_manager = initialize_signer(app_config)
+    certificate_batch_handler = CertificateBatchHandler(secret_manager=secret_manager,
+                                                        certificate_handler=CertificateV2Handler(),
+                                                        merkle_tree=MerkleTreeGenerator())
+    if chain == Chain.mockchain:
+        transaction_handler = MockTransactionHandler()
+    # ethereum chains
+    elif chain == Chain.ethereum_mainnet or chain == Chain.ethereum_ropsten:
+        cost_constants = EthereumTransactionCostConstants(app_config.gas_price, app_config.gas_limit)
+        connector = instantiate_connector(app_config, cost_constants)
+        transaction_handler = EthereumSCTransactionHandler(connector, cost_constants, secret_manager,
+                                                           issuing_address=issuing_address)
+
+    return certificate_batch_handler, transaction_handler, connector

cert_issuer/blockchain_handlers/ethereum_sc/connectors.py

@@ -0,0 +1,103 @@
+import json
+import os
+import logging
+from errors import UnableToSignTxError
+
+from cert_issuer.models import ServiceProviderConnector
+from web3 import Web3, HTTPProvider
+
+
+def get_abi(contract):
+    """
+    Returns smart contract abi.
+    possible values for contract: "blockcerts", "ens_registry"
+    """
+
+    directory = os.path.dirname(os.path.abspath(__file__))
+    path = os.path.join(directory, f"data/{contract}_abi.json")
+
+    with open(path, "r") as f:
+        raw = f.read()
+    abi = json.loads(raw)
+    return abi
+
+
+# this class can be used for both ENS contracts as well as our own ("cert_store")
+class EthereumSCServiceProviderConnector(ServiceProviderConnector):
+    """
+    Collects abi, address, contract data and instantiates a contract object
+    """
+    def __init__(self, app_config, contract_address, abi_type="cert_store", private_key=None, cost_constants=None):
+        self.cost_constants = cost_constants
+
+        self.app_config = app_config
+        self._private_key = private_key
+
+        if abi_type == "cert_store":
+            from cert_issuer.blockchain_handlers.ethereum_sc.ens import ENSConnector
+            abi = ENSConnector(app_config).get_abi()
+        else:
+            abi = get_abi(abi_type)
+
+        self._w3 = Web3(HTTPProvider(self.app_config.node_url))
+        self._w3.eth.defaultAccount = self.app_config.issuing_address
+
+        self._contract_obj = self._w3.eth.contract(address=contract_address, abi=abi)
+
+    def get_balance(self, address):
+        return self._w3.eth.getBalance(address)
+
+    def create_transaction(self, method, *argv):
+        gas_limit = self.cost_constants.get_gas_limit()
+        estimated_gas = self._contract_obj.functions[method](*argv).estimateGas() * 2
+        if estimated_gas > gas_limit:
+            logging.warning("Estimated gas of %s more than gas limit of %s, transaction might fail. Please verify on etherescan.com.", estimated_gas, gas_limit)
+            estimated_gas = gas_limit
+
+        gas_price = self._w3.eth.gasPrice
+        gas_price_limit = self.cost_constants.get_gas_price()
+
+        if gas_price > gas_price_limit:
+            logging.warning("Gas price provided by network of %s higher than gas price of %s set in config, transaction might fail. Please verify on etherescan.com.", gas_price, gas_price_limit)
+            gas_price = gas_price_limit
+
+        tx_options = {
+            'nonce': self._w3.eth.getTransactionCount(self._w3.eth.defaultAccount),
+            'gas': estimated_gas,
+            'gasPrice': gas_price
+            }
+
+        construct_txn = self._contract_obj.functions[method](*argv).buildTransaction(tx_options)
+        return construct_txn
+
+    def broadcast_tx(self, signed_tx):
+        tx_hash = self._w3.eth.sendRawTransaction(signed_tx.rawTransaction)
+        tx_receipt = self._w3.eth.waitForTransactionReceipt(tx_hash)
+        return tx_receipt.transactionHash.hex()
+
+    def transact(self, method, *argv):
+        """
+        Sends a signed transaction on the blockchain and waits for a response.
+        If initialized with private key this class can sign the transaction.
+        In general, an external signer should be used in conjunction with
+        create_transaction() and broadcast_tx.
+        """
+        if self._private_key is None:
+            raise UnableToSignTxError("This method is only available if a private key was passed upon initialization")
+
+        prepared_tx = self.create_transaction(method, *argv)
+        signed_tx = self._sign_transaction(prepared_tx)
+        txid = self.broadcast_transaction(signed_tx)
+        return txid
+
+    def _sign_transaction(self, prepared_tx):
+        acct = self._w3.eth.account.from_key(self._private_key)
+
+        try:
+            signed_tx = acct.sign_transaction(prepared_tx)
+            return signed_tx
+        except Exception:
+            raise UnableToSignTxError('You are trying to sign a non transaction type')
+
+    def call(self, method, *argv):
+        return self._contract_obj.functions[method](*argv).call()