chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/did_wallet/did_wallet_puzzles.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Optional, Union
+
+from chia_rs import G1Element
+
+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
+from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.ints import uint64
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+from chia.wallet.singleton import (
+    SINGLETON_LAUNCHER_PUZZLE_HASH,
+    SINGLETON_LAUNCHER_PUZZLE_HASH_TREE_HASH,
+    SINGLETON_TOP_LAYER_MOD,
+    SINGLETON_TOP_LAYER_MOD_HASH,
+    SINGLETON_TOP_LAYER_MOD_HASH_TREE_HASH,
+    is_singleton,
+)
+from chia.wallet.util.curry_and_treehash import (
+    calculate_hash_of_quoted_mod_hash,
+    curry_and_treehash,
+    shatree_atom,
+    shatree_atom_list,
+    shatree_int,
+    shatree_pair,
+)
+
+DID_INNERPUZ_MOD = load_clvm_maybe_recompile(
+    "did_innerpuz.clsp", package_or_requirement="chia.wallet.did_wallet.puzzles"
+)
+DID_INNERPUZ_MOD_HASH = DID_INNERPUZ_MOD.get_tree_hash()
+DID_INNERPUZ_MOD_HASH_QUOTED = calculate_hash_of_quoted_mod_hash(DID_INNERPUZ_MOD_HASH)
+INTERMEDIATE_LAUNCHER_MOD = load_clvm_maybe_recompile(
+    "nft_intermediate_launcher.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles"
+)
+
+
+def create_innerpuz(
+    p2_puzzle_or_hash: Union[Program, bytes32],
+    recovery_list: list[bytes32],
+    num_of_backup_ids_needed: uint64,
+    launcher_id: bytes32,
+    metadata: Program = Program.to([]),
+    recovery_list_hash: Optional[Program] = None,
+) -> Program:
+    """
+    Create DID inner puzzle
+    :param p2_puzzle_or_hash: Standard P2 puzzle or hash
+    :param recovery_list: A list of DIDs used for the recovery
+    :param num_of_backup_ids_needed: Need how many DIDs for the recovery
+    :param launcher_id: ID of the launch coin
+    :param metadata: DID customized metadata
+    :param recovery_list_hash: Recovery list hash
+    :return: DID inner puzzle
+    Note: Receiving a standard P2 puzzle hash wouldn't calculate a valid puzzle, but
+    that can be useful if calling `.get_tree_hash_precalc()` on it.
+    """
+    backup_ids_hash: Union[Program, bytes32] = Program.to(recovery_list).get_tree_hash()
+    if recovery_list_hash is not None:
+        backup_ids_hash = recovery_list_hash
+    singleton_struct = Program.to((SINGLETON_TOP_LAYER_MOD_HASH, (launcher_id, SINGLETON_LAUNCHER_PUZZLE_HASH)))
+    return DID_INNERPUZ_MOD.curry(
+        p2_puzzle_or_hash, backup_ids_hash, num_of_backup_ids_needed, singleton_struct, metadata
+    )
+
+
+def get_inner_puzhash_by_p2(
+    p2_puzhash: bytes32,
+    recovery_list: list[bytes32],
+    num_of_backup_ids_needed: uint64,
+    launcher_id: bytes32,
+    metadata: Program = Program.to([]),
+) -> bytes32:
+    """
+    Calculate DID inner puzzle hash based on a P2 puzzle hash
+    :param p2_puzhash: P2 puzzle hash
+    :param recovery_list: A list of DIDs used for the recovery
+    :param num_of_backup_ids_needed: Need how many DIDs for the recovery
+    :param launcher_id: ID of the launch coin
+    :param metadata: DID customized metadata
+    :return: DID inner puzzle hash
+    """
+
+    backup_ids_hash = shatree_atom_list(recovery_list)
+
+    # singleton_struct = (MOD_HASH . (LAUNCHER_ID . LAUNCHER_PUZZLE_HASH))
+    singleton_struct = shatree_pair(
+        SINGLETON_TOP_LAYER_MOD_HASH_TREE_HASH,
+        shatree_pair(shatree_atom(launcher_id), SINGLETON_LAUNCHER_PUZZLE_HASH_TREE_HASH),
+    )
+
+    return curry_and_treehash(
+        DID_INNERPUZ_MOD_HASH_QUOTED,
+        p2_puzhash,
+        shatree_atom(backup_ids_hash),
+        shatree_int(num_of_backup_ids_needed),
+        singleton_struct,
+        metadata.get_tree_hash(),
+    )
+
+
+def is_did_innerpuz(inner_f: Program) -> bool:
+    """
+    Check if a puzzle is a DID inner mode
+    :param inner_f: puzzle
+    :return: Boolean
+    """
+    return inner_f == DID_INNERPUZ_MOD
+
+
+def uncurry_innerpuz(puzzle: Program) -> Optional[tuple[Program, Program, Program, Program, Program]]:
+    """
+    Uncurry a DID inner puzzle
+    :param puzzle: DID puzzle
+    :return: Curried parameters
+    """
+    r = puzzle.uncurry()
+    if r is None:
+        return r
+    inner_f, args = r
+    if not is_did_innerpuz(inner_f):
+        return None
+
+    p2_puzzle, id_list, num_of_backup_ids_needed, singleton_struct, metadata = list(args.as_iter())
+    return p2_puzzle, id_list, num_of_backup_ids_needed, singleton_struct, metadata
+
+
+def create_recovery_message_puzzle(recovering_coin_id: bytes32, newpuz: bytes32, pubkey: G1Element) -> Program:
+    """
+    Create attestment message puzzle
+    :param recovering_coin_id: ID of the DID coin needs to recover
+    :param newpuz: New wallet puzzle hash
+    :param pubkey: New wallet pubkey
+    :return: Message puzzle
+    """
+    puzzle = Program.to(
+        (
+            1,
+            [
+                [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, recovering_coin_id],
+                [ConditionOpcode.AGG_SIG_UNSAFE, bytes(pubkey), newpuz],
+            ],
+        )
+    )
+    return puzzle
+
+
+def create_spend_for_message(
+    parent_of_message: bytes32, recovering_coin: bytes32, newpuz: bytes32, pubkey: G1Element
+) -> CoinSpend:
+    """
+    Create a CoinSpend for a atestment
+    :param parent_of_message: Parent coin ID
+    :param recovering_coin: ID of the DID coin needs to recover
+    :param newpuz: New wallet puzzle hash
+    :param pubkey: New wallet pubkey
+    :return: CoinSpend
+    """
+    puzzle = create_recovery_message_puzzle(recovering_coin, newpuz, pubkey)
+    coin = Coin(parent_of_message, puzzle.get_tree_hash(), uint64(0))
+    solution = Program.to([])
+    return make_spend(coin, puzzle, solution)
+
+
+def match_did_puzzle(mod: Program, curried_args: Program) -> Optional[Iterator[Program]]:
+    """
+    Given a puzzle test if it's a DID, if it is, return the curried arguments
+    :param puzzle: Puzzle
+    :return: Curried parameters
+    """
+    try:
+        if mod == SINGLETON_TOP_LAYER_MOD:
+            mod, curried_args = curried_args.rest().first().uncurry()
+            if mod == DID_INNERPUZ_MOD:
+                return curried_args.as_iter()
+    except Exception:
+        import traceback
+
+        print(f"exception: {traceback.format_exc()}")
+    return None
+
+
+def check_is_did_puzzle(puzzle: Program) -> bool:
+    """
+    Check if a puzzle is a DID puzzle
+    :param puzzle: Puzzle
+    :return: Boolean
+    """
+    r = puzzle.uncurry()
+    if r is None:
+        return False
+    inner_f, _ = r
+    return is_singleton(inner_f)
+
+
+def metadata_to_program(metadata: dict[str, str]) -> Program:
+    """
+    Convert the metadata dict to a Chialisp program
+    :param metadata: User defined metadata
+    :return: Chialisp program
+    """
+    kv_list = []
+    for key, value in metadata.items():
+        kv_list.append((key, value))
+    return Program.to(kv_list)
+
+
+def did_program_to_metadata(program: Program) -> dict[str, str]:
+    """
+    Convert a program to a metadata dict
+    :param program: Chialisp program contains the metadata
+    :return: Metadata dict
+    """
+    metadata = {}
+    for key, val in program.as_python():
+        metadata[str(key, "utf-8")] = str(val, "utf-8")
+    return metadata

