hive-nectar 0.0.2__py3-none-any.whl

nectargraphenebase/signedtransactions.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+import hashlib
+import logging
+from binascii import hexlify, unhexlify
+from collections import OrderedDict
+
+import ecdsa
+
+from nectargraphenebase.py23 import py23_bytes
+
+from .account import PublicKey
+from .chains import known_chains
+from .ecdsasig import sign_message, verify_message
+from .objects import GrapheneObject, Operation, isArgsThisClass
+from .types import (
+    Array,
+    PointInTime,
+    Set,
+    Signature,
+    Uint16,
+    Uint32,
+)
+
+log = logging.getLogger(__name__)
+
+
+class Signed_Transaction(GrapheneObject):
+    """Create a signed transaction and offer method to create the
+    signature
+
+    :param num ref_block_num: reference block number
+    :param num ref_block_prefix:
+    :param str expiration: expiration date
+    :param array operations:  array of operations
+    """
+
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            prefix = kwargs.pop("prefix", "STM")
+            if "extensions" not in kwargs:
+                kwargs["extensions"] = Set([])
+            elif not kwargs.get("extensions"):
+                kwargs["extensions"] = Set([])
+            if "signatures" not in kwargs:
+                kwargs["signatures"] = Array([])
+            else:
+                kwargs["signatures"] = Array(
+                    [Signature(unhexlify(a)) for a in kwargs["signatures"]]
+                )
+
+            if "operations" in kwargs:
+                opklass = self.getOperationKlass()
+                if all([not isinstance(a, opklass) for a in kwargs["operations"]]):
+                    kwargs["operations"] = Array(
+                        [opklass(a, prefix=prefix) for a in kwargs["operations"]]
+                    )
+                else:
+                    kwargs["operations"] = Array(kwargs["operations"])
+
+            super(Signed_Transaction, self).__init__(
+                OrderedDict(
+                    [
+                        ("ref_block_num", Uint16(kwargs["ref_block_num"])),
+                        ("ref_block_prefix", Uint32(kwargs["ref_block_prefix"])),
+                        ("expiration", PointInTime(kwargs["expiration"])),
+                        ("operations", kwargs["operations"]),
+                        ("extensions", kwargs["extensions"]),
+                        ("signatures", kwargs["signatures"]),
+                    ]
+                )
+            )
+
+    @property
+    def id(self):
+        """The transaction id of this transaction"""
+        # Store signatures temporarily since they are not part of
+        # transaction id
+        sigs = self.data["signatures"]
+        self.data.pop("signatures", None)
+
+        # Generage Hash of the seriliazed version
+        h = hashlib.sha256(py23_bytes(self)).digest()
+
+        # recover signatures
+        self.data["signatures"] = sigs
+
+        # Return properly truncated tx hash
+        return hexlify(h[:20]).decode("ascii")
+
+    def getOperationKlass(self):
+        return Operation
+
+    def derSigToHexSig(self, s):
+        """Format DER to HEX signature"""
+        s, junk = ecdsa.der.remove_sequence(unhexlify(s))
+        if junk:
+            log.debug("JUNK: %s", hexlify(junk).decode("ascii"))
+        if not (junk == b""):
+            raise AssertionError()
+        x, s = ecdsa.der.remove_integer(s)
+        y, s = ecdsa.der.remove_integer(s)
+        return "%064x%064x" % (x, y)
+
+    def getKnownChains(self):
+        return known_chains
+
+    def getChainParams(self, chain):
+        # Which network are we on:
+        chains = self.getKnownChains()
+        if isinstance(chain, str) and chain in chains:
+            chain_params = chains[chain]
+        elif isinstance(chain, dict):
+            chain_params = chain
+        else:
+            raise Exception("sign() only takes a string or a dict as chain!")
+        if "chain_id" not in chain_params:
+            raise Exception("sign() needs a 'chain_id' in chain params!")
+        return chain_params
+
+    def deriveDigest(self, chain):
+        chain_params = self.getChainParams(chain)
+        # Chain ID
+        self.chainid = chain_params["chain_id"]
+
+        # Do not serialize signatures
+        sigs = self.data["signatures"]
+        self.data["signatures"] = []
+
+        # Get message to sign
+        #   bytes(self) will give the wire formated data according to
+        #   GrapheneObject and the data given in __init__()
+        self.message = unhexlify(self.chainid) + py23_bytes(self)
+        self.digest = hashlib.sha256(self.message).digest()
+
+        # restore signatures
+        self.data["signatures"] = sigs
+
+    def verify(self, pubkeys=[], chain=None, recover_parameter=False):
+        """Returned pubkeys have to be checked if they are existing"""
+        if not chain:
+            raise
+        chain_params = self.getChainParams(chain)
+        self.deriveDigest(chain)
+        signatures = self.data["signatures"].data
+        pubKeysFound = []
+
+        for signature in signatures:
+            if recover_parameter:
+                p = verify_message(self.message, py23_bytes(signature))
+            else:
+                p = None
+            if p is None:
+                for i in range(4):
+                    try:
+                        p = verify_message(self.message, py23_bytes(signature), recover_parameter=i)
+                        phex = hexlify(p).decode("ascii")
+                        pubKeysFound.append(phex)
+                    except Exception:
+                        p = None
+            else:
+                phex = hexlify(p).decode("ascii")
+                pubKeysFound.append(phex)
+
+        for pubkey in pubkeys:
+            if not isinstance(pubkey, PublicKey):
+                raise Exception("Pubkeys must be array of 'PublicKey'")
+
+            k = pubkey.unCompressed()[2:]
+            if k not in pubKeysFound and repr(pubkey) not in pubKeysFound:
+                k = PublicKey(PublicKey(k).compressed())
+                f = format(k, chain_params["prefix"])
+                raise Exception("Signature for %s missing!" % f)
+        return pubKeysFound
+
+    def sign(self, wifkeys, chain=None):
+        """Sign the transaction with the provided private keys.
+
+        :param array wifkeys: Array of wif keys
+        :param str chain: identifier for the chain
+
+        """
+        if not chain:
+            raise Exception("Chain needs to be provided!")
+        self.deriveDigest(chain)
+
+        # Get Unique private keys
+        self.privkeys = []
+        [self.privkeys.append(item) for item in wifkeys if item not in self.privkeys]
+
+        # Sign the message with every private key given!
+        sigs = []
+        for wif in self.privkeys:
+            signature = sign_message(self.message, wif)
+            sigs.append(Signature(signature))
+
+        self.data["signatures"] = Array(sigs)
+        return self

