Merge remote-tracking branch 'origin/feat/mainsail' into refactor/class-based-slot-module

Author: alexbarnsley

crypto/configuration/network.py

@@ -1,53 +1,26 @@
-from datetime import datetime
-from typing import Type, TypedDict, Union
-from crypto.networks.mainnet import Mainnet
+from crypto.networks.abstract_network import AbstractNetwork
 from crypto.networks.testnet import Testnet
 
-class NetworkType(TypedDict):
-    epoch: datetime
-    wif: str
-    chain_id: int
+class Network:
+    _network: AbstractNetwork
 
-network: NetworkType = {
-    'epoch': Testnet.epoch,
-    'wif': Testnet.wif,
-    'chain_id': Testnet.chain_id,
-}
+    @classmethod
+    def set_network(cls, network: AbstractNetwork) -> None:
+        """Set what network you want to use in the crypto library
 
-def set_network(network_object: Union[Type[Mainnet], Type[Testnet]]) -> None:
-    """Set what network you want to use in the crypto library
+        Args:
+            network_object: Testnet, Devnet, Mainnet
+        """
 
-    Args:
-        network_object: Testnet, Devnet, Mainnet
-    """
-    global network
+        cls._network = network
 
-    network = {
-        'epoch': network_object.epoch,
-        'wif': network_object.wif,
-        'chain_id': network_object.chain_id,
-    }
+    @classmethod
+    def get_network(cls) -> AbstractNetwork:
+        """Get settings for a selected network
 
-def get_network() -> NetworkType:
-    """Get settings for a selected network, default network is devnet
+        Returns:
+            AbstractNetwork: network settings (default network is testnet)
+        """
+        return cls._network
 
-    Returns:
-        dict: network settings (default network is devnet)
-    """
-    return network
-
-def set_custom_network(epoch: datetime, wif: str, chain_id: int) -> None:
-    """Set custom network
-
-    Args:
-        epoch (datetime): chains epoch time
-        wif (str): chains wif
-        chain_id (int): chain id
-    """
-    global network
-
-    network = {
-        'epoch': epoch,
-        'wif': wif,
-        'chain_id': chain_id
-    }
+Network.set_network(Testnet())

crypto/identity/address.py

@@ -4,76 +4,81 @@
 from crypto.identity.private_key import PrivateKey
 
 from Cryptodome.Hash import keccak
-from coincurve import PrivateKey, PublicKey
+from coincurve import PublicKey
 
-def get_checksum_address(address: str) -> str:
-    """Get checksum address
+class Address:
+    @classmethod
+    def from_public_key(cls, public_key: str) -> str:
+        """Get an address from a public key
 
-    Args:
-        address (str): address to get checksum
+        Args:
+            public_key (str): public key to get address
 
-    Returns:
-        str: checksum address
-    """
-    address = address.lower()
+        Returns:
+            str: address
+        """
 
-    chars = list(address[2:])
+        public_key_bytes = PublicKey(bytes.fromhex(public_key)).format(compressed=False)[1:]
 
-    expanded = bytearray(40)
-    for i in range(40):
-        expanded[i] = ord(chars[i])
+        keccak_hash = keccak.new(
+            data=bytearray.fromhex(public_key_bytes.hex()),
+            digest_bits=256,
+        )
 
-    hashed = keccak.new(data=bytes(expanded), digest_bits=256).digest()
+        return cls.get_checksum_address(unhexlify(keccak_hash.hexdigest()[22:]).hex())
 
-    for i in range(0, 40, 2):
-        if (hashed[i >> 1] >> 4) >= 8:
-            chars[i] = chars[i].upper()
-        if (hashed[i >> 1] & 0x0F) >= 8:
-            chars[i + 1] = chars[i + 1].upper()
+    @classmethod
+    def from_private_key(cls, private_key: str) -> str:
+        """Get an address from private key
 
-    return "0x" + ''.join(chars)
+        Args:
+            private_key (string): private key to get address
 
-def address_from_public_key(public_key: str) -> str:
-    """Get an address from a public key
+        Returns:
+            str: address
+        """
+        private_key_object = PrivateKey.from_hex(private_key)
 
-    Args:
-        public_key (str): public key to get address
+        return cls.from_public_key(private_key_object.public_key)
 
-    Returns:
-        str: address
-    """
+    @classmethod
+    def from_passphrase(cls, passphrase: str) -> str:
+        """Get an address from passphrase
 
-    public_key_bytes = PublicKey(bytes.fromhex(public_key)).format(compressed=False)[1:]
+        Args:
+            passphrase (str): passphrase to get address
 
-    keccak_hash = keccak.new(
-        data=bytearray.fromhex(public_key_bytes.hex()),
-        digest_bits=256,
-    )
+        Returns:
+            str: address
+        """
+        private_key = hashlib.sha256(passphrase.encode()).hexdigest()
 
-    return get_checksum_address(unhexlify(keccak_hash.hexdigest()[22:]).hex())
+        return cls.from_private_key(private_key)
 
-def address_from_private_key(private_key: str) -> str:
-    """Get an address from private key
+    @classmethod
+    def get_checksum_address(cls, address: str) -> str:
+        """Get checksum address
 