chia/wallet/did_wallet/puzzles/did_innerpuz.clsp

@@ -0,0 +1,135 @@
+; The DID innerpuzzle is designed to sit inside the singleton layer and provide functionality related to being an identity.
+; At the moment the two pieces of functionality are recovery and message creation.
+; A DID's ID is it's Singleton ID
+; Recovery is based around having a list of known other DIDs which can send messages approving you change the innerpuzzle of your DID singleton
+
+(mod
+  (
+    INNER_PUZZLE  ; Standard P2 inner puzzle, used to record the ownership of the DID.
+    RECOVERY_DID_LIST_HASH  ; the list of DIDs that can send messages to you for recovery we store only the hash so that we don't have to reveal every time we make a message spend
+    NUM_VERIFICATIONS_REQUIRED  ; how many of the above list are required for a recovery
+    SINGLETON_STRUCT  ; my singleton_struct, formerly a Truth - ((SINGLETON_MOD_HASH, (LAUNCHER_ID, LAUNCHER_PUZZLE_HASH)))
+    METADATA  ; Customized metadata, e.g KYC info
+    mode  ; this indicates which spend mode we want. 0. Recovery mode 1. Run INNER_PUZZLE with p2_solution
+    my_amount_or_inner_solution  ; In mode 0, we use this to recover our coin and assert it is our actual amount
+    ; In mode 1 this is the solution of the inner P2 puzzle, only required in the create message mode and transfer mode.
+    new_inner_puzhash  ; In recovery mode, this will be the new wallet DID puzzle hash
+    parent_innerpuzhash_amounts_for_recovery_ids  ; during a recovery we need extra information about our recovery list coins
+    pubkey  ; this is the new pubkey used for a recovery
+    recovery_list_reveal  ; this is the reveal of the stored list of DIDs approved for recovery
+    my_id  ; my coin ID
+  )
+  ;message is the new puzzle in the recovery and standard spend cases
+
+  ;MOD_HASH, MY_PUBKEY, RECOVERY_DID_LIST_HASH are curried into the puzzle
+  ;EXAMPLE SOLUTION (0xcafef00d 0x12341234 0x923bf9a7856b19d335a65f12d68957d497e1f0c16c0e14baf6d120e60753a1ce 2 1 100 (q "source code") 0xdeadbeef 0xcafef00d ((0xdadadada 0xdad5dad5 200) () (0xfafafafa 0xfaf5faf5 200)) 0xfadeddab (0x22222222 0x33333333 0x44444444))
+
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+
+  ; takes a lisp tree and returns the hash of it
+  (defun sha256tree1 (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree1 (f TREE)) (sha256tree1 (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  ; recovery message module - gets values curried in to make the puzzle
+  (defun make_message_puzzle (recovering_coin newpuz pubkey)
+    (qq (q . (((unquote CREATE_COIN_ANNOUNCEMENT) (unquote recovering_coin)) ((unquote AGG_SIG_UNSAFE) (unquote pubkey) (unquote newpuz)))))
+  )
+
+  ; this function creates the assert announcement for each message coin approving a recovery
+  (defun-inline create_consume_message (coin_id my_id new_innerpuz pubkey)
+    (list ASSERT_COIN_ANNOUNCEMENT (sha256 (sha256 coin_id (sha256tree1 (make_message_puzzle my_id new_innerpuz pubkey))) my_id))
+  )
+
+  ; this function calculates a coin ID given the inner puzzle and singleton information
+  (defun create_coin_ID_for_recovery (SINGLETON_STRUCT launcher_id parent innerpuzhash amount)
+    (sha256 parent (calculate_full_puzzle_hash (c (f SINGLETON_STRUCT) (c launcher_id (r (r SINGLETON_STRUCT)))) innerpuzhash) amount)
+  )
+
+
+  ; return the full puzzlehash for a singleton with the innerpuzzle curried in
+  ; puzzle-hash-of-curried-function is imported from curry-and-treehash.clib
+  (defun-inline calculate_full_puzzle_hash (SINGLETON_STRUCT inner_puzzle_hash)
+    (puzzle-hash-of-curried-function (f SINGLETON_STRUCT)
+      inner_puzzle_hash
+      (sha256tree1 SINGLETON_STRUCT)
+    )
+  )
+
+  ; this loops over our identities to check list, and checks if we have been given parent information for this identity
+  ; the reason for this is because we might only require 3/5 of the IDs give approval messages for a recovery
+  ; if we have the information for an identity then we create a consume message using that information
+
+  (defun check_messages_from_identities (SINGLETON_STRUCT num_verifications_required identities my_id  new_puz parent_innerpuzhash_amounts_for_recovery_ids pubkey num_verifications)
+    (if identities
+        (if (f parent_innerpuzhash_amounts_for_recovery_ids)
+            ; if we have parent information then we should create a consume coin condition
+            (c
+              (create_consume_message
+                ; create coin_id from DID
+                (create_coin_ID_for_recovery
+                  SINGLETON_STRUCT
+                  (f identities)
+                  (f (f parent_innerpuzhash_amounts_for_recovery_ids))
+                  (f (r (f parent_innerpuzhash_amounts_for_recovery_ids)))
+                (f (r (r (f parent_innerpuzhash_amounts_for_recovery_ids)))))
+                my_id
+                new_puz
+                pubkey
+              )
+              (check_messages_from_identities
+                SINGLETON_STRUCT
+                num_verifications_required
+                (r identities)
+                my_id
+                new_puz
+                (r parent_innerpuzhash_amounts_for_recovery_ids)
+                pubkey
+                (+ num_verifications 1)
+              )
+            )
+            ; if no parent information found for this identity, move on to next in list
+            (check_messages_from_identities
+              SINGLETON_STRUCT
+              (r identities)
+              my_id
+              new_puz
+              (r parent_innerpuzhash_amounts_for_recovery_ids)
+              pubkey
+              num_verifications
+            )
+        )
+        ;if we're out of identites to check for, check we have enough
+        (if (> num_verifications (- num_verifications_required 1))
+            (list (list AGG_SIG_UNSAFE pubkey new_puz) )
+            (x)
+        )
+    )
+  )
+
+  ;Spend modes:
+  ;0 = recovery
+  ;1 = run the INNER_PUZZLE
+
+  ;MAIN
+  (if mode
+      ; mode 1 - run INNER_PUZZLE
+      (a INNER_PUZZLE my_amount_or_inner_solution)
+
+      ; mode 0 - recovery
+      (if (all (= (sha256tree1 recovery_list_reveal) RECOVERY_DID_LIST_HASH) (> NUM_VERIFICATIONS_REQUIRED 0))
+          (c (list ASSERT_MY_AMOUNT my_amount_or_inner_solution)
+            (c (list CREATE_COIN new_inner_puzhash my_amount_or_inner_solution (list new_inner_puzhash))
+              (c (list ASSERT_MY_COIN_ID my_id)
+                (check_messages_from_identities SINGLETON_STRUCT NUM_VERIFICATIONS_REQUIRED recovery_list_reveal my_id new_inner_puzhash parent_innerpuzhash_amounts_for_recovery_ids pubkey 0)
+              )
+            )
+          )
+          (x)
+      )
+  )
+)

chia/wallet/did_wallet/puzzles/did_innerpuz.clsp.hex

@@ -0,0 +1 @@
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

chia/wallet/driver_protocol.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from typing_extensions import Protocol
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
+from chia.wallet.uncurried_puzzle import UncurriedPuzzle
+
+
+class DriverProtocol(Protocol):
+    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]: ...
+
+    def get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]: ...
+
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]: ...
+
+    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]: ...
+
+    def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program: ...
+
+    def solve(
+        self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program
+    ) -> Program: ...

