CHIA-595: bump chia_rs to 0.8.0 and update G1Element handling

chia/_tests/clvm/test_puzzles.py

@@ -233,7 +233,7 @@ def do_test_spend_p2_delegated_puzzle_or_hidden_puzzle_with_delegated_puzzle(hid
 
  assert synthetic_public_key == int_to_public_key(synthetic_offset) + hidden_pub_key_point
 
- secret_exponent = key_lookup.dict.get(hidden_public_key)
+ secret_exponent = key_lookup.dict[G1Element.from_bytes(hidden_public_key)]
  assert int_to_public_key(secret_exponent) == hidden_pub_key_point
 
  synthetic_secret_exponent = secret_exponent + synthetic_offset

chia/_tests/core/mempool/test_mempool.py

@@ -6,7 +6,7 @@
 from typing import Callable, Dict, List, Optional, Tuple
 
 import pytest
-from chia_rs import G2Element
+from chia_rs import G1Element, G2Element
 from clvm.casts import int_to_bytes
 from clvm_tools import binutils
 
@@ -2161,7 +2161,7 @@ def test_create_coin_cost(self, softfork_height):
  ],
  )
  def test_agg_sig_cost(self, condition, softfork_height):
- pubkey = "abababababababababababababababababababababababab"
+ pubkey = "0x" + bytes(G1Element()).hex()
 
  if softfork_height >= test_constants.HARD_FORK_FIX_HEIGHT:
  generator_base_cost = 40
@@ -2182,7 +2182,7 @@ def test_agg_sig_cost(self, condition, softfork_height):
 
  # this max cost is exactly enough for the AGG_SIG condition
  npc_result = generator_condition_tester(
- f'({condition[0]} "{pubkey}" "foobar") ',
+ f'({condition[0]} {pubkey} "foobar") ',
  max_cost=generator_base_cost + 117 * COST_PER_BYTE + expected_cost,
  height=softfork_height,
  )
@@ -2193,7 +2193,7 @@ def test_agg_sig_cost(self, condition, softfork_height):
 
  # if we subtract one from max cost, this should fail
  npc_result = generator_condition_tester(
- f'({condition[0]} "{pubkey}" "foobar") ',
+ f'({condition[0]} {pubkey} "foobar") ',
  max_cost=generator_base_cost + 117 * COST_PER_BYTE + expected_cost - 1,
  height=softfork_height,
  )
@@ -2219,7 +2219,7 @@ def test_agg_sig_cost(self, condition, softfork_height):
  @pytest.mark.parametrize("extra_arg", [' "baz"', ""])
  @pytest.mark.parametrize("mempool", [True, False])
  def test_agg_sig_extra_arg(self, condition, extra_arg, mempool, softfork_height):
