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)
