chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/wallet/puzzles/tails.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 from chia_rs import Coin
 
@@ -43,20 +43,20 @@ GENESIS_BY_ID_OR_SINGLETON_MOD = load_clvm_maybe_recompile(
 
 class LimitationsProgram:
     @staticmethod
-    def match(uncurried_mod: Program, curried_args: Program) -> Tuple[bool, List[Program]]:
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
         raise NotImplementedError("Need to implement 'match' on limitations programs")
 
     @staticmethod
-    def construct(args: List[Program]) -> Program:
+    def construct(args: list[Program]) -> Program:
         raise NotImplementedError("Need to implement 'construct' on limitations programs")
 
     @staticmethod
-    def solve(args: List[Program], solution_dict: Dict) -> Program:
+    def solve(args: list[Program], solution_dict: dict) -> Program:
         raise NotImplementedError("Need to implement 'solve' on limitations programs")
 
     @classmethod
     async def generate_issuance_bundle(
-        cls, wallet, cat_tail_info: Dict, amount: uint64, action_scope: WalletActionScope
+        cls, wallet, cat_tail_info: dict, amount: uint64, action_scope: WalletActionScope
     ) -> WalletSpendBundle:
         raise NotImplementedError("Need to implement 'generate_issuance_bundle' on limitations programs")
 
@@ -68,7 +68,7 @@ class GenesisById(LimitationsProgram):
     """
 
     @staticmethod
-    def match(uncurried_mod: Program, curried_args: Program) -> Tuple[bool, List[Program]]:
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
         if uncurried_mod == GENESIS_BY_ID_MOD:
             genesis_id = curried_args.first()
             return True, [genesis_id]
@@ -76,18 +76,18 @@ class GenesisById(LimitationsProgram):
             return False, []
 
     @staticmethod
-    def construct(args: List[Program]) -> Program:
+    def construct(args: list[Program]) -> Program:
         return GENESIS_BY_ID_MOD.curry(args[0])
 
     @staticmethod
-    def solve(args: List[Program], solution_dict: Dict) -> Program:
+    def solve(args: list[Program], solution_dict: dict) -> Program:
         return Program.to([])
 
     @classmethod
     async def generate_issuance_bundle(
         cls,
         wallet,
-        _: Dict,
+        _: dict,
         amount: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
@@ -97,7 +97,9 @@ class GenesisById(LimitationsProgram):
         origin = coins.copy().pop()
         origin_id = origin.name()
 
-        cat_inner: Program = await wallet.get_new_inner_puzzle()
+        cat_inner: Program = await wallet.standard_wallet.get_puzzle(
+            new=not action_scope.config.tx_config.reuse_puzhash
+        )
         tail: Program = cls.construct([Program.to(origin_id)])
 
         wallet.lineage_store = await CATLineageStore.create(
@@ -126,12 +128,12 @@ class GenesisById(LimitationsProgram):
             CAT_MOD,
             [
                 SpendableCAT(
-                    list(
+                    next(
                         filter(
                             lambda a: a.amount == amount,
                             [add for tx in inner_action_scope.side_effects.transactions for add in tx.additions],
                         )
-                    )[0],
+                    ),
                     tail.get_tree_hash(),
                     cat_inner,
                     inner_solution,
@@ -153,7 +155,7 @@ class GenesisByPuzhash(LimitationsProgram):
     """
 
     @staticmethod
-    def match(uncurried_mod: Program, curried_args: Program) -> Tuple[bool, List[Program]]:
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
         if uncurried_mod == GENESIS_BY_PUZHASH_MOD:
             genesis_puzhash = curried_args.first()
             return True, [genesis_puzhash]
@@ -161,11 +163,11 @@ class GenesisByPuzhash(LimitationsProgram):
             return False, []
 
     @staticmethod
-    def construct(args: List[Program]) -> Program:
+    def construct(args: list[Program]) -> Program:
         return GENESIS_BY_PUZHASH_MOD.curry(args[0])
 
     @staticmethod
-    def solve(args: List[Program], solution_dict: Dict) -> Program:
+    def solve(args: list[Program], solution_dict: dict) -> Program:
         pid = hexstr_to_bytes(solution_dict["parent_coin_info"])
         return Program.to([pid, solution_dict["amount"]])
 
@@ -176,7 +178,7 @@ class EverythingWithSig(LimitationsProgram):
     """
 
     @staticmethod
-    def match(uncurried_mod: Program, curried_args: Program) -> Tuple[bool, List[Program]]:
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
         if uncurried_mod == EVERYTHING_WITH_SIG_MOD:
             pubkey = curried_args.first()
             return True, [pubkey]
@@ -184,11 +186,11 @@ class EverythingWithSig(LimitationsProgram):
             return False, []
 
     @staticmethod
-    def construct(args: List[Program]) -> Program:
+    def construct(args: list[Program]) -> Program:
         return EVERYTHING_WITH_SIG_MOD.curry(args[0])
 
     @staticmethod
-    def solve(args: List[Program], solution_dict: Dict) -> Program:
+    def solve(args: list[Program], solution_dict: dict) -> Program:
         return Program.to([])
 
 
@@ -198,7 +200,7 @@ class DelegatedLimitations(LimitationsProgram):
     """
 
     @staticmethod
-    def match(uncurried_mod: Program, curried_args: Program) -> Tuple[bool, List[Program]]:
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
         if uncurried_mod == DELEGATED_LIMITATIONS_MOD:
             pubkey = curried_args.first()
             return True, [pubkey]
@@ -206,11 +208,11 @@ class DelegatedLimitations(LimitationsProgram):
             return False, []
 
     @staticmethod
-    def construct(args: List[Program]) -> Program:
+    def construct(args: list[Program]) -> Program:
         return DELEGATED_LIMITATIONS_MOD.curry(args[0])
 
     @staticmethod
-    def solve(args: List[Program], solution_dict: Dict) -> Program:
+    def solve(args: list[Program], solution_dict: dict) -> Program:
         signed_program = ALL_LIMITATIONS_PROGRAMS[solution_dict["signed_program"]["identifier"]]
         inner_program_args = [Program.fromhex(item) for item in solution_dict["signed_program"]["args"]]
         inner_solution_dict = solution_dict["program_arguments"]
@@ -228,7 +230,7 @@ class GenesisByIdOrSingleton(LimitationsProgram):
     """
 
     @staticmethod
-    def match(uncurried_mod: Program, curried_args: Program) -> Tuple[bool, List[Program]]:  # pragma: no cover
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:  # pragma: no cover
         if uncurried_mod == GENESIS_BY_ID_OR_SINGLETON_MOD:
             genesis_id = curried_args.first()
             return True, [genesis_id]
@@ -236,14 +238,14 @@ class GenesisByIdOrSingleton(LimitationsProgram):
             return False, []
 
     @staticmethod
-    def construct(args: List[Program]) -> Program:
+    def construct(args: list[Program]) -> Program:
         return GENESIS_BY_ID_OR_SINGLETON_MOD.curry(
             args[0],
             args[1],
         )
 
     @staticmethod
-    def solve(args: List[Program], solution_dict: Dict) -> Program:  # pragma: no cover
+    def solve(args: list[Program], solution_dict: dict) -> Program:  # pragma: no cover
         pid = hexstr_to_bytes(solution_dict["parent_coin_info"])
         return Program.to([pid, solution_dict["amount"]])
 
@@ -251,20 +253,22 @@ class GenesisByIdOrSingleton(LimitationsProgram):
     async def generate_issuance_bundle(
         cls,
         wallet,
-        tail_info: Dict,
+        tail_info: dict,
         amount: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
     ) -> WalletSpendBundle:
         if "coins" in tail_info:
-            coins: List[Coin] = tail_info["coins"]
+            coins: list[Coin] = tail_info["coins"]
             origin_id = coins.copy().pop().name()
         else:  # pragma: no cover
             coins = await wallet.standard_wallet.select_coins(amount + fee, action_scope)
             origin = coins.copy().pop()
             origin_id = origin.name()
 
-        cat_inner: Program = await wallet.get_new_inner_puzzle()
+        cat_inner: Program = await wallet.standard_wallet.get_puzzle(
+            new=not action_scope.config.tx_config.reuse_puzhash
+        )
         # GENESIS_ID
         # TREASURY_SINGLETON_STRUCT  ; (SINGLETON_MOD_HASH, (LAUNCHER_ID, LAUNCHER_PUZZLE_HASH))
         launcher_puzhash = create_cat_launcher_for_singleton_id(tail_info["treasury_id"]).get_tree_hash()
@@ -309,7 +313,7 @@ class GenesisByIdOrSingleton(LimitationsProgram):
             CAT_MOD,
             [
                 SpendableCAT(
-                    list(filter(lambda a: a.amount == amount, tx_record.additions))[0],
+                    next(filter(lambda a: a.amount == amount, tx_record.additions)),
                     tail.get_tree_hash(),
                     cat_inner,
                     inner_solution,
@@ -326,7 +330,7 @@ class GenesisByIdOrSingleton(LimitationsProgram):
 
 # This should probably be much more elegant than just a dictionary with strings as identifiers
 # Right now this is small and experimental so it can stay like this
-ALL_LIMITATIONS_PROGRAMS: Dict[str, Any] = {
+ALL_LIMITATIONS_PROGRAMS: dict[str, Any] = {
     "genesis_by_id": GenesisById,
     "genesis_by_puzhash": GenesisByPuzhash,
     "everything_with_signature": EverythingWithSig,
@@ -335,7 +339,7 @@ ALL_LIMITATIONS_PROGRAMS: Dict[str, Any] = {
 }
 
 
-def match_limitations_program(limitations_program: Program) -> Tuple[Optional[LimitationsProgram], List[Program]]:
+def match_limitations_program(limitations_program: Program) -> tuple[Optional[LimitationsProgram], list[Program]]:
     uncurried_mod, curried_args = limitations_program.uncurry()
     for key, lp in ALL_LIMITATIONS_PROGRAMS.items():
         matched, args = lp.match(uncurried_mod, curried_args)

chia/wallet/signer_protocol.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List
 
 from chia.types.blockchain_format.coin import Coin as _Coin
 from chia.types.blockchain_format.program import Program
@@ -58,7 +57,7 @@ class Spend(Streamable):
 @clvm_streamable
 @dataclass(frozen=True)
 class TransactionInfo(Streamable):
-    spends: List[Spend]
+    spends: list[Spend]
 
 
 @clvm_streamable
@@ -72,7 +71,7 @@ class SigningTarget(Streamable):
 @clvm_streamable
 @dataclass(frozen=True)
 class SumHint(Streamable):
-    fingerprints: List[bytes]
+    fingerprints: list[bytes]
     synthetic_offset: bytes
     final_pubkey: bytes
 
@@ -81,21 +80,21 @@ class SumHint(Streamable):
 @dataclass(frozen=True)
 class PathHint(Streamable):
     root_fingerprint: bytes
-    path: List[uint64]
+    path: list[uint64]
 
 
 @clvm_streamable
 @dataclass(frozen=True)
 class KeyHints(Streamable):
-    sum_hints: List[SumHint]
-    path_hints: List[PathHint]
+    sum_hints: list[SumHint]
+    path_hints: list[PathHint]
 
 
 @clvm_streamable
 @dataclass(frozen=True)
 class SigningInstructions(Streamable):
     key_hints: KeyHints
-    targets: List[SigningTarget]
+    targets: list[SigningTarget]
 
 
 @clvm_streamable
@@ -123,4 +122,4 @@ class Signature(Streamable):
 @dataclass(frozen=True)
 class SignedTransaction(Streamable):
     transaction_info: TransactionInfo
-    signatures: List[Signature]
+    signatures: list[Signature]

chia/wallet/singleton.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -36,7 +36,7 @@ def get_inner_puzzle_from_singleton(puzzle: Union[Program, SerializedProgram]) -
     inner_f, args = r
     if not is_singleton(inner_f):
         return None
-    SINGLETON_STRUCT, INNER_PUZZLE = list(args.as_iter())
+    _SINGLETON_STRUCT, INNER_PUZZLE = list(args.as_iter())
     return Program(INNER_PUZZLE)
 
 
@@ -52,7 +52,7 @@ def get_singleton_id_from_puzzle(puzzle: Union[Program, SerializedProgram]) -> O
     inner_f, args = r
     if not is_singleton(inner_f):
         return None
-    SINGLETON_STRUCT, INNER_PUZZLE = list(args.as_iter())
+    SINGLETON_STRUCT, _INNER_PUZZLE = list(args.as_iter())
     return bytes32(Program(SINGLETON_STRUCT).rest().first().as_atom())
 
 
@@ -94,7 +94,7 @@ def create_singleton_puzzle(innerpuz: Union[Program, SerializedProgram], launche
 
 
 def get_most_recent_singleton_coin_from_coin_spend(coin_sol: CoinSpend) -> Optional[Coin]:
-    additions: List[Coin] = compute_additions(coin_sol)
+    additions: list[Coin] = compute_additions(coin_sol)
     for coin in additions:
         if coin.amount % 2 == 1:
             return coin