- pubkey = "abababababababababababababababababababababababab"
+ pubkey = "0x" + bytes(G1Element()).hex()
 
  new_condition = condition in [
  ConditionOpcode.AGG_SIG_PARENT,
@@ -2258,7 +2258,7 @@ def test_agg_sig_extra_arg(self, condition, extra_arg, mempool, softfork_height)
 
  # this max cost is exactly enough for the AGG_SIG condition
  npc_result = generator_condition_tester(
- f'({condition[0]} "{pubkey}" "foobar"{extra_arg}) ',
+ f'({condition[0]} {pubkey} "foobar"{extra_arg}) ',
  max_cost=11000000000,
  height=softfork_height,
  mempool_mode=mempool,

chia/_tests/core/util/test_cached_bls.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from chia_rs import AugSchemeMPL, G1Element
+from chia_rs import AugSchemeMPL
 
 from chia.util import cached_bls
 from chia.util.hash import std_hash
@@ -11,7 +11,7 @@ def test_cached_bls():
  n_keys = 10
  seed = b"a" * 31
  sks = [AugSchemeMPL.key_gen(seed + bytes([i])) for i in range(n_keys)]
- pks = [bytes(sk.get_g1()) for sk in sks]
+ pks = [sk.get_g1() for sk in sks]
 
  msgs = [("msg-%d" % (i,)).encode() for i in range(n_keys)]
  sigs = [AugSchemeMPL.sign(sk, msg) for sk, msg in zip(sks, msgs)]
@@ -22,7 +22,7 @@ def test_cached_bls():
  sigs_half = sigs[: n_keys // 2]
  agg_sig_half = AugSchemeMPL.aggregate(sigs_half)
 
- assert AugSchemeMPL.aggregate_verify([G1Element.from_bytes(pk) for pk in pks], msgs, agg_sig)
+ assert AugSchemeMPL.aggregate_verify(pks, msgs, agg_sig)
 
  # Verify with empty cache and populate it
  assert cached_bls.aggregate_verify(pks_half, msgs_half, agg_sig_half, True)
@@ -46,12 +46,12 @@ def test_cached_bls_repeat_pk():
  n_keys = 400
  seed = b"a" * 32
  sks = [AugSchemeMPL.key_gen(seed) for i in range(n_keys)] + [AugSchemeMPL.key_gen(std_hash(seed))]
- pks = [bytes(sk.get_g1()) for sk in sks]
+ pks = [sk.get_g1() for sk in sks]
 
  msgs = [("msg-%d" % (i,)).encode() for i in range(n_keys + 1)]
  sigs = [AugSchemeMPL.sign(sk, msg) for sk, msg in zip(sks, msgs)]
  agg_sig = AugSchemeMPL.aggregate(sigs)
 
- assert AugSchemeMPL.aggregate_verify([G1Element.from_bytes(pk) for pk in pks], msgs, agg_sig)
+ assert AugSchemeMPL.aggregate_verify(pks, msgs, agg_sig)
 
  assert cached_bls.aggregate_verify(pks, msgs, agg_sig, force_cache=True)

chia/_tests/util/key_tool.py

@@ -3,7 +3,7 @@
 from dataclasses import dataclass, field
 from typing import Dict, List
 
-from chia_rs import AugSchemeMPL, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
 
 from chia._tests.core.make_block_generator import GROUP_ORDER, int_to_public_key
 from chia.simulator.block_tools import test_constants
@@ -13,16 +13,16 @@
 
 @dataclass
 class KeyTool:
- dict: Dict[bytes, int] = field(default_factory=dict)
+ dict: Dict[G1Element, int] = field(default_factory=dict)
 
  def add_secret_exponents(self, secret_exponents: List[int]) -> None:
  for _ in secret_exponents:
- self.dict[bytes(int_to_public_key(_))] = _ % GROUP_ORDER
+ self.dict[int_to_public_key(_)] = _ % GROUP_ORDER
 
- def sign(self, public_key: bytes, message: bytes) -> G2Element:
+ def sign(self, public_key: G1Element, message: bytes) -> G2Element:
  secret_exponent = self.dict.get(public_key)
  if not secret_exponent:
- raise ValueError("unknown pubkey %s" % public_key.hex())
+ raise ValueError("unknown pubkey %s" % bytes(public_key).hex())
  bls_private_key = PrivateKey.from_bytes(secret_exponent.to_bytes(32, "big"))
  return AugSchemeMPL.sign(bls_private_key, message)
 

chia/_tests/util/test_condition_tools.py

@@ -8,7 +8,7 @@
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32, bytes48
+from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
 from chia.types.spend_bundle_conditions import Spend, SpendBundleConditions
@@ -29,8 +29,8 @@
 
 def mk_agg_sig_conditions(
  opcode: ConditionOpcode,
- agg_sig_data: List[Tuple[bytes, bytes]],
- agg_sig_unsafe_data: List[Tuple[bytes, bytes]] = [],
+ agg_sig_data: List[Tuple[G1Element, bytes]],
+ agg_sig_unsafe_data: List[Tuple[G1Element, bytes]] = [],
 ) -> SpendBundleConditions:
  spend = Spend(
  coin_id=TEST_COIN.name(),
@@ -69,18 +69,18 @@ def mk_agg_sig_conditions(
  ],
 )
 def test_pkm_pairs_vs_for_conditions_dict(opcode: ConditionOpcode) -> None:
- conds = mk_agg_sig_conditions(opcode, agg_sig_data=[(bytes48(PK1), b"msg1"), (bytes48(PK2), b"msg2")])
+ conds = mk_agg_sig_conditions(opcode, agg_sig_data=[(PK1, b"msg1"), (PK2, b"msg2")])
  pks, msgs = pkm_pairs(conds, b"foobar")
  result_aligned = [(x, y) for x, y in zip(pks, msgs)]
  conditions_dict = {
- opcode: [ConditionWithArgs(opcode, [bytes48(PK1), b"msg1"]), ConditionWithArgs(opcode, [bytes48(PK2), b"msg2"])]
+ opcode: [ConditionWithArgs(opcode, [bytes(PK1), b"msg1"]), ConditionWithArgs(opcode, [bytes(PK2), b"msg2"])]
  }
  result2 = pkm_pairs_for_conditions_dict(conditions_dict, TEST_COIN, b"foobar")
  assert result_aligned == result2
 
  # missing message argument
  with pytest.raises(ConsensusError, match="INVALID_CONDITION"):
- conditions_dict = {opcode: [ConditionWithArgs(opcode, [bytes48(PK1)])]}
+ conditions_dict = {opcode: [ConditionWithArgs(opcode, [bytes(PK1)])]}
  result2 = pkm_pairs_for_conditions_dict(conditions_dict, TEST_COIN, b"foobar")
 
  with pytest.raises(ConsensusError, match="INVALID_CONDITION"):
@@ -89,12 +89,12 @@ def test_pkm_pairs_vs_for_conditions_dict(opcode: ConditionOpcode) -> None:
 
  # extra argument
  with pytest.raises(ConsensusError, match="INVALID_CONDITION"):
- conditions_dict = {opcode: [ConditionWithArgs(opcode, [bytes48(PK1), b"msg1", b"msg2"])]}
+ conditions_dict = {opcode: [ConditionWithArgs(opcode, [bytes(PK1), b"msg1", b"msg2"])]}
  result2 = pkm_pairs_for_conditions_dict(conditions_dict, TEST_COIN, b"foobar")
 
  # message too long
  with pytest.raises(ConsensusError, match="INVALID_CONDITION"):
- conditions_dict = {opcode: [ConditionWithArgs(opcode, [bytes48(PK1), b"m" * 1025])]}
+ conditions_dict = {opcode: [ConditionWithArgs(opcode, [bytes(PK1), b"m" * 1025])]}
  result2 = pkm_pairs_for_conditions_dict(conditions_dict, TEST_COIN, b"foobar")
 
 
@@ -136,7 +136,7 @@ def test_no_agg_sigs(self, opcode: ConditionOpcode) -> None:
  ],
  )
  def test_agg_sig_conditions(self, opcode: ConditionOpcode, value: bytes) -> None:
- conds = mk_agg_sig_conditions(opcode, agg_sig_data=[(bytes48(PK1), b"msg1"), (bytes48(PK2), b"msg2")])
+ conds = mk_agg_sig_conditions(opcode, agg_sig_data=[(PK1, b"msg1"), (PK2, b"msg2")])
  addendum = b"foobar" if opcode == ConditionOpcode.AGG_SIG_ME else std_hash(b"foobar" + opcode)
  pks, msgs = pkm_pairs(conds, b"foobar")
  assert [bytes(pk) for pk in pks] == [bytes(PK1), bytes(PK2)]
@@ -155,9 +155,7 @@ def test_agg_sig_conditions(self, opcode: ConditionOpcode, value: bytes) -> None
  ],
  )
  def test_agg_sig_unsafe(self, opcode: ConditionOpcode) -> None:
- conds = mk_agg_sig_conditions(
- opcode, agg_sig_data=[], agg_sig_unsafe_data=[(bytes48(PK1), b"msg1"), (bytes48(PK2), b"msg2")]
- )
+ conds = mk_agg_sig_conditions(opcode, agg_sig_data=[], agg_sig_unsafe_data=[(PK1, b"msg1"), (PK2, b"msg2")])
  pks, msgs = pkm_pairs(conds, b"foobar")
  assert [bytes(pk) for pk in pks] == [bytes(PK1), bytes(PK2)]
  assert msgs == [b"msg1", b"msg2"]
@@ -175,9 +173,7 @@ def test_agg_sig_unsafe(self, opcode: ConditionOpcode) -> None:
  ],
  )
  def test_agg_sig_mixed(self, opcode: ConditionOpcode, value: bytes) -> None:
- conds = mk_agg_sig_conditions(
- opcode, agg_sig_data=[(bytes48(PK1), b"msg1")], agg_sig_unsafe_data=[(bytes48(PK2), b"msg2")]
- )
+ conds = mk_agg_sig_conditions(opcode, agg_sig_data=[(PK1, b"msg1")], agg_sig_unsafe_data=[(PK2, b"msg2")])
  addendum = b"foobar" if opcode == ConditionOpcode.AGG_SIG_ME else std_hash(b"foobar" + opcode)
  pks, msgs = pkm_pairs(conds, b"foobar")
  assert [bytes(pk) for pk in pks] == [bytes(PK2), bytes(PK1)]