-    Args:
-        private_key (string): private key to get address
+        Args:
+            address (str): address to get checksum
 
-    Returns:
-        str: address
-    """
-    private_key_object = PrivateKey.from_hex(private_key)
+        Returns:
+            str: checksum address
+        """
+        address = address.lower()
 
-    return address_from_public_key(private_key_object.public_key.format(compressed=False).hex())
+        chars = list(address[2:])
 
-def address_from_passphrase(passphrase: str) -> str:
-    """Get an address from passphrase
+        expanded = bytearray(40)
+        for i in range(40):
+            expanded[i] = ord(chars[i])
 
-    Args:
-        passphrase (str): passphrase to get address
+        hashed = keccak.new(data=bytes(expanded), digest_bits=256).digest()
 
-    Returns:
-        str: address
-    """
-    private_key = hashlib.sha256(passphrase.encode()).hexdigest()
+        for i in range(0, 40, 2):
+            if (hashed[i >> 1] >> 4) >= 8:
+                chars[i] = chars[i].upper()
+            if (hashed[i >> 1] & 0x0F) >= 8:
+                chars[i + 1] = chars[i + 1].upper()
 
-    return address_from_private_key(private_key)
+        return "0x" + ''.join(chars)

crypto/identity/private_key.py

@@ -4,7 +4,7 @@
 from Cryptodome.Hash import keccak
 from base58 import b58decode
 
-from crypto.configuration.network import get_network
+from crypto.configuration.network import Network
 from crypto.enums.constants import Constants
 
 class PrivateKey(object):
@@ -76,7 +76,7 @@ def from_wif(cls, wif: str):
         wif = b58decode(wif).hex()
 
         version = wif[0:2]
-        if version != get_network()['wif']:
+        if version != Network.get_network().wif():
             raise ValueError(f"Invalid network version: {version}")
 
         private_key = wif[2:66]

crypto/identity/public_key.py

@@ -8,9 +8,6 @@ class PublicKey(object):
     def __init__(self, public_key: str):
         self.public_key = PubKey(unhexlify(public_key.encode()))
 
-    def to_hex(self) -> str:
-        return hexlify(self.public_key.format()).decode()
-
     @classmethod
     def from_passphrase(cls, passphrase: str) -> str:
         private_key = PrivateKey.from_passphrase(passphrase)

crypto/identity/wif.py

@@ -5,7 +5,7 @@
 
 from binary.unsigned_integer.writer import write_bit8
 
-from crypto.configuration.network import get_network
+from crypto.configuration.network import Network
 
 def wif_from_passphrase(passphrase: str, network_wif: Optional[str] = None):
     """Get wif from passphrase
@@ -18,9 +18,9 @@ def wif_from_passphrase(passphrase: str, network_wif: Optional[str] = None):
         string: wif
     """
     if not network_wif:
-        network = get_network()
+        network = Network.get_network()
 
-        network_wif = network['wif']
+        network_wif = network.wif()
 
     private_key = hashlib.sha256(passphrase.encode())
     seed = write_bit8(int(network_wif, 16)) + private_key.digest() + write_bit8(0x01)

crypto/networks/abstract_network.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+class AbstractNetwork(ABC):
+    @abstractmethod
+    def chain_id(self) -> int:
+        """Return the chain ID of the network."""
+
+    @abstractmethod
+    def epoch(self) -> str:
+        """Return the epoch time of the network."""
+
+    @abstractmethod
+    def wif(self) -> str:
+        """Return the WIF (Wallet Import Format) of the network."""

crypto/networks/mainnet.py

@@ -1,6 +1,11 @@
-from datetime import datetime
+from crypto.networks.abstract_network import AbstractNetwork
 
-class Mainnet(object):
-    epoch = datetime(2017, 3, 21, 13, 00, 00)
-    wif = 'ba'
-    chain_id = 10000
+class Mainnet(AbstractNetwork):
+    def chain_id(self):
+        return 10000
+
+    def epoch(self):
+        return '2017-03-21T13:00:00.000Z'
+
+    def wif(self):
+        return 'ba'

crypto/networks/testnet.py

@@ -1,6 +1,11 @@
-from datetime import datetime
+from crypto.networks.abstract_network import AbstractNetwork
 
-class Testnet(object):
-    epoch = datetime(2017, 3, 21, 13, 00, 00)
-    wif = 'ba'
-    chain_id = 10000
+class Testnet(AbstractNetwork):
+    def chain_id(self):
+        return 10000
+
+    def epoch(self):
+        return '2017-03-21T13:00:00.000Z'
+
+    def wif(self):
+        return 'ba'

crypto/transactions/builder/base.py

@@ -1,5 +1,4 @@
-from typing import Optional
-from crypto.configuration.network import get_network
+from crypto.configuration.network import Network
 from crypto.identity.private_key import PrivateKey
 from crypto.transactions.types.abstract_transaction import AbstractTransaction
 
@@ -11,7 +10,7 @@ def __init__(self, data: dict):
             'senderPublicKey': '',
             'gasPrice': '5',
             'nonce': '1',
-            'network': get_network()['chain_id'],
+            'network': Network.get_network().chain_id(),
             'gasLimit': 1_000_000,
             'data': '',