def get_harvester_signature(self, header_data: HeaderData,
plot_pk: PublicKey):
for value_dict in self.plot_config["plots"].values():
if (PrivateKey.from_bytes(bytes.fromhex(
value_dict["sk"])).get_public_key() == plot_pk):
return PrivateKey.from_bytes(bytes.fromhex(
value_dict["sk"])).sign_prepend(header_data.get_hash())
def test_threshold_instance(T, N):
commitments = []
# fragments[i][j] = fragment held by player i,
# received from player j
fragments = [[None] * N for _ in range(N)]
secrets = []
# Step 1 : Threshold.create
for player in range(N):
secret_key, commi, frags = Threshold.create(T, N)
for target, frag in enumerate(frags):
fragments[target][player] = frag
commitments.append(commi)
secrets.append(secret_key)
# Step 2 : Threshold.verify_secret_fragment
for player_source in range(1, N + 1):
for player_target in range(1, N + 1):
assert Threshold.verify_secret_fragment(
player_target, fragments[player_target - 1][player_source - 1],
commitments[player_source - 1], T)
# Step 3 : master_pubkey = PublicKey.aggregate_insecure(...)
# secret_share = PrivateKey.aggregate_insecure(...)
master_pubkey = PublicKey.aggregate_insecure(
[commitments[i][0] for i in range(N)])
secret_shares = [
PrivateKey.aggregate_insecure(fragment_row)
for fragment_row in fragments
]
master_privkey = PrivateKey.aggregate_insecure(secrets)
msg = ("Test").encode("utf-8")
signature_actual = master_privkey.sign_insecure(msg)
# Step 4 : sig_share = Threshold.sign_with_coefficient(...)
# Check every combination of T players
for X in combinations(range(1, N + 1), T):
# X: a list of T indices like [1, 2, 5]
# Check signatures
signature_shares = [
Threshold.sign_with_coefficient(secret_shares[x - 1], msg, x, X)
for x in X
]
signature_cand = InsecureSignature.aggregate(signature_shares)
assert signature_cand == signature_actual
# Check that the signature actually verifies the message
assert signature_actual.verify([Util.hash256(msg)], [master_pubkey])
# Step 4b : Alternatively, we can add the lagrange coefficients
# to 'unit' signatures.
for X in combinations(range(1, N + 1), T):
# X: a list of T indices like [1, 2, 5]
# Check signatures
signature_shares = [secret_shares[x - 1].sign_insecure(msg) for x in X]
signature_cand = Threshold.aggregate_unit_sigs(signature_shares, X)
assert signature_cand == signature_actual
def test_vectors4():
sk1 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5]))
sk2 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5, 6]))
pk1 = sk1.get_public_key()
pk2 = sk2.get_public_key()
m1 = bytes([7, 8, 9])
m2 = bytes([10, 11, 12])
sig9 = sk1.sign_prepend(m1)
sig10 = sk2.sign_prepend(m2)
assert (sig9.serialize() == bytes.fromhex(
"d2135ad358405d9f2d4e68dc253d64b6049a821797817cffa5aa804086a8fb7b135175bb7183750e3aa19513db1552180f0b0ffd513c322f1c0c30a0a9c179f6e275e0109d4db7fa3e09694190947b17d890f3d58fe0b1866ec4d4f5a59b16ed"
))
assert (sig10.serialize() == bytes.fromhex(
"cc58c982f9ee5817d4fbf22d529cfc6792b0fdcf2d2a8001686755868e10eb32b40e464e7fbfe30175a962f1972026f2087f0495ba6e293ac3cf271762cd6979b9413adc0ba7df153cf1f3faab6b893404c2e6d63351e48cd54e06e449965f08"
))
agg_sig = PrependSignature.aggregate([sig9, sig9, sig10])
message_hashes = [Util.hash256(m1), Util.hash256(m1), Util.hash256(m2)]
pks = [pk1, pk1, pk2]
assert (agg_sig.serialize() == bytes.fromhex(
"c37077684e735e62e3f1fd17772a236b4115d4b581387733d3b97cab08b90918c7e91c23380c93e54be345544026f93505d41e6000392b82ab3c8af1b2e3954b0ef3f62c52fc89f99e646ff546881120396c449856428e672178e5e0e14ec894"
))
assert (agg_sig.verify(message_hashes, pks))
def create_transaction():
values = request.get_json()
print(values)
try:
to = values.get("node")
except:
return jsonify("bad request, parameters not found"), 401
if to is None:
to = "127.0.0.1:5001"
seed = bytes([
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
])
from_sk = PrivateKey.from_seed(seed)
from_pk = from_sk.get_public_key()
amount = random.randint(1, 100)
seed = []
for i in range(0, 32):
seed.append(random.randint(0, 254))
seed = bytes(seed)
to_sk = PrivateKey.from_seed(seed)
to_pk = to_sk.get_public_key()
tx = Transaction(str(from_pk.serialize(), "ISO-8859-1"),
str(to_pk.serialize(), "ISO-8859-1"), amount, from_sk)
print(tx.verify_signature())
url = "http://" + to + "/transactions/new"
response = requests.post(url, json=tx.jsonify_Transaction())
print(response.status_code)
return jsonify("transaction created and sent to destination"), 200
def calculate_synthetic_secret_key(secret_key: PrivateKey, hidden_puzzle_hash: bytes32) -> PrivateKey:
secret_exponent = int.from_bytes(bytes(secret_key), "big")
public_key = secret_key.get_g1()
synthetic_offset = calculate_synthetic_offset(public_key, hidden_puzzle_hash)
synthetic_secret_exponent = (secret_exponent + synthetic_offset) % GROUP_ORDER
blob = synthetic_secret_exponent.to_bytes(32, "big")
synthetic_secret_key = PrivateKey.from_bytes(blob)
return synthetic_secret_key
def private_key_gen(seed=None):
if seed == None:
sk = PrivateKey.from_seed(seed_gen())
else:
sk = PrivateKey.from_seed(seed)
sk_bytes = sk.serialize()
output_file = open(KEY_FILE_PATH, "wb")
output_file.write(sk_bytes)
output_file.close()
return sk_bytes
def sign(
self,
privKey: blspy.PrivateKey,
nonce: int
) -> None:
self.holder = privKey.get_public_key().serialize()
self.nonce = nonce
self.blsSignature = privKey.sign(self.prefix + Verification.serialize(self))
self.signature = self.blsSignature.serialize()
def test_vectors2():
m1 = bytes([1, 2, 3, 40])
m2 = bytes([5, 6, 70, 201])
m3 = bytes([9, 10, 11, 12, 13])
m4 = bytes([15, 63, 244, 92, 0, 1])
sk1 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5]))
sk2 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5, 6]))
sig1 = sk1.sign(m1)
sig2 = sk2.sign(m2)
sig3 = sk2.sign(m1)
sig4 = sk1.sign(m3)
sig5 = sk1.sign(m1)
sig6 = sk1.sign(m4)
sig_L = Signature.aggregate([sig1, sig2])
sig_R = Signature.aggregate([sig3, sig4, sig5])
assert (sig_L.verify())
assert (sig_R.verify())
sig_final = Signature.aggregate([sig_L, sig_R, sig6])
assert (sig_final.serialize() == bytes.fromhex(
"07969958fbf82e65bd13ba0749990764cac81cf10d923af9fdd2723f1e3910c3fdb874a67f9d511bb7e4920f8c01232b12e2fb5e64a7c2d177a475dab5c3729ca1f580301ccdef809c57a8846890265d195b694fa414a2a3aa55c32837fddd80"
))
assert (sig_final.verify())
quotient = sig_final.divide_by([sig2, sig5, sig6])
assert (quotient.verify())
assert (sig_final.verify())
assert (quotient.serialize() == bytes.fromhex(
"8ebc8a73a2291e689ce51769ff87e517be6089fd0627b2ce3cd2f0ee1ce134b39c4da40928954175014e9bbe623d845d0bdba8bfd2a85af9507ddf145579480132b676f027381314d983a63842fcc7bf5c8c088461e3ebb04dcf86b431d6238f"
))
assert (quotient.divide_by([]) == quotient)
try:
quotient.divide_by([sig6])
assert (False) # Should fail due to not subset
except:
pass
sig_final.divide_by([sig1]) # Should not throw
try:
sig_final.divide_by([sig_L]) # Should throw due to not unique
assert (False) # Should fail due to not unique
except:
pass
# Divide by aggregate
sig7 = sk2.sign(m3)
sig8 = sk2.sign(m4)
sig_R2 = Signature.aggregate([sig7, sig8])
sig_final2 = Signature.aggregate([sig_final, sig_R2])
quotient2 = sig_final2.divide_by([sig_R2])
assert (quotient2.verify())
assert (quotient2.serialize() == bytes.fromhex(
"06af6930bd06838f2e4b00b62911fb290245cce503ccf5bfc2901459897731dd08fc4c56dbde75a11677ccfbfa61ab8b14735fddc66a02b7aeebb54ab9a41488f89f641d83d4515c4dd20dfcf28cbbccb1472c327f0780be3a90c005c58a47d3"
))
def t_group_sign_verify():
msg = "NSAWatches"
bmsg = formatting.binary_string([msg])
privates = [utils.private_key_gen() for i in range(5)]
publics = [
PrivateKey.from_bytes(i).get_public_key().serialize() for i in privates
]
sigs = [PrivateKey.from_bytes(i).sign(bmsg) for i in privates]
assert utils.group_sign(sigs), "failing on group_sign()"
group_sig = utils.group_sign(sigs)
assert utils.aggregate_pub_keys(publics), "failing on aggregate_pub_keys()"
agg_key = utils.aggregate_pub_keys(publics)
assert utils.verify_sig(bmsg, agg_key,
group_sig), "aggregate sig verification fails"
def test_bip39_eip2333_test_vector(self):
kc: Keychain = Keychain(testing=True)
kc.delete_all_keys()
mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
passphrase = "TREZOR"
print("entropy to seed:", mnemonic_to_seed(mnemonic, passphrase).hex())
master_sk = kc.add_private_key(mnemonic, passphrase)
tv_master_int = 5399117110774477986698372024995405256382522670366369834617409486544348441851
tv_child_int = 11812940737387919040225825939013910852517748782307378293770044673328955938106
assert master_sk == PrivateKey.from_bytes(
tv_master_int.to_bytes(32, "big"))
child_sk = AugSchemeMPL.derive_child_sk(master_sk, 0)
assert child_sk == PrivateKey.from_bytes(
tv_child_int.to_bytes(32, "big"))
def sign(self, public_key: bytes, message_hash: bytes32) -> G2Element:
secret_exponent = self.get(public_key)
if not secret_exponent:
raise ValueError("unknown pubkey %s" % public_key.hex())
bls_private_key = PrivateKey.from_bytes(
secret_exponent.to_bytes(32, "big"))
return AugSchemeMPL.sign(bls_private_key, message_hash)
def createKey():
seed = []
for i in range(0, 32):
seed.append(SystemRandom().randrange(0, 254))
seed = bytes(seed)
private_key = PrivateKey.from_seed(seed)
return private_key
def test_stream(self):
for _ in range(1, 64):
p = PrivateKey.from_bytes(_.to_bytes(32, "big")).get_g1()
blob = bytes(p)
p1 = G1Element.from_bytes(blob)
self.assertEqual(len(blob), 48)
self.assertEqual(p, p1)
def _add_plot(
self, str_path: str, plot_sk: PrivateKey, pool_pk: Optional[PublicKey]
) -> bool:
plot_config = load_config(self.root_path, "plots.yaml")
if pool_pk is None:
for pool_pk_cand in self.pool_pubkeys:
pr = DiskProver(str_path)
if (
ProofOfSpace.calculate_plot_seed(
pool_pk_cand, plot_sk.get_public_key()
)
== pr.get_id()
):
pool_pk = pool_pk_cand
break
if pool_pk is None:
return False
plot_config["plots"][str_path] = {
"sk": bytes(plot_sk).hex(),
"pool_pk": bytes(pool_pk).hex(),
}
save_config(self.root_path, "plots.yaml", plot_config)
self._refresh_plots()
return True
def aggsig():
seed = bytes([
0, 50, 6, 244, 24, 199, 1, 25, 52, 88, 192, 19, 18, 12, 89, 6, 220, 18,
102, 58, 209, 82, 12, 62, 89, 110, 182, 9, 44, 20, 254, 22
])
num = 3 #number of data packets that needs to be transferred together
sk = [0] * num
pk = [0] * num
sig = [0] * num
msg = [0] * num
m = []
for j in range(num):
m.append(random.randint(1, 999))
for x in range(num):
seed = bytes([x + 1]) + seed[1:]
sk[x] = PrivateKey.from_seed(seed)
pk[x] = sk[x].get_public_key()
msg[x] = bytes(m[x])
dt1 = timeit.default_timer()
for x in range(num):
sig[x] = sk[x].sign(msg[x])
for i in range(0, num - 1, 2):
# Aggregate signatures together
agg_sig_l = Signature.aggregate([sig[i], sig[i + 1]])
# Arbitrary trees of aggregates
agg_sig_final = Signature.aggregate([agg_sig_l, sig[i + 2]])
sig[i + 2] = agg_sig_final
dt2 = timeit.default_timer()
print("Signature Generation:", (dt2 - dt1) * 1000, "ms")
return agg_sig_final, msg
def additional_python_methods():
private_key = PrivateKey.from_seed(b'123')
s1 = private_key.sign(b'message')
s2 = private_key.sign_prepend(b'message')
assert s1.get_insecure_sig().verify([Util.hash256(b'message')],
[private_key.get_public_key()])
assert s2.get_insecure_sig().verify([
Util.hash256(private_key.get_public_key().serialize() +
Util.hash256(b'message'))
], [private_key.get_public_key()])
s1_b = Signature.from_insecure_sig(s1.get_insecure_sig())
s2_b = PrependSignature.from_insecure_sig(s2.get_insecure_sig())
assert s1 == s1_b and s2 == s2_b
s3 = private_key.sign_insecure_prehashed(Util.hash256(b'456'))
assert s3.verify([Util.hash256(b'456')], [private_key.get_public_key()])
esk = ExtendedPrivateKey.from_seed(b'789')
epk = esk.get_public_key()
s3 = private_key.sign(b'message3')
s4 = private_key.sign_insecure(b'message3')
assert bytes(private_key) == private_key.serialize()
assert deepcopy(private_key) == private_key
assert deepcopy(s1) == s1
assert deepcopy(s2) == s2
assert deepcopy(s3) == s3
assert deepcopy(s4) == s4
assert deepcopy(
private_key.get_public_key()) == private_key.get_public_key()
assert deepcopy(esk) == esk
assert deepcopy(epk) == epk
assert deepcopy(esk.get_chain_code()) == esk.get_chain_code()
async def request_header_signature(
self, request: harvester_protocol.RequestHeaderSignature
):
"""
The farmer requests a signature on the header hash, for one of the proofs that we found.
A signature is created on the header hash using the plot private key.
"""
if request.quality_string not in self.challenge_hashes:
return
_, filename, _ = self.challenge_hashes[request.quality_string]
plot_sk = PrivateKey.from_bytes(
bytes.fromhex(self.plot_config["plots"][filename]["sk"])
)
header_hash_signature: PrependSignature = plot_sk.sign_prepend(
request.header_hash
)
assert header_hash_signature.verify(
[Util.hash256(request.header_hash)], [plot_sk.get_public_key()]
)
response: harvester_protocol.RespondHeaderSignature = harvester_protocol.RespondHeaderSignature(
request.quality_string, header_hash_signature,
)
yield OutboundMessage(
NodeType.FARMER,
Message("respond_header_signature", response),
Delivery.RESPOND,
)
async def proof_of_space_finalized(
self,
proof_of_space_finalized: farmer_protocol.ProofOfSpaceFinalized):
"""
Full node notifies farmer that a proof of space has been completed. It gets added to the
challenges list at that weight, and weight is updated if necessary
"""
get_proofs: bool = False
if (proof_of_space_finalized.weight >= self.current_weight
and proof_of_space_finalized.challenge_hash
not in self.seen_challenges):
# Only get proofs for new challenges, at a current or new weight
get_proofs = True
if proof_of_space_finalized.weight > self.current_weight:
self.current_weight = proof_of_space_finalized.weight
# TODO: ask the pool for this information
coinbase: CoinbaseInfo = CoinbaseInfo(
uint32(proof_of_space_finalized.height + 1),
calculate_block_reward(proof_of_space_finalized.height),
bytes.fromhex(self.key_config["pool_target"]),
)
pool_sks: List[PrivateKey] = [
PrivateKey.from_bytes(bytes.fromhex(ce))
for ce in self.key_config["pool_sks"]
]
coinbase_signature: PrependSignature = pool_sks[0].sign_prepend(
bytes(coinbase))
self.coinbase_rewards[uint32(proof_of_space_finalized.height +
1)] = (
coinbase,
coinbase_signature,
)
log.info(f"\tCurrent weight set to {self.current_weight}")
self.seen_challenges.add(proof_of_space_finalized.challenge_hash)
if proof_of_space_finalized.weight not in self.challenges:
self.challenges[proof_of_space_finalized.weight] = [
proof_of_space_finalized
]
else:
self.challenges[proof_of_space_finalized.weight].append(
proof_of_space_finalized)
self.challenge_to_weight[
proof_of_space_finalized.
challenge_hash] = proof_of_space_finalized.weight
self.challenge_to_height[
proof_of_space_finalized.
challenge_hash] = proof_of_space_finalized.height
if get_proofs:
message = harvester_protocol.NewChallenge(
proof_of_space_finalized.challenge_hash)
yield OutboundMessage(
NodeType.HARVESTER,
Message("new_challenge", message),
Delivery.BROADCAST,
)
async def test_delegated_tail(self, setup_sim):
sim, sim_client = setup_sim
try:
standard_acs = Program.to(1)
standard_acs_ph: bytes32 = standard_acs.get_tree_hash()
await sim.farm_block(standard_acs_ph)
starting_coin: Coin = (await sim_client.get_coin_records_by_puzzle_hash(standard_acs_ph))[0].coin
sk = PrivateKey.from_bytes(secret_exponent_for_index(1).to_bytes(32, "big"))
tail: Program = DelegatedLimitations.construct([Program.to(sk.get_g1())])
cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, tail.get_tree_hash(), acs)
cat_ph: bytes32 = cat_puzzle.get_tree_hash()
await sim_client.push_tx(
SpendBundle(
[CoinSpend(starting_coin, standard_acs, Program.to([[51, cat_ph, starting_coin.amount]]))],
G2Element(),
)
)
await sim.farm_block()
# We're signing a different tail to use here
name_as_program = Program.to(starting_coin.name())
new_tail: Program = GenesisById.construct([name_as_program])
checker_solution: Program = DelegatedLimitations.solve(
[name_as_program],
{
"signed_program": {
"identifier": "genesis_by_id",
"args": [str(name_as_program)],
},
"program_arguments": {},
},
)
signature: G2Element = AugSchemeMPL.sign(sk, new_tail.get_tree_hash())
await self.do_spend(
sim,
sim_client,
tail,
[(await sim_client.get_coin_records_by_puzzle_hash(cat_ph, include_spent_coins=False))[0].coin],
[NO_LINEAGE_PROOF],
[
Program.to(
[
[51, acs.get_tree_hash(), starting_coin.amount],
[51, 0, -113, tail, checker_solution],
]
)
],
(MempoolInclusionStatus.SUCCESS, None),
signatures=[signature],
limitations_solutions=[checker_solution],
cost_str="Delegated Genesis",
)
finally:
await sim.close()
def test_vectors():
sk1 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5]))
pk1 = sk1.get_public_key()
sig1 = sk1.sign(bytes([7, 8, 9]))
sk2 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5, 6]))
pk2 = sk2.get_public_key()
sig2 = sk2.sign(bytes([7, 8, 9]))
assert (sk1.serialize() == bytes.fromhex(
"022fb42c08c12de3a6af053880199806532e79515f94e83461612101f9412f9e"))
assert (pk1.get_fingerprint() == 0x26d53247)
assert (pk2.get_fingerprint() == 0x289bb56e)
assert (sig1.serialize() == bytes.fromhex(
"93eb2e1cb5efcfb31f2c08b235e8203a67265bc6a13d9f0ab77727293b74a357ff0459ac210dc851fcb8a60cb7d393a419915cfcf83908ddbeac32039aaa3e8fea82efcb3ba4f740f20c76df5e97109b57370ae32d9b70d256a98942e5806065"
))
assert (sig2.serialize() == bytes.fromhex(
"975b5daa64b915be19b5ac6d47bc1c2fc832d2fb8ca3e95c4805d8216f95cf2bdbb36cc23645f52040e381550727db420b523b57d494959e0e8c0c6060c46cf173872897f14d43b2ac2aec52fc7b46c02c5699ff7a10beba24d3ced4e89c821e"
))
agg_sig = Signature.aggregate([sig1, sig2])
agg_pk = PublicKey.aggregate([pk1, pk2])
agg_sk = PrivateKey.aggregate([sk1, sk2], [pk1, pk2])
assert (agg_sig.serialize() == bytes.fromhex(
"0a638495c1403b25be391ed44c0ab013390026b5892c796a85ede46310ff7d0e0671f86ebe0e8f56bee80f28eb6d999c0a418c5fc52debac8fc338784cd32b76338d629dc2b4045a5833a357809795ef55ee3e9bee532edfc1d9c443bf5bc658"
))
assert (agg_sk.sign(bytes([7, 8, 9])).serialize() == agg_sig.serialize())
assert (sig1.verify())
assert (agg_sig.verify())
agg_sig.set_aggregation_info(
AggregationInfo.from_msg(agg_pk, bytes([7, 8, 9])))
assert (agg_sig.verify())
sig1.set_aggregation_info(sig2.get_aggregation_info())
assert (not sig1.verify())
sig3 = sk1.sign(bytes([1, 2, 3]))
sig4 = sk1.sign(bytes([1, 2, 3, 4]))
sig5 = sk2.sign(bytes([1, 2]))
agg_sig2 = Signature.aggregate([sig3, sig4, sig5])
assert (agg_sig2.verify())
assert (agg_sig2.serialize() == bytes.fromhex(
"8b11daf73cd05f2fe27809b74a7b4c65b1bb79cc1066bdf839d96b97e073c1a635d2ec048e0801b4a208118fdbbb63a516bab8755cc8d850862eeaa099540cd83621ff9db97b4ada857ef54c50715486217bd2ecb4517e05ab49380c041e159b"
))
def puzzHash(pk):
child_sk: PrivateKey = PrivateKey.from_bytes(bytes.fromhex(pk))
child_public_key = child_sk.get_g1()
puzzle = puzzle_for_pk(child_public_key)
puzzle_hash = puzzle.get_tree_hash()
# xch
address = encode_puzzle_hash(puzzle_hash, "txch")
return address
def parse_plot_info(memo: bytes) -> Tuple[G1Element, G1Element, PrivateKey]:
# Parses the plot info bytes into keys
assert len(memo) == (48 + 48 + 32)
return (
G1Element.from_bytes(memo[:48]),
G1Element.from_bytes(memo[48:96]),
PrivateKey.from_bytes(memo[96:]),
)
def recovery_string_to_dict(recovery_string):
recovery_dict = cbor.loads(bytes.fromhex(recovery_string))
recovery_dict['root_public_key'] = ExtendedPublicKey.from_bytes(
recovery_dict['root_public_key'])
recovery_dict['secret_key'] = PrivateKey.from_bytes(
recovery_dict['secret_key'])
recovery_dict['stake_factor'] = Decimal(recovery_dict['stake_factor'])
return recovery_dict
async def add_plot(self, request: Dict) -> Dict:
filename = request["filename"]
if "pool_pk" in request:
pool_pk = PublicKey.from_bytes(bytes.fromhex(request["pool_pk"]))
else:
pool_pk = None
plot_sk = PrivateKey.from_bytes(bytes.fromhex(request["plot_sk"]))
success = self.service._add_plot(filename, plot_sk, pool_pk)
return {"success": success}
def parse_plot_info(memo: bytes) -> Tuple[Union[G1Element, bytes32], G1Element, PrivateKey]:
# Parses the plot info bytes into keys
if len(memo) == (48 + 48 + 32):
# This is a public key memo
return (
G1Element.from_bytes(memo[:48]),
G1Element.from_bytes(memo[48:96]),
PrivateKey.from_bytes(memo[96:]),
)
elif len(memo) == (32 + 48 + 32):
# This is a pool_contract_puzzle_hash memo
return (
bytes32(memo[:32]),
G1Element.from_bytes(memo[32:80]),
PrivateKey.from_bytes(memo[80:]),
)
else:
raise ValueError(f"Invalid number of bytes {len(memo)}")
def generate(args, parser):
root_path = args.root_path
keys_yaml = "keys.yaml"
key_config_filename = config_path_for_filename(root_path, keys_yaml)
if args.keys != ["keys"]:
parser.print_help()
print("\nTry `chia generate keys`")
return 1
if key_config_filename.exists():
# If the file exists, warn the user
yn = input(
f"The keys file {key_config_filename} already exists. Are you sure"
f" you want to override the keys? Plots might become invalid. (y/n): "
)
if not (yn.lower() == "y" or yn.lower() == "yes"):
return 1
else:
# Create the file if if doesn't exist
mkdir(key_config_filename.parent)
open(key_config_filename, "a").close()
key_config = load_config(root_path, keys_yaml)
if key_config is None:
key_config = {}
wallet_target = None
if args.wallet:
wallet_sk = ExtendedPrivateKey.from_seed(token_bytes(32))
wallet_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(wallet_sk.public_child(0).get_public_key()))
)
key_config["wallet_sk"] = bytes(wallet_sk).hex()
key_config["wallet_target"] = wallet_target.hex()
save_config(root_path, keys_yaml, key_config)
if args.harvester:
# Replaces the harvester's sk seed. Used to generate plot private keys, which are
# used to sign farmed blocks.
key_config["sk_seed"] = token_bytes(32).hex()
save_config(root_path, keys_yaml, key_config)
if args.pool:
# Replaces the pools keys and targes. Only useful if running a pool, or doing
# solo farming. The pool target allows spending of the coinbase.
pool_sks = [PrivateKey.from_seed(token_bytes(32)) for _ in range(2)]
if wallet_target is None:
pool_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(pool_sks[0].get_public_key()))
)
else:
pool_target = wallet_target
key_config["pool_sks"] = [bytes(pool_sk).hex() for pool_sk in pool_sks]
key_config["pool_target"] = pool_target.hex()
save_config(root_path, keys_yaml, key_config)
if args.pooltarget:
# Compute a new pool target and save it to the config
assert "wallet_target" in key_config
key_config["pool_target"] = key_config["wallet_target"]
save_config(root_path, keys_yaml, key_config)
def test2():
seed = bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
seed2 = bytes([1, 20, 102, 229, 1, 157])
sk = PrivateKey.from_seed(seed)
sk_cp = PrivateKey.from_seed(seed)
sk2 = PrivateKey.from_seed(seed2)
pk = sk.get_public_key()
pk2 = sk2.get_public_key()
assert (sk == sk_cp)
assert (sk != sk2)
assert (pk.get_fingerprint() == 0xddad59bb)
sk2_ser = sk2.serialize()
pk2_ser = pk2.serialize()
pk2_copy = PublicKey.from_bytes(pk2_ser)
assert (pk2 == pk2_copy)
assert (pk != pk2)
assert (len(pk2_ser) == 48)
assert (len(sk2_ser) == 32)
message = bytes("this is the message", "utf-8")
sig = sk.sign(message)
sig_ser = sig.serialize()
sig_cp = Signature.from_bytes(sig_ser)
a1 = AggregationInfo.from_msg(pk, message)
sig_cp.set_aggregation_info(a1)
a2 = sig_cp.get_aggregation_info()
assert (a1 == a2)
sig2 = sk2.sign(message)
assert (len(sig_ser) == 96)
assert (sig != sig2)
assert (sig == sig_cp)
sig_agg = Signature.aggregate([sig, sig2])
result = sig_cp.verify()
result2 = sig2.verify()
result3 = sig_agg.verify()
assert (result)
assert (result2)
assert (result3)
sk2 = sk
def main():
"""
Script for checking all plots in the plots.yaml file. Specify a number of challenge to test for each plot.
"""
parser = argparse.ArgumentParser(description="Chia plot checking script.")
parser.add_argument("-n",
"--num",
help="Number of challenges",
type=int,
default=1000)
args = parser.parse_args()
v = Verifier()
if os.path.isfile(plot_config_filename):
plot_config = safe_load(open(plot_config_filename, "r"))
for plot_filename, plot_info in plot_config["plots"].items():
plot_seed: bytes32 = ProofOfSpace.calculate_plot_seed(
PublicKey.from_bytes(bytes.fromhex(plot_info["pool_pk"])),
PrivateKey.from_bytes(bytes.fromhex(
plot_info["sk"])).get_public_key(),
)
if not os.path.isfile(plot_filename):
# Tries relative path
full_path: str = os.path.join(plot_root, plot_filename)
if not os.path.isfile(full_path):
# Tries absolute path
full_path: str = plot_filename
if not os.path.isfile(full_path):
print(f"Plot file {full_path} not found.")
continue
pr = DiskProver(full_path)
else:
pr = DiskProver(plot_filename)
total_proofs = 0
try:
for i in range(args.num):
challenge = sha256(i.to_bytes(32, "big")).digest()
for index, quality in enumerate(
pr.get_qualities_for_challenge(challenge)):
proof = pr.get_full_proof(challenge, index)
total_proofs += 1
ver_quality = v.validate_proof(plot_seed,
pr.get_size(),
challenge, proof)
assert quality == ver_quality
except BaseException as e:
print(
f"{type(e)}: {e} error in proving/verifying for plot {plot_filename}"
)
print(
f"{plot_filename}: Proofs {total_proofs} / {args.num}, {round(total_proofs/float(args.num), 4)}"
)
else:
print(f"Not plot file found at {plot_config_filename}")
def test_schemes():
# fmt: off
seed = bytes([
0, 50, 6, 244, 24, 199, 1, 25, 52, 88, 192, 19, 18, 12, 89, 6, 220, 18,
102, 58, 209, 82, 12, 62, 89, 110, 182, 9, 44, 20, 254, 22
])
# fmt: on
msg = bytes([100, 2, 254, 88, 90, 45, 23])
msg2 = bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
sk = BasicSchemeMPL.key_gen(seed)
pk = sk.get_g1()
assert sk == PrivateKey.from_bytes(bytes(sk))
assert pk == G1Element.from_bytes(bytes(pk))
for Scheme in (BasicSchemeMPL, AugSchemeMPL, PopSchemeMPL):
sig = Scheme.sign(sk, msg)
assert sig == G2Element.from_bytes(bytes(sig))
assert Scheme.verify(pk, msg, sig)
seed = bytes([1]) + seed[1:]
sk1 = BasicSchemeMPL.key_gen(seed)
pk1 = sk1.get_g1()
seed = bytes([2]) + seed[1:]
sk2 = BasicSchemeMPL.key_gen(seed)
pk2 = sk2.get_g1()
for Scheme in (BasicSchemeMPL, AugSchemeMPL, PopSchemeMPL):
# Aggregate same message
agg_pk = pk1 + pk2
if Scheme is AugSchemeMPL:
sig1 = Scheme.sign(sk1, msg, agg_pk)
sig2 = Scheme.sign(sk2, msg, agg_pk)
else:
sig1 = Scheme.sign(sk1, msg)
sig2 = Scheme.sign(sk2, msg)
agg_sig = Scheme.aggregate([sig1, sig2])
assert Scheme.verify(agg_pk, msg, agg_sig)
# Aggregate different message
sig1 = Scheme.sign(sk1, msg)
sig2 = Scheme.sign(sk2, msg2)
agg_sig = Scheme.aggregate([sig1, sig2])
assert Scheme.aggregate_verify([pk1, pk2], [msg, msg2], agg_sig)
# HD keys
child = Scheme.derive_child_sk(sk1, 123)
childU = Scheme.derive_child_sk_unhardened(sk1, 123)
childUPk = Scheme.derive_child_pk_unhardened(pk1, 123)
sig_child = Scheme.sign(child, msg)
assert Scheme.verify(child.get_g1(), msg, sig_child)
sigU_child = Scheme.sign(childU, msg)
assert Scheme.verify(childUPk, msg, sigU_child)
async def on_connect():
# Sends a handshake to the harvester
pool_sks: List[PrivateKey] = [
PrivateKey.from_bytes(bytes.fromhex(ce))
for ce in key_config["pool_sks"]
]
msg = HarvesterHandshake([sk.get_public_key() for sk in pool_sks])
yield OutboundMessage(NodeType.HARVESTER,
Message("harvester_handshake", msg),
Delivery.BROADCAST)