@@ -196,9 +192,7 @@ def test_agg_sig_mixed(self, opcode: ConditionOpcode, value: bytes) -> None:
  ],
  )
  def test_agg_sig_unsafe_restriction(self, opcode: ConditionOpcode) -> None:
- conds = mk_agg_sig_conditions(
- opcode, agg_sig_data=[], agg_sig_unsafe_data=[(bytes48(PK1), b"msg1"), (bytes48(PK2), b"msg2")]
- )
+ conds = mk_agg_sig_conditions(opcode, agg_sig_data=[], agg_sig_unsafe_data=[(PK1, b"msg1"), (PK2, b"msg2")])
  with pytest.raises(ConsensusError, match="INVALID_CONDITION"):
  pkm_pairs(conds, b"msg1")
 
@@ -216,11 +210,9 @@ class TestPkmPairsForConditionDict:
  def test_agg_sig_unsafe_restriction(self) -> None:
  ASU = ConditionOpcode.AGG_SIG_UNSAFE
 
- conds = {
- ASU: [ConditionWithArgs(ASU, [bytes48(PK1), b"msg1"]), ConditionWithArgs(ASU, [bytes48(PK2), b"msg2"])]
- }
+ conds = {ASU: [ConditionWithArgs(ASU, [bytes(PK1), b"msg1"]), ConditionWithArgs(ASU, [bytes(PK2), b"msg2"])]}
  tuples = pkm_pairs_for_conditions_dict(conds, TEST_COIN, b"msg10")
- assert tuples == [(bytes48(PK1), b"msg1"), (bytes48(PK2), b"msg2")]
+ assert tuples == [(PK1, b"msg1"), (PK2, b"msg2")]
 
  with pytest.raises(ConsensusError, match="INVALID_CONDITION"):
  pkm_pairs_for_conditions_dict(conds, TEST_COIN, b"msg1")

chia/_tests/wallet/clawback/test_clawback_lifecycle.py

@@ -75,10 +75,9 @@ def sign_coin_spend(self, coin_spend: CoinSpend, index: int) -> G2Element:
 
  conditions_dict = conditions_dict_for_solution(coin_spend.puzzle_reveal, coin_spend.solution, INFINITE_COST)
  signatures = []