nectargraphenebase/types.py

@@ -0,0 +1,419 @@
+# -*- coding: utf-8 -*-
+import json
+import struct
+import sys
+import time
+from binascii import hexlify, unhexlify
+from calendar import timegm
+from datetime import datetime
+
+from .py23 import py23_bytes
+
+timeformat = "%Y-%m-%dT%H:%M:%S%Z"
+
+
+def varint(n):
+    """Varint encoding."""
+    data = b""
+    while n >= 0x80:
+        data += bytes([(n & 0x7F) | 0x80])
+        n >>= 7
+    data += bytes([n])
+    return data
+
+
+def varintdecode(data):
+    """Varint decoding."""
+    shift = 0
+    result = 0
+    for b in bytes(data):
+        result |= (b & 0x7F) << shift
+        if not (b & 0x80):
+            break
+        shift += 7
+    return result
+
+
+def variable_buffer(s):
+    """Encodes variable length buffer."""
+    return varint(len(s)) + s
+
+
+def JsonObj(data):
+    """Returns json object from data."""
+    return json.loads(str(data))
+
+
+class Uint8(object):
+    """Uint8."""
+
+    def __init__(self, d):
+        """init."""
+        self.data = int(d)
+
+    def __bytes__(self):
+        """Returns bytes."""
+        return struct.pack("<B", self.data)
+
+    def __str__(self):
+        """Returns str"""
+        return "%d" % self.data
+
+
+class Int16(object):
+    """Int16."""
+
+    def __init__(self, d):
+        """init."""
+        self.data = int(d)
+
+    def __bytes__(self):
+        """Returns bytes."""
+        return struct.pack("<h", int(self.data))
+
+    def __str__(self):
+        return "%d" % self.data
+
+
+class Uint16(object):
+    def __init__(self, d):
+        self.data = int(d)
+
+    def __bytes__(self):
+        """Returns bytes."""
+        return struct.pack("<H", self.data)
+
+    def __str__(self):
+        return "%d" % self.data
+
+
+class Uint32(object):
+    def __init__(self, d):
+        self.data = int(d)
+
+    def __bytes__(self):
+        """Returns bytes."""
+        return struct.pack("<I", self.data)
+
+    def __str__(self):
+        """Returns data as string."""
+        return "%d" % self.data
+
+
+class Uint64(object):
+    def __init__(self, d):
+        self.data = int(d)
+
+    def __bytes__(self):
+        """Returns bytes."""
+        return struct.pack("<Q", self.data)
+
+    def __str__(self):
+        """Returns data as string."""
+        return "%d" % self.data
+
+
+class Varint32(object):
+    def __init__(self, d):
+        self.data = int(d)
+
+    def __bytes__(self):
+        """Returns bytes."""
+        return varint(self.data)
+
+    def __str__(self):
+        """Returns data as string."""
+        return "%d" % self.data
+
+
+class Int64(object):
+    def __init__(self, d):
+        self.data = int(d)
+
+    def __bytes__(self):
+        """Returns bytes."""
+        return struct.pack("<q", self.data)
+
+    def __str__(self):
+        """Returns data as string."""
+        return "%d" % self.data
+
+
+class HexString(object):
+    def __init__(self, d):
+        self.data = d
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        d = bytes(unhexlify(bytes(self.data, "ascii")))
+        return varint(len(d)) + d
+
+    def __str__(self):
+        """Returns data as string."""
+        return "%s" % str(self.data)
+
+
+class String(object):
+    def __init__(self, d):
+        self.data = d
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        d = self.unicodify()
+        return varint(len(d)) + d
+
+    def __str__(self):
+        """Returns data as string."""
+        return "%s" % str(self.data)
+
+    def unicodify(self):
+        r = []
+        for s in self.data:
+            o = ord(s)
+            if (o <= 7) or (o == 11) or (o > 13 and o < 32):
+                r.append("u%04x" % o)
+            elif o == 8:
+                r.append("b")
+            elif o == 9:
+                r.append("\t")
+            elif o == 10:
+                r.append("\n")
+            elif o == 12:
+                r.append("f")
+            elif o == 13:
+                r.append("\r")
+            else:
+                r.append(s)
+        return bytes("".join(r), "utf-8")
+
+
+class Bytes(object):
+    def __init__(self, d):
+        self.data = d
+
+    def __bytes__(self):
+        """Returns data as bytes."""
+        d = unhexlify(bytes(self.data, "utf-8"))
+        return varint(len(d)) + d
+
+    def __str__(self):
+        """Returns data as string."""
+        return str(self.data)
+
+
+class Hash(Bytes):
+    def json(self):
+        return str(self.data)
+
+    def __bytes__(self):
+        return unhexlify(bytes(self.data, "utf-8"))
+
+
+class Ripemd160(Hash):
+    def __init__(self, a):
+        assert len(a) == 40, "Require 40 char long hex"
+        super().__init__(a)
+
+
+class Sha1(Hash):
+    def __init__(self, a):
+        assert len(a) == 40, "Require 40 char long hex"
+        super().__init__(a)
+
+
+class Sha256(Hash):
+    def __init__(self, a):
+        assert len(a) == 64, "Require 64 char long hex"
+        super().__init__(a)
+
+
+class Void(object):
+    def __init__(self):
+        pass
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        return b""
+
+    def __str__(self):
+        """Returns data as string."""
+        return ""
+
+
+class Array(object):
+    def __init__(self, d):
+        self.data = d
+        self.length = Varint32(len(self.data))
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        return py23_bytes(self.length) + b"".join([py23_bytes(a) for a in self.data])
+
+    def __str__(self):
+        """Returns data as string."""
+        r = []
+        for a in self.data:
+            try:
+                if isinstance(a, String):
+                    r.append(str(a))
+                else:
+                    r.append(JsonObj(a))
+            except Exception:
+                r.append(str(a))
+        return json.dumps(r)
+
+
+class PointInTime(object):
+    def __init__(self, d):
+        self.data = d
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        if isinstance(self.data, datetime):
+            unixtime = timegm(self.data.timetuple())
+        elif sys.version > "3":
+            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat))
+        else:
+            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat.encode("utf-8")))
+        if unixtime < 0:
+            return struct.pack("<i", unixtime)
+        return struct.pack("<I", unixtime)
+
+    def __str__(self):
+        """Returns data as string."""
+        return self.data
+
+
+class Signature(object):
+    def __init__(self, d):
+        self.data = d
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        return self.data
+
+    def __str__(self):
+        """Returns data as string."""
+        return json.dumps(hexlify(self.data).decode("ascii"))
+
+
+class Bool(Uint8):  # Bool = Uint8
+    def __init__(self, d):
+        super(Bool, self).__init__(d)
+
+    def __str__(self):
+        """Returns data as string."""
+        return json.dumps(True) if self.data else json.dumps(False)
+
+
+class Set(Array):  # Set = Array
+    def __init__(self, d):
+        super(Set, self).__init__(d)
+
+
+class Fixed_array(object):
+    def __init__(self, d):
+        raise NotImplementedError
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        raise NotImplementedError
+
+    def __str__(self):
+        """Returns data as string."""
+        raise NotImplementedError
+
+
+class Optional(object):
+    def __init__(self, d):
+        self.data = d
+
+    def __bytes__(self):
+        """Returns data as bytes."""
+        if not self.data:
+            return py23_bytes(Bool(0))
+        else:
+            return (
+                py23_bytes(Bool(1)) + py23_bytes(self.data)
+                if py23_bytes(self.data)
+                else py23_bytes(Bool(0))
+            )
+
+    def __str__(self):
+        """Returns data as string."""
+        return str(self.data)
+
+    def isempty(self):
+        if not self.data:
+            return True
+        return not bool(py23_bytes(self.data))
+
+
+class Static_variant(object):
+    def __init__(self, d, type_id, legacy_style=True):
+        self.data = d
+        self.type_id = type_id
+
+        # `legacy_style = True` it means, that static variant is treated like an array, otherwise like an object
+        self.legacy_style = legacy_style
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        return varint(self.type_id) + py23_bytes(self.data)
+
+    def __str__(self):
+        """Returns data as string."""
+        if self.legacy_style:
+            return json.dumps([self.type_id, self.data.json()])
+        else:
+            return json.dumps({"type": self.type_id, "value": self.data.json()})
+
+
+class Map(object):
+    def __init__(self, data):
+        self.data = data
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        b = b""
+        b += varint(len(self.data))
+        for e in self.data:
+            b += py23_bytes(e[0]) + py23_bytes(e[1])
+        return b
+
+    def __str__(self):
+        """Returns data as string."""
+        r = []
+        for e in self.data:
+            r.append([str(e[0]), str(e[1])])
+        return json.dumps(r)
+
+
+class Id(object):
+    def __init__(self, d):
+        self.data = Varint32(d)
+
+    def __bytes__(self):
+        """Returns bytes representation."""
+        return py23_bytes(self.data)
+
+    def __str__(self):
+        """Returns data as string."""
+        return str(self.data)
+
+
+class Enum8(Uint8):
+    # List needs to be provided by super class
+    options = []
+
+    def __init__(self, selection):
+        if selection not in self.options or (
+            isinstance(selection, int) and len(self.options) < selection
+        ):
+            raise ValueError("Options are {}. Given '{}'".format(str(self.options), selection))
+
+        super(Enum8, self).__init__(self.options.index(selection))
+
+    def __str__(self):
+        """Returns data as string."""
+        return str(self.options[self.data])