Working on helper classes for UCP documents

Need unittests to valid done work

ucoinpy/__init__.py

@@ -15,3 +15,7 @@
 # Authors:
 # Caner Candan <caner@candan.fr>, http://caner.candan.fr
 #
+
+PROTOCOL_VERSION="1"
+
+MANAGED_API=["BASIC_MERKLED_API"]

ucoinpy/documents/__init__.py

+'''
+Created on 3 déc. 2014
+
+@author: inso
+'''
+import base58
+import time
+from ..key import Base58Encoder
+
+
+class Document:
+    def __init__(self, timestamp):
+        self.timestamp = timestamp
+
+    def ts(self):
+        return "META:TS:{0}".format(self.timestamp)
+
+    def content(self):
+        return ""
+
+    def sign(self, key):
+        return key.sign(self.content(), encoder=Base58Encoder)
+
+    def signed(self, key):
+        return "{0}\n{1}\n".format(self.content(), self.sign(key))

ucoinpy/documents/block.py

@@ -4,13 +4,131 @@ Created on 2 déc. 2014
 @author: inso
 '''
 
-class Block(object):
+from .. import PROTOCOL_VERSION
+from . import Document
+
+
+class Block(Document):
     '''
-    classdocs
+Version: VERSION
+Type: Block
+Currency: CURRENCY
+Nonce: NONCE
+Number: BLOCK_NUMBER
+PoWMin: NUMBER_OF_ZEROS
+Time: GENERATED_ON
+MedianTime: MEDIAN_DATE
+UniversalDividend: DIVIDEND_AMOUNT
+Issuer: ISSUER_KEY
+PreviousHash: PREVIOUS_HASH
+PreviousIssuer: PREVIOUS_ISSUER_KEY
+Parameters: PARAMETERS
+MembersCount: WOT_MEM_COUNT
+Identities:
+PUBLIC_KEY:SIGNATURE:TIMESTAMP:USER_ID
+...
+Joiners:
+PUBLIC_KEY:SIGNATURE:NUMBER:HASH:TIMESTAMP:USER_ID
+...
+Actives:
+PUBLIC_KEY:SIGNATURE:NUMBER:HASH:TIMESTAMP:USER_ID
+...
+Leavers:
+PUBLIC_KEY:SIGNATURE:NUMBER:HASH:TIMESTAMP:USER_ID
+...
+Excluded:
+PUBLIC_KEY
+...
+Certifications:
+PUBKEY_FROM:PUBKEY_TO:BLOCK_NUMBER:SIGNATURE
+...
+Transactions:
+COMPACT_TRANSACTION
+...
+BOTTOM_SIGNATURE
     '''
 
-
-    def __init__(self, params):
+    def __init__(self, currency, noonce, number, powmin, time,
+                 mediantime, ud, issuer, prev_hash, prev_issuer,
+                 parameters, members_count, identities, joiners,
+                 actives, leavers, excluded, certifications,
+                 transactions):
         '''
         Constructor
         '''
+        self.currency = currency
+        self.noonce = noonce
+        self.number = number
+        self.powmin = powmin
+        self.time = time
+        self.mediantime = mediantime
+        self.ud = ud
+        self.issuer = issuer
+        self.prev_hash = prev_hash
+        self.prev_issuer = prev_issuer
+        self.parameters = parameters
+        self.members_count = members_count
+        self.identities = identities
+        self.joiners = joiners
+        self.actives = actives
+        self.leavers = leavers
+        self.excluded = excluded
+        self.certifications = certifications
+        self.transactions = transactions
+
+    def content(self):
+        doc = """
+Version: {0}
+Type: Block
+Currency: {1}
+Nonce: {2}
+Number: {3}
+PoWMin: {4}
+Time: {5}
+MedianTime: {6}
+UniversalDividend: {7}
+Issuer: {8}
+PreviousHash: {9}
+PreviousIssuer: {10}
+Parameters: {11}
+MembersCount: {12}
+Identities:""".format(PROTOCOL_VERSION,
+                      self.currency,
+                      self.noonce,
+                      self.number,
+                      self.powmin,
+                      self.time,
+                      self.mediantime,
+                      self.ud,
+                      self.issuer,
+                      self.prev_hash,
+                      self.prev_issuer,
+                      self.parameters,
+                      self.members_count)
+
+        for identity in self.identities:
+            doc += "{0}\n".format(identity.inline())
+
+        doc += "Joiners:\n"
+        for joiner in self.joiners:
+            doc += "{0}\n".format(joiner.inline())
+
+        doc += "Actives:\n"
+        for active in self.actives:
+            doc += "{0}\n".format(active.inline())
+
+        doc += "Leavers:\n"
+        for leaver in self.leavers:
+            doc += "{0]\n".format(leaver.inline())
+
+        doc += "Excluded:\n"
+        for exclude in self.exclude:
+            doc += "{0}\n".format(exclude.inline())
+
+        doc += "Certifications:\n"
+        for cert in self.certifications:
+            doc += "{0}\n".format(cert.inline())
+
+        doc += "Transactions:\n"
+        for transaction in self.transactions:
+            doc += "{0}\n".format(transaction.inline())

ucoinpy/documents/certification.py

@@ -3,14 +3,38 @@ Created on 2 déc. 2014
 
 @author: inso
 '''
