Add a first crack at syncing

Author: Quexington

chia/_tests/pools/test_plotnft_v2_drivers.py

@@ -65,7 +65,7 @@ async def mint_plotnft(
     else:
         custody = self_custody
 
-    conditions, spends, plotnft = PlotNFT.launch(origin_coins=[origin_coin], custody=custody, memos=[])
+    conditions, spends, plotnft = PlotNFT.launch(origin_coins=[origin_coin], custody=custody)
 
     result = await sim_client.push_tx(
         WalletSpendBundle(
@@ -75,6 +75,10 @@ async def mint_plotnft(
     )
     assert result == (MempoolInclusionStatus.SUCCESS, None)
     await sim.farm_block()
+    assert (
+        PlotNFT.get_next_from_coin_spend(coin_spend=spends[1], genesis_challenge=sim.defaults.GENESIS_CHALLENGE)
+        == plotnft
+    )
     return plotnft
 
 

chia/data_layer/data_layer_wallet.py

@@ -1058,7 +1058,9 @@ async def make_update_offer(
 
         # create some dummy requested payments
         requested_payments = {
-            k: [NotarizedPayment(bytes32.zeros, uint64(v), [], bytes32.zeros)] for k, v in offer_dict.items() if v > 0
+            k: [NotarizedPayment(bytes32.zeros, uint64(v), [], nonce=bytes32.zeros)]
+            for k, v in offer_dict.items()
+            if v > 0
         }
 
         async with action_scope.use() as interface:

chia/pools/plotnft_drivers.py

@@ -2,13 +2,14 @@
 
 import dataclasses
 from dataclasses import dataclass, field
-from typing import Self
+from typing import ClassVar, Self
 
+from chia_rs import G1Element
 from chia_rs.chia_rs import Coin, CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
-from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.program import Program, run
 from chia.types.coin_spend import make_spend
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
@@ -18,6 +19,7 @@
     MessageParticipant,
     ReserveFee,
     SendMessage,
+    parse_conditions_non_consensus,
 )
 from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.puzzles.custody.custody_architecture import (
@@ -36,6 +38,7 @@
     puzzle_for_singleton,
     solution_for_singleton,
 )
+from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
 
 CLAIM_POOL_REWARDS_DELEGATED_PUZZLE = load_clvm_maybe_recompile(
     "claim_pool_rewards_dpuz.clsp", package_or_requirement="chia.pools"
@@ -83,11 +86,12 @@ class SelfCustody:
 
     def puzzle_with_restrictions(self) -> PuzzleWithRestrictions:
         return PuzzleWithRestrictions(
-            nonce=0,
-            restrictions=[],
-            puzzle=self.member,
+            nonce=0, restrictions=[], puzzle=self.member, additional_memos=self.memos(nonce=0)
         )
 
+    def memos(self, nonce: int) -> Program:
+        return Program.to([self.member.synthetic_key])
+
     def puzzle(self, nonce: int) -> Program:
         return self.puzzle_with_restrictions().puzzle_reveal()
 
@@ -199,8 +203,12 @@ def puzzle_with_restrictions(self) -> PuzzleWithRestrictions:
                     self.pool_puzzle_with_restrictions(),
                 ],
             ),
+            additional_memos=self.memos(nonce=0),
         )
 
+    def memos(self, nonce: int) -> Program:
+        return Program.to([self.self_custody.member.synthetic_key, self.pool_puzzle_hash, self.timelock])
+
     def puzzle(self, nonce: int) -> Program:
         return self.puzzle_with_restrictions().puzzle_reveal()
 
@@ -267,20 +275,21 @@ class PlotNFT:
     coin: Coin
     singleton_lineage_proof: LineageProof
     puzzle: PlotNFTPuzzle
+    singleton_mod: ClassVar[Program] = SINGLETON_MOD
+    singleton_launcher: ClassVar[Program] = SINGLETON_LAUNCHER
 
-    @staticmethod
+    @classmethod
     def origin_coin_info(
+        cls,
         origin_coins: list[Coin],
-        singleton_mod: Program = SINGLETON_MOD,
-        singleton_launcher: Program = SINGLETON_LAUNCHER,
     ) -> tuple[Coin, Coin, SingletonStruct]:
         origin_coin = origin_coins[0]
 
-        launcher_hash = singleton_launcher.get_tree_hash()
+        launcher_hash = cls.singleton_launcher.get_tree_hash()
         launcher_coin = Coin(origin_coin.name(), launcher_hash, uint64(1))
         launcher_id = launcher_coin.name()
         singleton_struct = SingletonStruct(
-            singleton_mod=singleton_mod, launcher_id=launcher_id, singleton_launcher=singleton_launcher
+            singleton_mod=cls.singleton_mod, launcher_id=launcher_id, singleton_launcher=cls.singleton_launcher
         )
 
         return origin_coin, launcher_coin, singleton_struct
@@ -291,33 +300,32 @@ def launch(
         *,
         origin_coins: list[Coin],
         custody: SelfCustody | PoolingCustody,
-        memos: list[bytes],
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
-        singleton_mod: Program = SINGLETON_MOD,
-        singleton_launcher: Program = SINGLETON_LAUNCHER,
     ) -> tuple[list[Program], list[CoinSpend], Self]:
-        mod_hash = singleton_mod.get_tree_hash()
-        launcher_hash = singleton_launcher.get_tree_hash()
-        origin_coin, launcher_coin, singleton_struct = cls.origin_coin_info(
-            origin_coins, singleton_mod, singleton_launcher
-        )
+        mod_hash = cls.singleton_mod.get_tree_hash()
+        launcher_hash = cls.singleton_launcher.get_tree_hash()
+        origin_coin, launcher_coin, singleton_struct = cls.origin_coin_info(origin_coins)
         launcher_id = launcher_coin.name()
 
         plotnft_puzzle = PlotNFTPuzzle(singleton_struct=singleton_struct, inner_custody=custody)
         rev_puzzle = Program.to(
             (
                 1,
                 [
-                    CreateCoin(plotnft_puzzle.inner_custody.puzzle_hash(nonce=0), uint64(1), memos=memos).to_program(),
+                    CreateCoin(
+                        plotnft_puzzle.inner_custody.puzzle_hash(nonce=0),
+                        uint64(1),
+                        memo_blob=plotnft_puzzle.inner_custody.puzzle_with_restrictions().memo(),
+                    ).to_program(),
                     CreateCoinAnnouncement(msg=b"").to_program(),
                 ],
             )
         )
         full_rev_singleton_puzzle = puzzle_for_singleton(
             launcher_id,
             rev_puzzle,
-            singleton_mod=singleton_mod,
+            singleton_mod=cls.singleton_mod,
             launcher_hash=launcher_hash,
             singleton_mod_hash=mod_hash,
         )
@@ -335,7 +343,7 @@ def launch(
         ]
         launcher_spend = make_spend(
             launcher_coin,
-            singleton_launcher,
+            cls.singleton_launcher,
             launcher_solution,
         )
         rev_spend = make_spend(
@@ -361,6 +369,90 @@ def launch(
             ),
         )
 
+    @classmethod
+    def get_next_from_coin_spend(
+        cls,
+        *,
+        coin_spend: CoinSpend,
+        genesis_challenge: bytes32,
+        pre_uncurry: UncurriedPuzzle | None = None,
+    ) -> Self:
+        if pre_uncurry is None:
+            singleton = uncurry_puzzle(coin_spend.puzzle_reveal)
+        else:
+            singleton = pre_uncurry
+
+        if singleton.mod != cls.singleton_mod:
+            raise ValueError("Invalid singleton mod for next PlotNFT")
+        if singleton.args.at("frr") != cls.singleton_launcher.get_tree_hash():  # TODO: optimize
+            raise ValueError("Invalid singleton launcher for next PlotNFT")
+
+        singleton_struct = SingletonStruct(
+            singleton_mod=cls.singleton_mod,
+            singleton_launcher=cls.singleton_launcher,
+            launcher_id=bytes32(singleton.args.at("frf").as_atom()),
+        )
+
+        inner_puzzle = singleton.args.at("rf")
+        inner_conditions = parse_conditions_non_consensus(
+            run(inner_puzzle, Program.from_serialized(coin_spend.solution).at("rrf")).as_iter()
+        )
+        singleton_create_coin = next(condition for condition in inner_conditions if isinstance(condition, CreateCoin))
+        if singleton_create_coin.memo_blob is None:
+            raise ValueError("Invalid memoization of PlotNFT")
+        unknown_inner_puzzle = PuzzleWithRestrictions.from_memo(singleton_create_coin.memo_blob)
+        assert unknown_inner_puzzle.additional_memos is not None
+        self_custody = SelfCustody(
+            member=BLSWithTaprootMember(
+                synthetic_key=G1Element.from_bytes(unknown_inner_puzzle.additional_memos.at("f").as_atom())
+            )
+        )
+        if isinstance(unknown_inner_puzzle.puzzle, MofN):
+            unknown_inner_puzzle.fill_in_unknown_puzzles(
+                {SendMessageBanned().puzzle_hash(nonce=0): SendMessageBanned()}
+            )
+            pool_puzzle_hash = bytes32(unknown_inner_puzzle.additional_memos.at("rf").as_atom())
+            timelock = uint64(unknown_inner_puzzle.additional_memos.at("rrf").as_int())
+
+            custody: SelfCustody | PoolingCustody = PoolingCustody(
+                singleton_struct=singleton_struct,
+                self_custody=self_custody,
+                pool_puzzle_hash=pool_puzzle_hash,
+                reward_puzhash=RewardPuzzle(singleton_id=singleton_struct.launcher_id).puzzle_hash(),
+                timelock=timelock,
+                exiting=ValidatorStackRestriction(
+                    required_wrappers=[Timelock(timelock), SendMessageBanned()]
+                ).puzzle_hash(nonce=0)
+                in unknown_inner_puzzle.unknown_puzzles,
+                genesis_challenge=genesis_challenge,
+            )
+        else:
+            custody = self_custody
+
+        return cls(
+            coin=Coin(
+                coin_spend.coin.name(),
+                puzzle_for_singleton(
+                    launcher_id=singleton_struct.launcher_id,
+                    inner_puz=custody.puzzle(nonce=0),
+                    # TODO: optimize
+                    singleton_mod=cls.singleton_mod,
+                    launcher_hash=cls.singleton_launcher.get_tree_hash(),
+                    singleton_mod_hash=cls.singleton_mod.get_tree_hash(),
+                ).get_tree_hash(),
+                coin_spend.coin.amount,
+            ),
+            singleton_lineage_proof=LineageProof(
+                parent_name=coin_spend.coin.parent_coin_info,
+                inner_puzzle_hash=inner_puzzle.get_tree_hash(),
+                amount=coin_spend.coin.amount,
+            ),
+            puzzle=PlotNFTPuzzle(
+                singleton_struct=singleton_struct,
+                inner_custody=custody,
+            ),
+        )
+
     def singleton_action_spend(self, inner_solution: Program) -> CoinSpend:
         return make_spend(
             coin=self.coin,

chia/wallet/conditions.py

@@ -229,26 +229,41 @@ class CreateCoin(Condition):
     puzzle_hash: bytes32
     amount: uint64
     memos: list[bytes] | None = None
+    memo_blob: Program | None = None
+
+    def __post_init__(self) -> None:
+        if self.memos is not None and self.memo_blob is not None:
+            raise ValueError("Cannot have both memos and memo_blob")
+        return super().__post_init__()
 
     def to_program(self) -> Program:
         condition_args = [ConditionOpcode.CREATE_COIN, self.puzzle_hash, self.amount]
         if self.memos is not None:
             condition_args.append(self.memos)
+        elif self.memo_blob is not None:
+            condition_args.append(self.memo_blob)
         condition: Program = Program.to(condition_args)
         return condition
 
     @classmethod
     def from_program(cls, program: Program) -> Self:
         potential_memos: Program = program.at("rrr")
-        return cls(
-            bytes32(program.at("rf").as_atom()),
-            uint64(program.at("rrf").as_int()),
-            (
-                None
-                if potential_memos == Program.NIL
-                else [memo.as_atom() for memo in potential_memos.at("f").as_iter()]
-            ),
-        )
+        try:
+            return cls(
+                bytes32(program.at("rf").as_atom()),
+                uint64(program.at("rrf").as_int()),
+                (
+                    None
+                    if potential_memos == Program.NIL
+                    else [memo.as_atom() for memo in potential_memos.at("f").as_iter()]
+                ),
+            )
+        except ValueError:  # a bit of a hack to avoid doing the heavy lifting of switching the memo usage everywhere
+            return cls(
+                bytes32(program.at("rf").as_atom()),
+                uint64(program.at("rrf").as_int()),
+                memo_blob=potential_memos.at("f"),
+            )
 
     def as_condition_args(self) -> list[bytes32 | uint64 | list[bytes] | None]:
         return [self.puzzle_hash, self.amount, self.memos]

chia/wallet/puzzles/custody/custody_architecture.py

@@ -226,6 +226,7 @@ class PuzzleWithRestrictions:
     nonce: int  # Arbitrary nonce to make otherwise identical custody arrangements have different puzzle hashes
     restrictions: list[Restriction[MemberOrDPuz]]
     puzzle: Puzzle
+    additional_memos: Program | None = None
     spec_namespace: ClassVar[str] = "inner_puzzle_chip?"
 
     def memo(self) -> Program:
@@ -253,11 +254,12 @@ def memo(self) -> Program:
         return Program.to(
             (
                 self.spec_namespace,
-                [
+                [  # TODO: this should be cons
                     self.nonce,
                     [hint.to_program() for hint in restriction_hints],
                     1 if isinstance(self.puzzle, MofN) else 0,
                     puzzle_hint.to_program(),
+                    self.additional_memos,
                 ],
             )
         )
@@ -266,7 +268,9 @@ def memo(self) -> Program:
     def from_memo(cls, memo: Program) -> PuzzleWithRestrictions:
         if memo.atom is not None or memo.first() != Program.to(cls.spec_namespace):
             raise ValueError("Attempting to parse a memo that does not belong to this spec")
-        nonce, restriction_hints_prog, further_branching_prog, puzzle_hint_prog = memo.rest().as_iter()
+        nonce, restriction_hints_prog, further_branching_prog, puzzle_hint_prog, additional_memos = (
+            memo.rest().as_iter()
+        )
         restriction_hints = [RestrictionHint.from_program(hint) for hint in restriction_hints_prog.as_iter()]
         further_branching = further_branching_prog != Program.to(None)
         if further_branching:
@@ -282,6 +286,7 @@ def from_memo(cls, memo: Program) -> PuzzleWithRestrictions:
             nonce=nonce.as_int(),
             restrictions=[UnknownRestriction(hint) for hint in restriction_hints],
             puzzle=puzzle,
+            additional_memos=additional_memos if additional_memos != Program.to(None) else None,
         )
 
     @property

chia/wallet/trading/offer.py

@@ -71,7 +71,7 @@ class NotarizedPayment(CreateCoin):
     def from_condition_and_nonce(cls, condition: Program, nonce: bytes32) -> NotarizedPayment:
         with_opcode: Program = Program.to((51, condition))  # Gotta do this because the super class is expecting it
         p = CreateCoin.from_program(with_opcode)
-        return cls(p.puzzle_hash, p.amount, p.memos, nonce)
+        return cls(p.puzzle_hash, p.amount, p.memos, nonce=nonce)
 
     def name(self) -> bytes32:
         return self.to_program().get_tree_hash()
@@ -123,7 +123,7 @@ def notarize_payments(
         for asset_id, payments in requested_payments.items():
             notarized_payments[asset_id] = []
             for p in payments:
-                notarized_payments[asset_id].append(NotarizedPayment(p.puzzle_hash, p.amount, p.memos, nonce))
+                notarized_payments[asset_id].append(NotarizedPayment(p.puzzle_hash, p.amount, p.memos, nonce=nonce))
 
         return notarized_payments