def sign_stream_claim(self, claim, claim_address, cert_claim_id):
validate_claim_id(cert_claim_id)
decoded_addr = decode_address(claim_address)
to_sign = "%s%s%s" % (decoded_addr, claim.serialized_no_signature,
cert_claim_id.decode('hex'))
digest = self.HASHFUNC(to_sign).digest()
if not isinstance(self.private_key, ecdsa.SigningKey):
raise Exception("Not given a signing key")
sig_dict = {
"version":
V_0_0_1,
"signatureType":
self.CURVE_NAME,
"signature":
self.private_key.sign_digest_deterministic(digest,
hashfunc=self.HASHFUNC),
"certificateId":
cert_claim_id.decode('hex')
}
msg = {
"version": V_0_0_1,
"stream": decode_b64_fields(claim.protobuf_dict)['stream'],
"publisherSignature": sig_dict
}
return Claim.load(msg)
def decode_fields(claim_dictionary):
"""Decode hex and b58 encoded bytes in dictionaries given to ClaimDict"""
claim_dictionary = deepcopy(claim_dictionary)
claim_type = CLAIM_TYPES[claim_dictionary[CLAIM_TYPE]]
claim_value = claim_dictionary[claim_type]
if claim_type == CLAIM_TYPES[STREAM_TYPE]:
claim_value['source']['source'] = binascii.unhexlify(
claim_value['source']['source'])
if 'fee' in claim_value['metadata']:
try:
address = decode_address(
claim_value['metadata']['fee']['address'])
except InvalidAddress as err:
raise DecodeError("Invalid fee address: %s" % err)
claim_value['metadata']['fee']['address'] = address
elif claim_type == CLAIM_TYPES[CERTIFICATE_TYPE]:
public_key = binascii.unhexlify(claim_value["publicKey"])
claim_value["publicKey"] = public_key
if SIGNATURE in claim_dictionary:
decoded_sig = binascii.unhexlify(
claim_dictionary[SIGNATURE]['signature'])
decoded_cert_id = binascii.unhexlify(
claim_dictionary[SIGNATURE]['certificateId'])
claim_dictionary[SIGNATURE]['signature'] = decoded_sig
claim_dictionary[SIGNATURE]['certificateId'] = decoded_cert_id
claim_dictionary[claim_type] = claim_value
return claim_dictionary
def protobuf(self):
pb = {
"version": self.version,
"currency": CURRENCY_MAP[self.currency],
"address": decode_address(self.address),
"amount": self.amount
}
return FeeHelper.load(pb)
def migrate(fee):
if len(fee.keys(
)) == 3 and 'currency' in fee and 'amount' in fee and 'address' in fee:
return FeeHelper.load({
"version": "_0_0_1",
"currency": fee['currency'],
"amount": fee['amount'],
"address": decode_address(fee['address'])
})
if len(fee.keys()) > 1:
raise Exception("Invalid fee")
currency = fee.keys()[0]
amount = fee[currency]['amount']
address = fee[currency]['address']
return FeeHelper.load({
"version": "_0_0_1",
"currency": currency,
"amount": amount,
"address": decode_address(address)
})
def validate_claim_signature(self, claim, claim_address):
decoded_address = decode_address(claim_address)
# extract and serialize the stream from the claim, then check the signature
signature = claim.signature.decode('hex')
if signature is None:
raise Exception("No signature to validate")
to_sign = "%s%s%s" % (decoded_address,
claim.serialized_no_signature,
self.certificate_claim_id.decode('hex'))
return self.validate_signature(self.HASHFUNC(to_sign).digest(), signature)
def validate_claim_signature(self, claim, claim_address):
decoded_address = decode_address(claim_address)
# extract and serialize the stream from the claim, then check the signature
signature = binascii.unhexlify(claim.signature)
if signature is None:
raise Exception("No signature to validate")
to_sign = bytearray()
to_sign.extend(decoded_address)
to_sign.extend(claim.serialized_no_signature)
to_sign.extend(binascii.unhexlify(self.certificate_claim_id))
return self.validate_signature(
self.HASHFUNC(to_sign).digest(), signature)
def test_regtest_address_decode_error(self):
with self.assertRaises(InvalidAddress):
decode_address("bW5PZEvEBNPQRVhwpYXSjabFgbSw1oaHyR")
with self.assertRaises(InvalidAddress):
decode_address("mzGSynizDwSgURdnFjosZwakSVuZrdE8V5")
def test_regtest_address_encode_decode(self):
valid_addr_hex = "6fcdac187757dbf05500f613ada6fdd953d59b9acbf3c9343f"
self.assertEqual(encode_address(valid_addr_hex.decode('hex')),
"mzGSynizDwSgURdnFjosZwakSVuZrdE8V4")
self.assertEqual(decode_address("mzGSynizDwSgURdnFjosZwakSVuZrdE8V4"),
valid_addr_hex.decode('hex'))
def test_mainnet_address_encode_decode(self):
valid_addr_hex = "55be482f953ed0feda4fc5c4d012681b6119274993dc96bf10"
self.assertEqual(encode_address(valid_addr_hex.decode('hex')),
"bW5PZEvEBNPQRVhwpYXSjabFgbSw1oaHyR")
self.assertEqual(decode_address("bW5PZEvEBNPQRVhwpYXSjabFgbSw1oaHyR"),
valid_addr_hex.decode('hex'))