+from . import Document
 
-class Certification(object):
+
+class SelfCertification(Document):
     '''
-    classdocs
+    A document discribing a self certification.
     '''
 
+    def __init__(self, identifier):
+        self.identifier = identifier
+
+    def uid(self):
+        return "UID:{0}".format(self.identifier)
 
-    def __init__(self, params):
+    def content(self):
+        return "{0}\n{1}".format(self.uid(), self.timestamp())
+
+
+class Certification(Document):
+    '''
+    classdocs
+    '''
+
+    def __init__(self, selfcert, blockid):
         '''
         Constructor
         '''
+        self.selfcert = selfcert
+        self.blockid = blockid
+
+    def timestamp(self):
+        return "META:TS:{0}".format(self.blockid)
+
+    def content(self):
+        return "{0}\n{1}".format(self.selfcert.content(), self.timestamp())

ucoinpy/documents/membership.py

@@ -3,14 +3,55 @@ Created on 2 déc. 2014
 
 @author: inso
 '''
+from .. import PROTOCOL_VERSION
+
 
 class Membership(object):
     '''
-    classdocs
+    This is a utility class to generate membership documents :
+    Version: VERSION
+    Type: Membership
+    Currency: CURRENCY_NAME
+    Issuer: ISSUER
+    Block: NUMBER-HASH
+    Membership: MEMBERSHIP_TYPE
+    UserID: USER_ID
+    CertTS: CERTIFICATION_TS
     '''
 
-
-    def __init__(self, params):
+    def __init__(self, currency, issuer, block_number, block_hash,
+                 membership_type, userid, cert_ts):
         '''
         Constructor
         '''
+        self.currency = currency
+        self.issuer = issuer
+        self.block_number = block_number
+        self.block_hash = block_hash
+        self.membership_type = membership_type
+        self.userid = userid
+        self.cert_ts = cert_ts
+
+    def content(self):
+        return """
+Version: {0}
+Type: Membership
+Currency: {1}
+Issuer: {2}
+Block: {3}-{4}
+Membership: {5}
+UserID: {6}
+CertTS: {7}""".format(PROTOCOL_VERSION,
+                      self.currency,
+                      self.issuer,
+                      self.block_number, self.block_hash,
+                      self.membership_type,
+                      self.userid,
+                      self.cert_ts)
+
+    def inline(self):
+        return "{0}:{1}:{2}:{3}".format(self.issuer,
+                                        self.sign(),
+                                        self.block_number,
+                                        self.block_hash,
+                                        self.cert_ts)

ucoinpy/documents/peer.py

+'''
+Created on 2 déc. 2014
+
+@author: inso
+'''
+
+import re
+
+from . import Document
+from .. import PROTOCOL_VERSION, MANAGED_API
+
+
+class Peer(Document):
+    """
+    Version: VERSION
+    Type: Peer
+    Currency: CURRENCY_NAME
+    PublicKey: NODE_PUBLICKEY
+    Block: BLOCK
+    Endpoints:
+    END_POINT_1
+    END_POINT_2
+    END_POINT_3
+    [...]
+    """
+
+    def __init__(self, currency, pubkey, blockid, endpoints):
+        self.currency = currency
+        self.pubkey = pubkey
+        self.blockid = blockid
+        self.endpoints = endpoints
+
+    def content(self):
+        doc = """
+Version: {0}
+Type: Peer
+Currency: {1}
+PublicKey: {2}
+Block: {3}
+Endpoints:
+""".format(PROTOCOL_VERSION, self.currency, self.pubkey, self.blockid)
+
+        for endpoint in self.endpoints:
+            doc += "{0}\n".format(endpoint.inline())
+        return doc
+
+
+class Endpoint():
+    """
+    Describing endpoints
+    """
+
+    @staticmethod
+    def from_inline(inline):
+        for api in MANAGED_API:
+            if (inline.startswith(api)):
+                return Endpoint.parse_line(inline, api)
+
+    @staticmethod
+    def parse_line(self, inline, api):
+        if (api == "BASIC_MERKLED_API"):
+            bma_endpoints = re.compile('^BASIC_MERKLED_API( ([a-z_][a-z0-9-_.]+))?( ([0-9.]+))?( ([0-9a-f:]+))?( ([0-9]+))$')
+            m = bma_endpoints.match(inline)
+            server = m.group(2)
+            ipv4 = m.group(4)
+            ipv6 = m.group(6)
+            port = int(m.group(8))
+            return BMAEndpoint(server, ipv4, ipv6, port)
+        return None
+
+
+class BMAEndpoint(Endpoint):
+    def __init__(self, server, ipv4, ipv6, port):
+        self.server = server
+        self.ipv4 = ipv4
+        self.ipv6 = ipv6
+        self.port = port
+
+    def inline(self):
+        return "BASIC_MERKLED_API {DNS} {IPv4} {IPv6} {PORT}" \
+                    .format(DNS=self.server,
+                            IPv4=self.ipv4,
+                            IPv6=self.ipv6,
+                            PORT=self.port)

ucoinpy/documents/pubkey.py

-'''
-Created on 2 déc. 2014
-
-@author: inso
-'''
-
-class Pubkey(object):
-    '''
-    classdocs
-    '''
-
-
-    def __init__(self, params):
-        '''
-        Constructor
-        '''

ucoinpy/documents/status.py

@@ -4,13 +4,39 @@ Created on 2 déc. 2014
 @author: inso
 '''
 
