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'))