- for pk_bytes, msg in pkm_pairs_for_conditions_dict(
+ for pk, msg in pkm_pairs_for_conditions_dict(
  conditions_dict, coin_spend.coin, DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA
  ):
- pk = G1Element.from_bytes(pk_bytes)
  signature = AugSchemeMPL.sign(synthetic_secret_key, msg)
  assert AugSchemeMPL.verify(pk, msg, signature)
  signatures.append(signature)

chia/_tests/wallet/test_signer_protocol.py

@@ -122,7 +122,7 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
  SumHint(
  [pubkey.get_fingerprint().to_bytes(4, "big")],
  calculate_synthetic_offset(pubkey, DEFAULT_HIDDEN_PUZZLE_HASH).to_bytes(32, "big"),
- wallet_state_manager.main_wallet.puzzle_for_pk(pubkey).uncurry()[1].at("f").as_atom(),
+ G1Element.from_bytes(wallet_state_manager.main_wallet.puzzle_for_pk(pubkey).uncurry()[1].at("f").as_atom()),
  )
  ]
  assert utx.signing_instructions.key_hints.path_hints == [
@@ -184,7 +184,7 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
  not_our_signing_instructions.key_hints,
  sum_hints=[
  *not_our_signing_instructions.key_hints.sum_hints,
- SumHint([bytes(not_our_pubkey)], std_hash(b"sum hint only"), bytes(G1Element())),
+ SumHint([bytes(not_our_pubkey)], std_hash(b"sum hint only"), G1Element()),
  ],
  ),
  )