-class Status(object):
+from . import Document
+from .. import PROTOCOL_VERSION
+
+
+class Status(Document):
     '''
-    classdocs
+    Version: VERSION
+    Type: Status
+    Currency: CURRENCY_NAME
+    Status: STATUS
+    Block: BLOCK
+    From: SENDER
+    To: RECIPIENT
     '''
 
-
-    def __init__(self, params):
+    def __init__(self, currency, status, blockid, sender, recipient):
         '''
         Constructor
         '''
+        self.currency = currency
+        self.status = status
+        self.blockid = blockid
+        self.sender = sender
+        self.recipient = recipient
+
+    def content(self):
+        return '''
+Version: {0}
+Type: Status
+Currency: {1}
+Status: {2}
+Block: {3}
+From: {4}
+To: {5}
+'''.format(PROTOCOL_VERSION, self.currency, self.status,
+           self.blockid, self.sender, self.recipient)

ucoinpy/documents/transaction.py

@@ -4,13 +4,148 @@ Created on 2 déc. 2014
 @author: inso
 '''
 
-class Transaction(object):
+from . import Document
+from .. import PROTOCOL_VERSION
+
+
+class Transaction(Document):
+    '''
+Version: VERSION
+Type: Transaction
+Currency: CURRENCY_NAME
+Issuers:
+PUBLIC_KEY
+...
+Inputs:
+INDEX:SOURCE:NUMBER:FINGERPRINT:AMOUNT
+...
+Outputs:
+PUBLIC_KEY:AMOUNT
+...
+Comment: COMMENT
+SIGNATURES
+...
+    '''
+
+    def __init__(self, currency, pubkeys, inputs, outputs, comment=None):
         '''
