def ExtendedKey(self, private=True, encoded=True, bip=44, cointype="bitcoin"): "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 = query_ver(private=private, bip=bip, cointype=cointype, testnet=self.testnet)[0] depth = bytes(bytearray([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 = b'\x00' + self.PrivateKey() raw = version + depth + fpr + child + chain + data if not encoded: return raw else: return Base58.check_encode(raw)
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 WalletImportFormat(self): "Returns private key encoded for wallet import" if self.public: raise Exception( "Publicly derived deterministic keys have no private half") addressversion = b'\x4c' if not self.testnet else b'\xef' raw = addressversion + self.k.to_string( ) + b'\x01' # Always compressed return Base58.check_encode(raw)
def fromExtendedKey(xkey, public=False): """ Create a BIP32Key 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.check_decode(xkey) if len(raw) != 78: raise ValueError("extended key format wrong length") # Verify address version/type version = raw[:4] if version == EX_MAIN_PRIVATE: keytype = 'xprv' elif version == EX_MAIN_PUBLIC: keytype = 'xpub' else: 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 = BIP32Key(secret=secret, chain=chain, depth=depth, index=child, fpr=fpr, public=is_pubkey) if not is_pubkey and public: key = key.SetPublic() return key
def P2WPKHoP2SHAddress(self): "Return P2WPKH over P2SH segwit address" pk_bytes = self.PublicKey() assert len(pk_bytes) == 33 and (pk_bytes.startswith(b"\x02") or pk_bytes.startswith(b"\x03")), \ "Only compressed public keys are compatible with p2sh-p2wpkh addresses. " \ "See https://github.com/bitcoin/bips/blob/master/bip-0049.mediawiki." pk_hash = hashlib.new('ripemd160', sha256(pk_bytes).digest()).digest() push_20 = bytes.fromhex('0014') script_sig = push_20 + pk_hash address_bytes = hashlib.new('ripemd160', sha256(script_sig).digest()).digest() prefix = b"\xc4" if self.testnet else b"\x05" return Base58.check_encode(prefix + address_bytes)
def fromExtendedKey(xkey, public=False): """ Create a BIP32Key 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.check_decode(xkey) if len(raw) != 78: raise ValueError("extended key format wrong length") # Verify address version/type version = raw[:4] if version == EX_MAIN_PRIVATE: keytype = 'xprv' elif version == EX_MAIN_PUBLIC: keytype = 'xpub' else: 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 = BIP32Key(secret=secret, chain=chain, depth=depth, index=child, fpr=fpr, public=is_pubkey) if not is_pubkey and public: key = key.SetPublic() return key
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)
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)
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 = '\xBF' + self.k.to_string() + '\x01' # Always compressed return Base58.check_encode(raw)
def Address(self): "Return compressed public key address" vh160 = chr(25) + self.Identifier() leadingzbytes = len(re_match('^\x00*', vh160).group(0)) return 'B' * leadingzbytes + Base58.check_encode(vh160)
def Address(self): "Return compressed public key address" vh160 = '\x00'+self.Identifier() return Base58.check_encode(vh160)
def Address(self): "Return compressed public key address" addressversion = b'\x42' if not self.testnet else b'\x6f' vh160 = addressversion + self.Identifier() return Base58.check_encode(vh160)
def fromExtendedKey(xkey, public=False): """ Create a BIP32Key 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.check_decode(xkey) if len(raw) != 78: raise ValueError("extended key format wrong length") # Verify address version/type version = raw[:4] tversion = codecs.encode(version, "hex") if tversion in query_lsit(testnet=False): is_testnet = False is_pubkey = False elif tversion in query_lsit(testnet=True): is_testnet = True is_pubkey = False elif tversion in query_lsit(public=True): is_testnet = False is_pubkey = True elif tversion in query_lsit(public=True, testnet=True): is_testnet = True is_pubkey = True else: raise ValueError("unknown extended key version") # Extract remaining fields # Python 2.x compatibility if type(raw[4]) == int: depth = raw[4] else: 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 not is_pubkey: secret = secret[1:] else: # Recover public curve point from compressed key # Python3 FIX lsb = secret[0] & 1 if type( secret[0]) == int else 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) key = BIP32Key(secret=secret, chain=chain, depth=depth, index=child, fpr=fpr, public=is_pubkey, testnet=is_testnet) if not is_pubkey and public: key = key.SetPublic() return key