@@ -284,7 +284,7 @@ async def test_p2blsdohp_execute_signing_instructions(wallet_environments: Walle
  sum_pk: G1Element = other_sk.get_g1() + root_pk
  signing_instructions: SigningInstructions = SigningInstructions(
  KeyHints(
- [SumHint([root_fingerprint], test_name, bytes(sum_pk))],
+ [SumHint([root_fingerprint], test_name, sum_pk)],
  [],
  ),
  [SigningTarget(sum_pk.get_fingerprint().to_bytes(4, "big"), test_name, test_name)],
@@ -335,7 +335,7 @@ async def test_p2blsdohp_execute_signing_instructions(wallet_environments: Walle
  sum_pk = child_sk.get_g1() + other_sk.get_g1()
  signing_instructions = SigningInstructions(
  KeyHints(
- [SumHint([child_sk.get_g1().get_fingerprint().to_bytes(4, "big")], test_name, bytes(sum_pk))],
+ [SumHint([child_sk.get_g1().get_fingerprint().to_bytes(4, "big")], test_name, sum_pk)],
  [PathHint(root_fingerprint, [uint64(1), uint64(2), uint64(3), uint64(4)])],
  ),
  [SigningTarget(sum_pk.get_fingerprint().to_bytes(4, "big"), test_name, test_name)],
@@ -370,8 +370,8 @@ async def test_p2blsdohp_execute_signing_instructions(wallet_environments: Walle
  SigningInstructions(
  KeyHints(
  [
- SumHint([child_sk.get_g1().get_fingerprint().to_bytes(4, "big")], test_name, bytes(sum_pk)),
- SumHint([child_sk_2.get_g1().get_fingerprint().to_bytes(4, "big")], test_name_2, bytes(sum_pk_2)),
+ SumHint([child_sk.get_g1().get_fingerprint().to_bytes(4, "big")], test_name, sum_pk),
+ SumHint([child_sk_2.get_g1().get_fingerprint().to_bytes(4, "big")], test_name_2, sum_pk_2),
  ],
  [
  PathHint(root_fingerprint, [uint64(1), uint64(2), uint64(3), uint64(4)]),
@@ -412,7 +412,7 @@ async def test_p2blsdohp_execute_signing_instructions(wallet_environments: Walle
  )
  unknown_sum_hint = SigningInstructions(
  KeyHints(
- [SumHint([b"unknown fingerprint"], b"", bytes(G1Element()))],
+ [SumHint([b"unknown fingerprint"], b"", G1Element())],
  [],
  ),
  [],
@@ -439,7 +439,7 @@ async def test_p2blsdohp_execute_signing_instructions(wallet_environments: Walle
  signing_responses = await wallet.execute_signing_instructions(
  SigningInstructions(
  KeyHints(
- [SumHint([root_fingerprint], test_name, bytes(sum_pk))],
+ [SumHint([root_fingerprint], test_name, sum_pk)],
  [],
  ),
  [SigningTarget(sum_pk.get_fingerprint().to_bytes(4, "big"), test_name, test_name)],

chia/consensus/block_body_validation.py

@@ -5,6 +5,7 @@
 from dataclasses import dataclass, field
 from typing import Awaitable, Callable, Dict, List, Optional, Set, Tuple, Union
 
+from chia_rs import G1Element
 from chiabip158 import PyBIP158
 
 from chia.consensus.block_record import BlockRecord
@@ -19,7 +20,7 @@
 from chia.full_node.mempool_check_conditions import mempool_check_time_locks
 from chia.types.block_protocol import BlockInfo
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.sized_bytes import bytes32, bytes48
+from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_record import CoinRecord
 from chia.types.full_block import FullBlock
 from chia.types.generator_types import BlockGenerator
@@ -512,7 +513,7 @@ async def validate_block_body(
  return error, None
 
  # create hash_key list for aggsig check
- pairs_pks: List[bytes48] = []
+ pairs_pks: List[G1Element] = []
  pairs_msgs: List[bytes] = []
  if npc_result:
  assert npc_result.conds is not None

chia/consensus/multiprocess_validation.py

@@ -8,7 +8,7 @@
 from dataclasses import dataclass
 from typing import Awaitable, Callable, Dict, List, Optional, Sequence, Tuple
 
-from chia_rs import AugSchemeMPL, G1Element
+from chia_rs import AugSchemeMPL
 
 from chia.consensus.block_header_validation import validate_finished_header_block
 from chia.consensus.block_record import BlockRecord
@@ -126,10 +126,8 @@ def batch_pre_validate_blocks(
  if npc_result is not None and block.transactions_info is not None:
  assert npc_result.conds
  pairs_pks, pairs_msgs = pkm_pairs(npc_result.conds, constants.AGG_SIG_ME_ADDITIONAL_DATA)
- # Using AugSchemeMPL.aggregate_verify, so it's safe to use from_bytes_unchecked
- pks_objects: List[G1Element] = [G1Element.from_bytes_unchecked(pk) for pk in pairs_pks]
  if not AugSchemeMPL.aggregate_verify(
- pks_objects, pairs_msgs, block.transactions_info.aggregated_signature
+ pairs_pks, pairs_msgs, block.transactions_info.aggregated_signature
  ):
  error_int = uint16(Err.BAD_AGGREGATE_SIGNATURE.value)
  else:

chia/full_node/mempool_manager.py

@@ -11,7 +11,7 @@
 
 from chia_rs import ELIGIBLE_FOR_DEDUP, ELIGIBLE_FOR_FF
 from chia_rs import CoinSpend as RustCoinSpend
-from chia_rs import GTElement
+from chia_rs import G1Element, GTElement
 from chia_rs import Program as RustProgram
 from chia_rs import supports_fast_forward
 from chiabip158 import PyBIP158
@@ -27,7 +27,7 @@
 from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions, mempool_check_time_locks
 from chia.full_node.pending_tx_cache import ConflictTxCache, PendingTxCache
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.sized_bytes import bytes32, bytes48
+from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.clvm_cost import CLVMCost
 from chia.types.coin_record import CoinRecord
 from chia.types.eligible_coin_spends import EligibilityAndAdditions, UnspentLineageInfo
@@ -78,7 +78,7 @@ def validate_clvm_and_signature(
  if result.error is not None:
  return Err(result.error), b"", {}, time.monotonic() - start_time
 
- pks: List[bytes48] = []
+ pks: List[G1Element] = []
  msgs: List[bytes] = []
  assert result.conds is not None
  pks, msgs = pkm_pairs(result.conds, additional_data)