-    classdocs
+        Constructor
         '''
+        self.currency = currency
+        self.pubkeys = pubkeys
+        self.inputs = inputs
+        self.outputs = outputs
+        self.comment = comment
+
+    def content(self):
+        doc = """
+Version: {0}
+Type: Transaction
+Currency: {1}
+Issuers:""".format(PROTOCOL_VERSION,
+                   self.currency)
+
+        for p in self.pubkeys:
+            doc += "{0}\n".format(p)
 
+        doc += "Inputs:\n"
+        for i in self.inputs:
+            doc += "{0}\n".format(i.inline())
 
-    def __init__(self, params):
+        doc += "Outputs:\n"
+        for o in self.outputs:
+            doc += "{0}\n".format(o.inline())
+
+        doc += """
+COMMENT:
+{0}
+""".format(self.comment)
+
+        return doc
+
+    def compact(self):
+        '''
+        Return a transaction in its compact format.
+        '''
+        """TX:VERSION:NB_ISSUERS:NB_INPUTS:NB_OUTPUTS:HAS_COMMENT
+PUBLIC_KEY:INDEX
+...
+INDEX:SOURCE:FINGERPRINT:AMOUNT
+...
+PUBLIC_KEY:AMOUNT
+...
+COMMENT
+"""
+        doc = "TX:{0}:{1}:{2}:{3}:{4}".format(PROTOCOL_VERSION,
+                                              self.pubkeys.len,
+                                              self.inputs.len,
+                                              self.outputs.len,
+                                              '1' if self.Comment else '0')
+        for pubkey in self.pubkeys:
+            doc += "{0}\n".format(pubkey)
+        for i in self.inputs:
+            doc += "{0}\n".format(i.compact())
+        for o in self.outputs:
+            doc += "{0}\n".format(o.inline())
+        if self.comment:
+            doc += "{0}\n".format(self.comment)
+        return doc
+
+    def sign(self, keys):
+        signatures = ""
+        for k in keys:
+            signatures += "{0}\n".format(super().sign(k))
+        return signatures
+
+
+class SimpleTransaction(Transaction):
+    '''
+As transaction class, but for only one issuer.
+...
+    '''
+    def __init__(self, currency, pubkey, single_input, outputs, comment):
         '''
         Constructor
         '''
+        self.currency = currency
+        self.pubkeys = [pubkey]
+        self.inputs = [single_input]
+        self.outputs = outputs
+        self.comment = comment
+
+
+class InputSource():
+    '''
+    A Transaction INPUT
+    '''
+    def __init__(self, index, source, number, fingerprint, amount):
+        self.index = index
+        self.source = source
+        self.number = number
+        self.fingerprint = fingerprint
+        self.amount = amount
+
+    def inline(self):
+        return "{0}:{1}:{2}:{3}:{4}".format(self.index,
+                                            self.source,
+                                            self.number,
+                                            self.fingerprint,
+                                            self.amount)
+
+    def compact(self):
+        return "{0}:{1}:{2}:{3}".format(self.index,
+                                        self.source,
+                                        self.fingerprint,
+                                        self.amount)
+
+
+class OutputSource():
+    '''
+    A Transaction OUTPUT
+    '''
+    def __init__(self, pubkey, amount):
+        self.pubkey = pubkey
+        self.amount = amount
+
+    def inline(self):
+        return "{0}:{1}".format(self.pubkey, self.amount)

ucoinpy/key/__init__.py

+'''
+Ucoin public and private keys
+
+@author: inso
+'''
+
+import base58
+
+
+class Base58Encoder(object):
+    @staticmethod
+    def encode(data):
+        return base58.b58encode(data)
+
+    @staticmethod
+    def decode(data):
+        return base58.b58decode(data)

ucoinpy/key/hdwallet.py

+'''
+HD Wallet inspired from Bip32 wallets.
+
+@author: inso
+'''
+'''
+import os
+import hmac
+import hashlib
+import ed25519
+import struct
+import base58
+import base64
+
+from hashlib import sha256
+from ecdsa.curves import SECP256k1
+from ecdsa.ecdsa import int_to_string, string_to_int
+from ecdsa.numbertheory import square_root_mod_prime as sqrt_mod
+
+MIN_ENTROPY_LEN = 128        # bits
+HDWALLET_HARDENED    = 0x80000000 # choose from hardened set of child keys
+CURVE_GEN       = ecdsa.ecdsa.generator_secp256k1
+CURVE_ORDER     = CURVE_GEN.order()
+FIELD_ORDER     = SECP256k1.curve.p()
+INFINITY        = ecdsa.ellipticcurve.INFINITY
+
+
+class HDWalletKey(object):
+
+    # Static initializers to create from entropy or external formats
+    #
+    @staticmethod
+    def fromEntropy(entropy, public=False):
+        "Create a HDWallet using supplied entropy >= MIN_ENTROPY_LEN"
+        if entropy == None:
+            entropy = os.urandom(MIN_ENTROPY_LEN/8) # Python doesn't have os.random()
+        if not len(entropy) >= MIN_ENTROPY_LEN/8:
+            raise ValueError("Initial entropy %i must be at least %i bits" %
+                                (len(entropy), MIN_ENTROPY_LEN))
+        I = hmac.new("UCoin seed", entropy, hashlib.sha512).digest()
+
+        Il, Ir = I[:32], I[32:]
+        # FIXME test Il for 0 or less than SECP256k1 prime field order
+        key = HDWalletKey(secret=Il, chain=Ir, depth=0, index=0, fpr='\0\0\0\0', public=False)
+        if public:
+            key.SetPublic()
+        return key
+
+    @staticmethod
+    def fromExtendedKey(xkey, public=False):
+        """
+        Create a HDWallet by importing from extended private or public key string
+
+        If public is True, return a public-only key regardless of input type.
+        """
+        # Sanity checks
+        raw = base58.b58decode_check(xkey)
+        # To fix
+        #if len(raw) != 78:
+        #    raise ValueError("extended key format wrong length")
+
+        # Verify address version/type
+        #version = raw[:4]
+        #if version == EX_MAIN_PRIVATE:
+        #    raise ValueError("unknown extended key version")
+
+        # Extract remaining fields
+        depth = ord(raw[4])
+        fpr = raw[5:9]
+        child = struct.unpack(">L", raw[9:13])[0]
+        chain = raw[13:45]
+        secret = raw[45:78]
+
+        # Extract private key or public key point
+        if keytype == 'xprv':
+            secret = secret[1:]
+        else:
+            # Recover public curve point from compressed key
+            lsb = ord(secret[0]) & 1
+            x = string_to_int(secret[1:])
+            ys = (x**3+7) % FIELD_ORDER # y^2 = x^3 + 7 mod p
+            y = sqrt_mod(ys, FIELD_ORDER)
+            if y & 1 != lsb:
+                y = FIELD_ORDER-y
+            point = ecdsa.ellipticcurve.Point(SECP256k1.curve, x, y)
+            secret = ecdsa.VerifyingKey.from_public_point(point, curve=SECP256k1)
+
+        is_pubkey = (keytype == 'xpub')
+        key = HDWalletKey(secret=secret, chain=chain, depth=depth, index=child,
+                          fpr=fpr, public=is_pubkey)
+        if not is_pubkey and public:
+            key = key.SetPublic()
+        return key
+
+
+    # Normal class initializer
+    def __init__(self, secret, chain, depth, index, fpr, public=False):
+        """
+        Create a public or private BIP32Key using key material and chain code.
+
+        secret   This is the source material to generate the keypair, either a
+                 32-byte string representation of a private key, or the ECDSA
+                 library object representing a public key.
+
+        chain    This is a 32-byte string representation of the chain code
+
+        depth    Child depth; parent increments its own by one when assigning this
+
+        index    Child index
+
+        fpr      Parent fingerprint
+
+        public   If true, this keypair will only contain a public key and can only create
+                 a public key chain.
+        """
+
+        self.public = public
+        if public is False:
+            self.k = ed25519.SigningKey(base58.b58decode(secret))
+            self.K = self.k.get_verifying_key()
+        else:
+            self.k = None
+            self.K = secret
+
+        self.C = chain
+        self.depth = depth
+        self.index = index
+        self.parent_fpr = fpr
+
+    # Internal methods not intended to be called externally
+    def _hmac(self, data):
+        """
+        Calculate the HMAC-SHA512 of input data using the chain code as key.
+
+        Returns a tuple of the left and right halves of the HMAC
+        """
+        I = hmac.new(self.C, data, hashlib.sha512).digest()
+        return (I[:32], I[32:])
+
+    def _CKDpriv(self, i):
+        """
+        Create a child key of index 'i'.
+
+        If the most significant bit of 'i' is set, then select from the
+        hardened key set, otherwise, select a regular child key.
+
+        Returns a BIP32Key constructed with the child key parameters,
+        or None if i index would result in an invalid key.
+        """
+        # Index as bytes, BE
+        i_str = struct.pack(">L", i)
+
+        # Data to HMAC
+        if i & HDWALLET_HARDENED:
+            data = b'\0' + self.k.to_string() + i_str
+        else:
+            data = self.PublicKey() + i_str
+        # Get HMAC of data
+        (Il, Ir) = self._hmac(data)
+
+        # Construct new key material from Il and current private key
+        Il_int = string_to_int(Il)
+        if Il_int > CURVE_ORDER:
+            return None
+        pvt_int = string_to_int(self.k.to_string())
+        k_int = (Il_int + pvt_int) % CURVE_ORDER
+        if (k_int == 0):
+            return None
+        secret = (b'\0'*32 + int_to_string(k_int))[-32:]
+
+        # Construct and return a new BIP32Key
+        return HDWalletKey(secret=secret, chain=Ir, depth=self.depth+1,
+                           index=i, fpr=self.Fingerprint(), public=False)
+
+    def _CKDpub(self, i):
+        """
+        Create a publicly derived child key of index 'i'.
+
+        If the most significant bit of 'i' is set, this is
+        an error.
+
+        Returns a HDWalletKey constructed with the child key parameters,
+        or None if index would result in invalid key.
+        """
+
+        if i & HDWALLET_HARDENED:
+            raise Exception("Cannot create a hardened child key using public child derivation")
+
+        # Data to HMAC.  Same as CKDpriv() for public child key.
+        data = self.PublicKey() + struct.pack(">L", i)
+
+        # Get HMAC of data
+        (Il, Ir) = self.hmac(data)
+
+        # Construct curve point Il*G+K
+        Il_int = string_to_int(Il)
+        if Il_int >= CURVE_ORDER:
+            return None
+        point = Il_int*CURVE_GEN + self.K.pubkey.point
+        if point == INFINITY:
+            return None
+
+        # Retrieve public key based on curve point
+        K_i = ed25519.VerifyingKey.from_public_point(point, curve=SECP256k1)
+
+        # Construct and return a new BIP32Key
+        return HDWalletKey(secret=K_i, chain=Ir, depth=self.depth, index=i, fpr=self.Fingerprint(), public=True)
+
+
+    # Public methods
+    #
+    def ChildKey(self, i):
+        """
+        Create and return a child key of this one at index 'i'.
+
+        The index 'i' should be summed with BIP32_HARDEN to indicate
+        to use the private derivation algorithm.
+        """
+        if self.public is False:
+            return self.CKDpriv(i)
+        else:
+            return self.CKDpub(i)
+
+
+    def SetPublic(self):
+        "Convert a private BIP32Key into a public one"
+        self.k = None
+        self.public = True
+
+
+    def PrivateKey(self):
+        "Return private key as string"
+        if self.public:
+            raise Exception("Publicly derived deterministic keys have no private half")
+        else:
+            return self.k.to_string()
+
+
+    def PublicKey(self):
+        "Return compressed public key encoding"
+        if self.K.pubkey.point.y() & 1:
+            ck = b'\3'+int_to_string(self.K.pubkey.point.x())
+        else:
+            ck = b'\2'+int_to_string(self.K.pubkey.point.x())
+        return ck
+
+
+    def ChainCode(self):
+        "Return chain code as string"
+        return self.C
+
+
+    def Identifier(self):
+        "Return key identifier as string"
+        cK = self.PublicKey()
+        return hashlib.new('ripemd160', sha256(cK).digest()).digest()
+
+
+    def Fingerprint(self):
+        "Return key fingerprint as string"
+        return self.Identifier()[:4]
+
+
+    def Address(self):
+        "Return compressed public key address"
+        vh160 = '\x00'+self.Identifier()
+        return Base58.check_encode(vh160)
+
+
+    def WalletImportFormat(self):
+        "Returns private key encoded for wallet import"
+        if self.public:
+            raise Exception("Publicly derived deterministic keys have no private half")
+        raw = '\x80' + self.k.to_string() + '\x01' # Always compressed
+        return Base58.check_encode(raw)
+
+
+    def ExtendedKey(self, private=True, encoded=True):
+        "Return extended private or public key as string, optionally Base58 encoded"
+        if self.public is True and private is True:
+            raise Exception("Cannot export an extended private key from a public-only deterministic key")
+        version = EX_MAIN_PRIVATE if private else EX_MAIN_PUBLIC
+        depth = chr(self.depth)
+        fpr = self.parent_fpr
+        child = struct.pack('>L', self.index)
+        chain = self.C
+        if self.public is True or private is False:
+            data = self.PublicKey()
+        else:
+            data = '\x00' + self.PrivateKey()
+        raw = version+depth+fpr+child+chain+data
+        if not encoded:
+            return raw
+        else:
+            return Base58.check_encode(raw)
+
+    # Debugging methods
+    #
+    def dump(self):
+        "Dump key fields mimicking the BIP0032 test vector format"
+        print "   * Identifier"
+        print "     * (hex):      ", self.Identifier().encode('hex')
+        print "     * (fpr):      ", self.Fingerprint().encode('hex')
+        print "     * (main addr):", self.Address()
+        if self.public is False:
+            print "   * Secret key"
+            print "     * (hex):      ", self.PrivateKey().encode('hex')
+            print "     * (wif):      ", self.WalletImportFormat()
+        print "   * Public key"
+        print "     * (hex):      ", self.PublicKey().encode('hex')
+        print "   * Chain code"
+        print "     * (hex):      ", self.C.encode('hex')
+        print "   * Serialized"
+        print "     * (pub hex):  ", self.ExtendedKey(private=False, encoded=False).encode('hex')
+        print "     * (prv hex):  ", self.ExtendedKey(private=True, encoded=False).encode('hex')
+        print "     * (pub b58):  ", self.ExtendedKey(private=False, encoded=True)
+        print "     * (prv b58):  ", self.ExtendedKey(private=True, encoded=True)
+
+
+if __name__ == "__main__":
+    import sys
+
+    # BIP0032 Test vector 1
+    entropy='000102030405060708090A0B0C0D0E0F'.decode('hex')
+    m = BIP32Key.fromEntropy(entropy)
+    print "Test vector 1:"
+    print "Master (hex):", entropy.encode('hex')
+    print "* [Chain m]"
+    m.dump()
+
+    print "* [Chain m/0h]"
+    m = m.ChildKey(0+BIP32_HARDEN)
+    m.dump()
+
+    print "* [Chain m/0h/1]"
+    m = m.ChildKey(1)
+    m.dump()
+
+    print "* [Chain m/0h/1/2h]"
+    m = m.ChildKey(2+BIP32_HARDEN)
+    m.dump()
+
+    print "* [Chain m/0h/1/2h/2]"
+    m = m.ChildKey(2)
+    m.dump()
+
+    print "* [Chain m/0h/1/2h/2/1000000000]"
+    m = m.ChildKey(1000000000)
+    m.dump()
+
+    # BIP0032 Test vector 2
+    entropy = 'fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542'.decode('hex')
+    m = BIP32Key.fromEntropy(entropy)
+    print "Test vector 2:"
+    print "Master (hex):", entropy.encode('hex')
+    print "* [Chain m]"
+    m.dump()
+
+    print "* [Chain m/0]"
+    m = m.ChildKey(0)
+    m.dump()
+
+    print "* [Chain m/0/2147483647h]"
+    m = m.ChildKey(2147483647+BIP32_HARDEN)
+    m.dump()
+
+    print "* [Chain m/0/2147483647h/1]"
+    m = m.ChildKey(1)
+    m.dump()
+
+    print "* [Chain m/0/2147483647h/1/2147483646h]"
+    m = m.ChildKey(2147483646+BIP32_HARDEN)
+    m.dump()
+
+    print "* [Chain m/0/2147483647h/1/2147483646h/2]"
+    m = m.ChildKey(2)
+    m.dump()
+'''
\ No newline at end of file