Python SigningKey.from_string方法代码示例

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test(self):
        for data in priv_pub_hash_addr_p2pkh_segwit:
            priv = PrivateKey.from_wif(data['privkey'])
            pub = PublicKey.unhexlify(data['pubkey'])
            pubhash = bytearray(unhexlify(data['pubkeyhash']))
            address = Address.from_string(data['address'], strict=False)
            p2pkhhex = data['scriptpubkey']
            segwit_addr = data['segwit']

            self.assertEqual(priv.pub(), pub)
            self.assertEqual(pub.hash(), pubhash)
            self.assertEqual(address.hash, pubhash)
            self.assertEqual(P2pkhScript(pub).hexlify(), p2pkhhex)
            self.assertEqual(P2pkhScript(address).hexlify(), p2pkhhex)
            self.assertEqual(P2pkhScript(pubhash).hexlify(), p2pkhhex)
            self.assertEqual(str(P2shScript(P2wpkhV0Script(pub)).address()), segwit_addr)
            self.assertEqual(str(P2shScript(P2wpkhV0Script(pubhash)).address()), segwit_addr)
            self.assertEqual(P2shScript(P2wpkhV0Script(pub)).scripthash, Address.from_string(segwit_addr).hash)
            self.assertEqual(P2shScript(P2wpkhV0Script(pubhash)).scripthash, Address.from_string(segwit_addr).hash) 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def ec_get_public_key_by_private_key(private_key: bytes, curve_name) -> bytes:
        if curve_name == Curve.P256:
            private_key = SigningKey.from_string(string=private_key, curve=curves.NIST256p)
            verifying_key = private_key.get_verifying_key()
            order = verifying_key.pubkey.order
            x_int = verifying_key.pubkey.point.x()
            y_int = verifying_key.pubkey.point.y()
            x_str = util.number_to_string(x_int, order)
            if y_int % 2 == 0:
                point_str = util.b('\x02') + x_str
            else:
                point_str = util.b('\x03') + x_str
        elif curve_name == Curve.P224:
            raise SDKException(ErrorCode.unsupported_key_type)
        elif curve_name == Curve.P384:
            raise SDKException(ErrorCode.unsupported_key_type)
        elif curve_name == Curve.P521:
            raise SDKException(ErrorCode.unsupported_key_type)
        else:
            raise SDKException(ErrorCode.unsupported_key_type)
        return point_str 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def from_parent(parent_key, i):
        if i & HARDENED_INDEX:
            raise ValueError("Can't generate a hardened child key from a parent public key.")

        child = hmac.new(parent_key.chain_code,
                         parent_key.compressed_key + i.to_bytes(length=4, byteorder='big'),
                         hashlib.sha512).digest()
        child_left, child_right = child[:32], child[32:]
        if int.from_bytes(child_left, 'big') >= ecdsa.generator_256.order():
            return None

        temp_pri_key = SigningKey.from_string(string=child_left, curve=curves.NIST256p)

        ki = temp_pri_key.verifying_key.pubkey.point + parent_key.key.pubkey.point
        if ki == ellipticcurve.INFINITY:
            return None

        return HDPublicKey(public_key=VerifyingKey.from_public_point(point=ki, curve=curves.NIST256p),
                           chain_code=child_right,
                           index=i,
                           depth=parent_key.depth + 1,
                           parent_fingerprint=parent_key.fingerprint) 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def validate_tx_in(tx_in, transaction, a_unspent_tx_outs):

    referenced_utxo = [utxo for utxo in a_unspent_tx_outs if utxo.tx_out_id == tx_in.tx_out_id and utxo.tx_out_index == tx_in.tx_out_index][0]
    if referenced_utxo == []:
        print('referenced txOut not found: ' + json.dumps(tx_in))
        return False

    address = referenced_utxo.address

    vk = VerifyingKey.from_string(bytes.fromhex(address), curve=SECP256k1)

    try:
        vk.verify(bytes.fromhex(tx_in.signature), transaction.id.encode())

    except Exception as e:
        # change the exception
        print('invalid tx_in signature: %s txId: %s address: %s' % (tx_in.signature, transaction.id, referenced_utxo.address))
        return False

    return True 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def sign_tx_in(transaction, tx_in_index,
               private_key, a_unspent_tx_outs):

    tx_in = transaction.tx_ins[tx_in_index]
    data_to_sign = str(transaction.id)
    referenced_utxo = find_unspent_tx_out(tx_in.tx_out_id, tx_in.tx_out_index, a_unspent_tx_outs)
    if referenced_utxo is None:
        print('could not find referenced txOut')
        # throw Error()
        return False

    referenced_address = referenced_utxo.address

    if get_public_key(private_key) != referenced_address:
        print('trying to sign an input with private' +
              ' key that does not match the address that is referenced in tx_in')
        # throw Error()
        return False

    # key = ec.keyFromPrivate(private_key, 'hex')
    sk = SigningKey.from_string(private_key, curve=SECP256k1)
    signature = binascii.b2a_hex(sk.sign(data_to_sign.encode())).decode()
    return signature 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def pub(self, compressed=None):
        if compressed is None:
            compressed = self.public_compressed
        raw_pubkey = bytearray(SigningKey.from_string(self.key, curve=SECP256k1).get_verifying_key().to_string())
        uncompressed = PublicKey(bytearray([0x04]) + raw_pubkey)
        if compressed:
            return PublicKey(uncompressed.compressed)
        else:
            return uncompressed 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def raw_sign(self, data, deterministic=True):
        sig_key = SigningKey.from_string(self.key, curve=SECP256k1)
        sig_func = partial(sig_key.sign_digest_deterministic, hashfunc=sha256) if deterministic else sig_key.sign_digest
        r, s, order = sig_func(data, sigencode=lambda *x: x)
        if s < 0x01:
            raise ValueError('Too low s value for signature: {}'.format(s))
        # ref: https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#Low_S_values_in_signatures
        if s > PrivateKey.highest_s:
            s = order - s
        if s.to_bytes(32, 'big')[0] > 0x7f:
            s = int.from_bytes(b'\x00' + s.to_bytes(32, 'big'), 'big')
        if r.to_bytes(32, 'big')[0] > 0x7f:
            r = int.from_bytes(b'\x00' + r.to_bytes(32, 'big'), 'big')
        return r, s, order 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_valid(self):
        for data in segwit_valid_addresses:
            address = SegWitAddress.from_string(data['address'], strict=False)
            script = ScriptBuilder.identify(data['script'])
            self.assertEqual(address.hash, script.address().hash)
            if len(data['script']) == 44:
                self.assertEqual(P2wpkhV0Script(address), script)
            elif len(data['script']) == 68:
                self.assertEqual(P2wshV0Script(address), script) 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_priv_to_pubhash(self):
        for priv, addr, _ in privk['derivations']:
            self.assertEqual(str(PrivateKey.from_wif(priv).pub().to_address(mainnet=False)),
                             addr)
            self.assertEqual(PrivateKey.from_wif(priv).pub().hash(),
                             Address.from_string(addr, strict=False).hash) 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.pubk = PublicKey.unhexlify('0384478d41e71dc6c3f9edde0f928a47d1b724c05984ebfb4e7d0422e80abe95ff')
        self.pubkh = self.pubk.hash()
        self.address = Address.from_string('mquvJWnJJwTDUcdneQkUbrfN2wm9uiXd1p') 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_success_addresses(self):

        for script_hex, address in p2sh.items():
            script = ScriptBuilder.identify(bytearray(unhexlify(script_hex)))
            from_addr = P2shScript(Address.from_string(address))
            from_script = P2shScript(script)
            self.assertTrue(str(from_addr.address()) == address)
            self.assertTrue(str(P2shAddress.from_script(script)) == address)
            self.assertTrue(str(from_script.address()) == address)

        script = P2shScript(self.address)
        self.assertTrue(script.decompile() ==
                        'OP_HASH160 {} OP_EQUAL'.format(self.as_data))
        self.assertTrue(script.hexlify() == 'a9{:02x}{}87'.format(len(self.as_data), self.as_data)) 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_success(self):
        for net, addr_type, address, hashed_data in self.good_addresses:
            from_string = Address.from_string(address, strict=False)
            self.assertTrue(address == str(from_string))
            self.assertTrue(from_string.__class__ == addr_type)
            self.assertTrue(from_string.network == net)
            self.assertTrue(from_string.hash == hashed_data) 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_conversions(self):
        for address, pkh in addresses:
            self.assertEqual(hexlify(Address.from_string(address, strict=False).hash).decode(), pkh)
            self.assertEqual(str(P2pkhScript(bytearray(unhexlify(pkh))).address(mainnet=True)), address)
            self.assertEqual(P2pkhScript(Address.from_string(address, strict=False)).pubkeyhash,
                             bytearray(unhexlify(pkh)))
            self.assertEqual(P2pkhAddress(bytearray(unhexlify(pkh)), mainnet=True).hash, bytearray(unhexlify(pkh))) 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_to_script(self):
        data = {}
        for addr, pkh in addresses:
            data[addr] = P2pkhScript(bytearray(unhexlify(pkh)))
        for script, addr in p2sh.items():
            data[addr] = P2shScript(ScriptBuilder.identify(script))
        for dic in segwit_valid_addresses:
            data[dic['address']] = ScriptBuilder.identify(dic['script'])

        for addr, script in data.items():
            self.assertTrue(Address.from_string(addr, strict=False).to_script().hexlify(),
                            script.hexlify()) 

# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def from_bytes(cls, data: bytes):
        """ Generates either a HDPublicKey from the underlying bytes.

        The serialization must conform to the description in:
        https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#serialization-format
        """
        if len(data) < 78:
            raise ValueError("b must be at least 78 bytes long.")

        version = int.from_bytes(data[:4], 'big')
        depth = data[4]
        parent_fingerprint = data[5:9]
        index = int.from_bytes(data[9:13], 'big')
        chain_code = data[13:45]
        key_bytes = data[45:78]

        if version != HDPublicKey.__VERSION:
            raise ValueError('invalid HD Public Key.')

        if key_bytes[0] != 0x02 and key_bytes[0] != 0x03:
            raise ValueError("First byte of public key must be 0x02 or 0x03!")

        # The curve of points satisfying y^2 = x^3 + a*x + b (mod p).
        curve = ecdsa.curve_256
        x = util.string_to_number(key_bytes[1:])
        y = (x * x * x + curve.a() * x + curve.b()) % curve.p()
        y = numbertheory.square_root_mod_prime(y, curve.p())
        if (key_bytes[0] == 0x03 and y % 2 == 0) or (key_bytes[0] == 0x02 and y % 2 != 0):
            y = (y * -1) % curve.p()
        order = curves.NIST256p.order
        s_key = util.number_to_string(x, order) + util.number_to_string(y, order)

        public_key = VerifyingKey.from_string(string=s_key, curve=curves.NIST256p)
        rv = cls(
            public_key=public_key,
            chain_code=chain_code,
            index=index,
            depth=depth,
            parent_fingerprint=parent_fingerprint)
        return rv