chia/wallet/key_val_store.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Any
+
+from chia.util.db_wrapper import DBWrapper2
+
+
+class KeyValStore:
+    """
+    Multipurpose persistent key-value store
+    """
+
+    db_wrapper: DBWrapper2
+
+    @classmethod
+    async def create(cls, db_wrapper: DBWrapper2):
+        self = cls()
+        self.db_wrapper = db_wrapper
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            await conn.execute("CREATE TABLE IF NOT EXISTS key_val_store(key text PRIMARY KEY, value blob)")
+            # Remove an old redundant index on the primary key
+            # See https://github.com/Chia-Network/chia-blockchain/issues/10276
+            await conn.execute("DROP INDEX IF EXISTS key_val_name")
+        return self
+
+    async def get_object(self, key: str, object_type: Any) -> Any:
+        """
+        Return bytes representation of stored object
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            cursor = await conn.execute("SELECT value from key_val_store WHERE key=?", (key,))
+            row = await cursor.fetchone()
+            await cursor.close()
+
+        if row is None:
+            return None
+
+        return object_type.from_bytes(row[0])
+
+    async def set_object(self, key: str, obj: Any):
+        """
+        Adds object to key val store. Obj MUST support __bytes__ and bytes() methods.
+        """
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute(
+                "INSERT OR REPLACE INTO key_val_store VALUES(?, ?)",
+                (key, obj.stream_to_bytes()),
+            )
+            await cursor.close()
+
+    async def remove_object(self, key: str):
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute("DELETE FROM key_val_store where key=?", (key,))
+            await cursor.close()

chia/wallet/lineage_proof.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Optional
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+from chia.util.streamable import Streamable, streamable
+
+
+class LineageProofField(Enum):
+    PARENT_NAME = 1
+    INNER_PUZZLE_HASH = 2
+    AMOUNT = 3
+
+
+@streamable
+@dataclass(frozen=True)
+class LineageProof(Streamable):
+    parent_name: Optional[bytes32] = None
+    inner_puzzle_hash: Optional[bytes32] = None
+    amount: Optional[uint64] = None
+
+    @classmethod
+    def from_program(cls, program: Program, fields: list[LineageProofField]) -> LineageProof:
+        lineage_proof_info: dict[str, Any] = {}
+        field_iter = iter(fields)
+        program_iter = program.as_iter()
+        for program_value in program_iter:
+            field = next(field_iter)
+            if field == LineageProofField.PARENT_NAME:
+                lineage_proof_info["parent_name"] = bytes32(program_value.as_atom())
+            elif field == LineageProofField.INNER_PUZZLE_HASH:
+                lineage_proof_info["inner_puzzle_hash"] = bytes32(program_value.as_atom())
+            elif field == LineageProofField.AMOUNT:
+                lineage_proof_info["amount"] = uint64(program_value.as_int())
+        try:
+            next(field_iter)
+            raise ValueError("Mismatch between program data and fields information")
+        except StopIteration:
+            pass
+
+        return LineageProof(**lineage_proof_info)
+
+    def to_program(self) -> Program:
+        final_list: list[Any] = []
+        if self.parent_name is not None:
+            final_list.append(self.parent_name)
+        if self.inner_puzzle_hash is not None:
+            final_list.append(self.inner_puzzle_hash)
+        if self.amount is not None:
+            final_list.append(self.amount)
+        return Program.to(final_list)
+
+    def is_none(self) -> bool:
+        return all([self.parent_name is None, self.inner_puzzle_hash is None, self.amount is None])

chia/wallet/nft_wallet/metadata_outer_puzzle.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
+
+NFT_STATE_LAYER_MOD = load_clvm_maybe_recompile(
+    "nft_state_layer.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles"
+)
+NFT_STATE_LAYER_MOD_HASH = NFT_STATE_LAYER_MOD.get_tree_hash()
+
+
+def match_metadata_layer_puzzle(puzzle: UncurriedPuzzle) -> tuple[bool, list[Program]]:
+    if puzzle.mod == NFT_STATE_LAYER_MOD:
+        return True, list(puzzle.args.as_iter())
+    return False, []
+
+
+def puzzle_for_metadata_layer(metadata: Program, updater_hash: bytes32, inner_puzzle: Program) -> Program:
+    return NFT_STATE_LAYER_MOD.curry(NFT_STATE_LAYER_MOD_HASH, metadata, updater_hash, inner_puzzle)
+
+
+def solution_for_metadata_layer(inner_solution: Program) -> Program:
+    return Program.to([inner_solution])
+
+
+@dataclass(frozen=True)
+class MetadataOuterPuzzle:
+    _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
+    _construct: Callable[[PuzzleInfo, Program], Program]
+    _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle], Optional[Program]]
+    _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
+
+    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+        matched, curried_args = match_metadata_layer_puzzle(puzzle)
+        if matched:
+            _, metadata, updater_hash, inner_puzzle = curried_args
+            constructor_dict = {
+                "type": "metadata",
+                "metadata": metadata,
+                "updater_hash": "0x" + updater_hash.as_atom().hex(),
+            }
+            next_constructor = self._match(uncurry_puzzle(inner_puzzle))
+            if next_constructor is not None:
+                constructor_dict["also"] = next_constructor.info
+            return PuzzleInfo(constructor_dict)
+        else:
+            return None
+        return None  # Uncomment above when match_metadata_layer_puzzle works
+
+    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+        return bytes32(constructor["updater_hash"])
+
+    def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
+        also = constructor.also()
+        if also is not None:
+            inner_puzzle = self._construct(also, inner_puzzle)
+        return puzzle_for_metadata_layer(constructor["metadata"], constructor["updater_hash"], inner_puzzle)
+
+    def get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
+        matched, curried_args = match_metadata_layer_puzzle(puzzle_reveal)
+        if matched:
+            _, _, _, inner_puzzle = curried_args
+            also = constructor.also()
+            if also is not None:
+                deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle))
+                return deep_inner_puzzle
+            else:
+                return inner_puzzle
+        else:
+            raise ValueError("This driver is not for the specified puzzle reveal")
+
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+        my_inner_solution: Program = solution.first()
+        also = constructor.also()
+        if also:
+            deep_inner_solution: Optional[Program] = self._get_inner_solution(also, my_inner_solution)
+            return deep_inner_solution
+        else:
+            return my_inner_solution
+
+    def solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
+        also = constructor.also()
+        if also is not None:
+            inner_solution = self._solve(also, solver, inner_puzzle, inner_solution)
+        return solution_for_metadata_layer(inner_solution)