def test_getcertificatesforsigning(self): cmds = MocCommands() claim = ClaimDict.generate_certificate(SECP256K1_PRIVATE_KEY, curve=SECP256k1) cmds.wallet.add_address_transaction(4003002001000) tx = cmds.wallet.add_claim_transaction('lbry://@test', 1000, claim.serialized) cmds.wallet.save_certificate(tx.get_claim_id(0), SECP256K1_PRIVATE_KEY) cmds.wallet.set_default_certificate(tx.get_claim_id(0)) self.assertEqual(1, len(cmds.getcertificatesforsigning())) self.assertIn('certificate', cmds.getcertificateclaims()[0]['value'])
def _make_claim_tx_key(self, cmds): claim = ClaimDict.generate_certificate(SECP256K1_PRIVATE_KEY, curve=SECP256k1) cmds.wallet.add_address_transaction(4003002001000) tx = cmds.wallet.add_claim_transaction('lbry://@test', 1000, claim.serialized) cmds.network = MocNetwork({ 'blockchain.claimtrie.getclaimsbyids': lambda _: { tx.get_claim_id(0): cmds.wallet.get_name_claims()[0] } }) key = cmds._serialize_certificate_key(tx.get_claim_id(0), SECP256K1_PRIVATE_KEY) return claim, tx, key
def generate_certificate(): secp256k1_private_key = get_signer( SECP256k1).generate().private_key.to_pem() return ClaimDict.generate_certificate( secp256k1_private_key, curve=SECP256k1), secp256k1_private_key
def _handle_claim_result(self, results): if not results: raise UnknownNameError("No results to return") if 'error' in results: if results['error'] == 'name is not claimed': raise UnknownNameError(results['error']) else: raise Exception(results['error']) if 'claim' in results: claim = results['claim'] if 'has_signature' in claim and claim['has_signature']: if not claim['signature_is_valid']: log.warning("lbry://%s#%s has an invalid signature", claim['name'], claim['claim_id']) decoded = ClaimDict.load_dict(claim['value']) claim_dict = decoded.claim_dict claim['value'] = claim_dict defer.returnValue(claim) try: decoded = smart_decode(claim['value']) claim_dict = decoded.claim_dict outpoint = ClaimOutpoint(claim['txid'], claim['nout']) name = claim['name'] claim['value'] = claim_dict claim['hex'] = decoded.serialized.encode('hex') yield self._save_name_metadata(name, outpoint, decoded.source_hash) yield self._update_claimid(claim['claim_id'], name, outpoint) except DecodeError: claim['hex'] = claim['value'] claim['value'] = None claim['error'] = "Failed to decode value" results = claim elif 'value' in results: if 'has_signature' in results and results['has_signature']: if not results['signature_is_valid']: log.warning("lbry://%s#%s has an invalid signature", results['name'], results['claim_id']) decoded = ClaimDict.load_dict(results['value']) claim_dict = decoded.claim_dict results['value'] = claim_dict defer.returnValue(results) try: decoded = ClaimDict.load_dict(results['value']) claim_dict = decoded.claim_dict claim_hex = decoded.serialized.encode('hex') claim_err = None outpoint = ClaimOutpoint(results['txid'], results['nout']) name = results['name'] yield self._save_name_metadata(name, outpoint, decoded.source_hash) yield self._update_claimid(results['claim_id'], name, outpoint) except DecodeError: claim_dict = None claim_hex = results['value'] claim_err = "Failed to decode value" if claim_err: results['error'] = claim_err results['hex'] = claim_hex results['value'] = claim_dict log.info("get claim info lbry://%s#%s", results['name'], results['claim_id']) defer.returnValue(results)
def test_make_ecdsa_cert(self): cert = ClaimDict.generate_certificate(secp256k1_private_key, curve=SECP256k1) self.assertEquals(cert.is_certificate, True) self.assertDictEqual(cert.claim_dict, secp256k1_cert)
def test_make_ecdsa_cert(self): cert = ClaimDict.generate_certificate(nist384p_private_key, curve=NIST384p) self.assertEquals(cert.is_certificate, True) self.assertDictEqual(cert.claim_dict, nist384p_cert)
def test_stream_is_not_certificate(self): deserialized_claim = ClaimDict.deserialize( example_010_serialized.decode('hex')) self.assertEquals(deserialized_claim.is_certificate, False)
} cert_claim_id = "63f2da17b0d90042c559cc73b6b17f853945c43e" stream_claim_address = "bDtL6qriyimxz71DSYjojTBsm6cpM1bqmj" stream_claim_address_2 = "bUG7VaMzLEqqyZQAyg9srxQzvf1wwnJ48w" claim_010_unsigned = migrate.migrate(unmigrated_003) # NIST256p test data nist256p_private_key = get_signer(NIST256p).generate().private_key.to_pem() claim_010_signed_nist256p = claim_010_unsigned.sign(nist256p_private_key, stream_claim_address, cert_claim_id, curve=NIST256p) nist256p_cert = ClaimDict.generate_certificate(nist256p_private_key, curve=NIST256p) # NIST384p test data nist384p_private_key = get_signer(NIST384p).generate().private_key.to_pem() claim_010_signed_nist384p = claim_010_unsigned.sign(nist384p_private_key, stream_claim_address, cert_claim_id, curve=NIST384p) nist384p_cert = ClaimDict.generate_certificate(nist384p_private_key, curve=NIST384p) # SECP256k1 test data secp256k1_private_key = get_signer(SECP256k1).generate().private_key.to_pem() claim_010_signed_secp256k1 = claim_010_unsigned.sign(secp256k1_private_key, stream_claim_address, cert_claim_id,
def test_stream_is_not_certificate(self): deserialized_claim = ClaimDict.deserialize( binascii.unhexlify(example_010_serialized)) self.assertEqual(deserialized_claim.is_certificate, False)
def claim(self) -> ClaimDict: if self.script.is_claim_name or self.script.is_update_claim: return ClaimDict.deserialize(self.script.values['claim']) raise ValueError( 'Only claim name and claim update have the claim payload.')
def test_fail_to_load_wrong_private_key_for_cert(self): cert_claim = ClaimDict.load_dict(secp256k1_cert) self.assertEqual( cert_claim.validate_private_key(nist256p_private_key, claim_id_1), False)
def test_valid_private_key_for_cert(self): cert_claim = ClaimDict.load_dict(secp256k1_cert) self.assertEqual( cert_claim.validate_private_key(secp256k1_private_key, claim_id_1), True)
def test_invalid_cert_curve(self): with self.assertRaises(Exception): ClaimDict.load_dict(malformed_secp256k1_cert)
async def test_creating_updating_and_abandoning_claim_with_channel(self): await self.account.ensure_address_gap() address1, address2 = await self.account.receiving.get_addresses( limit=2, only_usable=True) sendtxid1 = await self.blockchain.send_to_address(address1, 5) sendtxid2 = await self.blockchain.send_to_address(address2, 5) await self.blockchain.generate(1) await asyncio.wait([ self.on_transaction_id(sendtxid1), self.on_transaction_id(sendtxid2) ]) self.assertEqual(d2l(await self.account.get_balance()), '10.0') cert, key = generate_certificate() cert_tx = await Transaction.claim('@bar', cert, l2d('1.0'), address1, [self.account], self.account) claim = ClaimDict.load_dict(example_claim_dict) claim = claim.sign(key, address1, cert_tx.outputs[0].claim_id) claim_tx = await Transaction.claim('foo', claim, l2d('1.0'), address1, [self.account], self.account) await self.broadcast(cert_tx) await self.broadcast(claim_tx) await asyncio.wait([ # mempool self.on_transaction(claim_tx), self.on_transaction(cert_tx) ]) await self.blockchain.generate(1) await asyncio.wait([ # confirmed self.on_transaction(claim_tx), self.on_transaction(cert_tx) ]) self.assertEqual(d2l(await self.account.get_balance()), '7.985786') self.assertEqual( d2l(await self.account.get_balance(include_claims=True)), '9.985786') response = await self.ledger.resolve(0, 10, 'lbry://@bar/foo') self.assertIn('lbry://@bar/foo', response) self.assertIn('claim', response['lbry://@bar/foo']) abandon_tx = await Transaction.abandon([claim_tx.outputs[0]], [self.account], self.account) await self.broadcast(abandon_tx) await self.on_transaction(abandon_tx) await self.blockchain.generate(1) await self.on_transaction(abandon_tx) response = await self.ledger.resolve(0, 10, 'lbry://@bar/foo') self.assertNotIn('claim', response['lbry://@bar/foo']) # checks for expected format in inexistent URIs response = await self.ledger.resolve(0, 10, 'lbry://404', 'lbry://@404') self.assertEqual('URI lbry://404 cannot be resolved', response['lbry://404']['error']) self.assertEqual('URI lbry://@404 cannot be resolved', response['lbry://@404']['error'])
def create_cert(): private_key = get_signer(SECP256k1).generate().private_key.to_pem() certificate = ClaimDict.generate_certificate(private_key, curve=SECP256k1) return certificate, private_key
def test_deserialize(self): deserialized_claim = ClaimDict.deserialize(example_010_serialized.decode('hex')) self.assertDictEqual(ClaimDict.load_dict(example_010).claim_dict, deserialized_claim.claim_dict)
def test_deserialize(self): deserialized_claim = ClaimDict.deserialize( binascii.unhexlify(example_010_serialized)) self.assertDictEqual( ClaimDict.load_dict(example_010).claim_dict, deserialized_claim.claim_dict)