Merge DID into main (Chia-Network#1720)

* rebase DID off main

* fix indentation and imports

* lint fixes

* fix test_compilation paths for new puzzles

* added _init__.py for did_wallet

* mypy typing fixes

* included did_wallet in setup.py module list

* stored pubkey & puzhash so that recovery_spend can choose not take them

* black missing comma

.gitignore

@@ -80,6 +80,9 @@ vdf_bench
 # Backup Files
 *.backup
 
+# Attest Files
+*.attest
+
 # Compiled CLVM
 main.sym
 *.recompiled

chia/rpc/wallet_rpc_api.py

@@ -4,7 +4,7 @@
 from pathlib import Path
 from typing import Callable, Dict, List, Optional, Tuple
 
-from blspy import PrivateKey
+from blspy import PrivateKey, G1Element
 
 from chia.cmds.init_funcs import check_keys
 from chia.consensus.block_rewards import calculate_base_farmer_reward
@@ -22,6 +22,7 @@
 from chia.util.ws_message import WsRpcMessage, create_payload_dict
 from chia.wallet.cc_wallet.cc_wallet import CCWallet
 from chia.wallet.rl_wallet.rl_wallet import RLWallet
+from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.backup_utils import download_backup, get_backup_info, upload_backup
@@ -83,6 +84,16 @@ def get_routes(self) -> Dict[str, Callable]:
             "/get_trade": self.get_trade,
             "/get_all_trades": self.get_all_trades,
             "/cancel_trade": self.cancel_trade,
+            # DID Wallet
+            "/did_update_recovery_ids": self.did_update_recovery_ids,
+            "/did_spend": self.did_spend,
+            "/did_get_pubkey": self.did_get_pubkey,
+            "/did_get_did": self.did_get_did,
+            "/did_recovery_spend": self.did_recovery_spend,
+            "/did_get_recovery_list": self.did_get_recovery_list,
+            "/did_create_attest": self.did_create_attest,
+            "/did_get_information_needed_for_recovery": self.did_get_information_needed_for_recovery,
+            "/did_create_backup_file": self.did_create_backup_file,
             # RL wallet
             "/rl_set_user_info": self.rl_set_user_info,
             "/send_clawback_transaction:": self.send_clawback_transaction,
@@ -336,7 +347,7 @@ async def create_new_wallet(self, request: Dict):
                 cc_wallet = await CCWallet.create_wallet_for_cc(wallet_state_manager, main_wallet, request["colour"])
                 asyncio.create_task(self._create_backup_and_upload(host))
                 return {"type": cc_wallet.type()}
-        if request["wallet_type"] == "rl_wallet":
+        elif request["wallet_type"] == "rl_wallet":
             if request["rl_type"] == "admin":
                 log.info("Create rl admin wallet")
                 rl_admin: RLWallet = await RLWallet.create_rl_admin(wallet_state_manager)
@@ -366,6 +377,55 @@ async def create_new_wallet(self, request: Dict):
                     "type": rl_user.type(),
                     "pubkey": rl_user.rl_info.user_pubkey.hex(),
                 }
+        elif request["wallet_type"] == "did_wallet":
+            try:
+                if request["did_type"] == "new":
+                    backup_dids = []
+                    num_needed = 0
+                    for d in request["backup_dids"]:
+                        backup_dids.append(hexstr_to_bytes(d))
+                    if len(backup_dids) > 0:
+                        num_needed = uint64(request["num_of_backup_ids_needed"])
+                    did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
+                        wallet_state_manager,
+                        main_wallet,
+                        int(request["amount"]),
+                        backup_dids,
+                        uint64(num_needed),
+                    )
+                    my_did = did_wallet.get_my_DID()
+                    return {
+                        "success": True,
+                        "type": did_wallet.type(),
+                        "my_did": my_did,
+                        "wallet_id": did_wallet.id(),
+                    }
+                elif request["did_type"] == "recovery":
+                    did_wallet = await DIDWallet.create_new_did_wallet_from_recovery(
+                        wallet_state_manager, main_wallet, request["filename"]
+                    )
+                    assert did_wallet.did_info.temp_coin is not None
+                    assert did_wallet.did_info.temp_puzhash is not None
+                    assert did_wallet.did_info.temp_pubkey is not None
+                    my_did = did_wallet.get_my_DID()
+                    coin_name = did_wallet.did_info.temp_coin.name().hex()
+                    coin_list = did_wallet.did_info.temp_coin.as_list()
+                    newpuzhash = did_wallet.did_info.temp_puzhash
+                    pubkey = did_wallet.did_info.temp_pubkey
+                    return {
+                        "success": True,
+                        "type": did_wallet.type(),
+                        "my_did": my_did,
+                        "wallet_id": did_wallet.id(),
+                        "coin_name": coin_name,
+                        "coin_list": coin_list,
+                        "newpuzhash": newpuzhash.hex(),
+                        "pubkey": pubkey.hex(),
+                        "backup_dids": did_wallet.did_info.backup_ids,
+                        "num_verifications_required": did_wallet.did_info.num_of_backup_ids_needed,
+                    }
+            except Exception as e:
+                return {"success": False, "reason": e}
 
     ##########################################################################################
     # Wallet
@@ -395,7 +455,7 @@ async def get_wallet_balance(self, request: Dict) -> Dict:
 
     async def get_transaction(self, request: Dict) -> Dict:
         assert self.service.wallet_state_manager is not None
-        transaction_id: bytes32 = bytes32(bytes.fromhex(request["transaction_id"]))
+        transaction_id: bytes32 = bytes32(hexstr_to_bytes(request["transaction_id"]))
         tr: Optional[TransactionRecord] = await self.service.wallet_state_manager.get_transaction(transaction_id)
         if tr is None:
             raise ValueError(f"Transaction 0x{transaction_id.hex()} not found")
@@ -659,6 +719,144 @@ async def get_backup_info(self, request: Dict):
         backup_info = get_backup_info(file_path, sk)
         return {"backup_info": backup_info}
 
+    ##########################################################################################
+    # Distributed Identities
+    ##########################################################################################
+
+    async def did_update_recovery_ids(self, request):
+        wallet_id = int(request["wallet_id"])
+        wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+        recovery_list = []
+        for _ in request["new_list"]:
+            recovery_list.append(hexstr_to_bytes(_))
+        if "num_verifications_required" in request:
+            new_amount_verifications_required = uint64(request["num_verifications_required"])
+        else:
+            new_amount_verifications_required = len(recovery_list)
+        success = await wallet.update_recovery_list(recovery_list, new_amount_verifications_required)
+        # Update coin with new ID info
+        updated_puz = await wallet.get_new_puzzle()
+        spend_bundle = await wallet.create_spend(updated_puz.get_tree_hash())
+        if spend_bundle is not None and success:
+            return {"success": True}
+        return {"success": False}
+
+    async def did_spend(self, request):
+        wallet_id = int(request["wallet_id"])
+        wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+        spend_bundle = await wallet.create_spend(request["puzzlehash"])
+        if spend_bundle is not None:
+            return {"success": True}
+        return {"success": False}
+
+    async def did_get_did(self, request):
+        wallet_id = int(request["wallet_id"])
+        wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+        my_did: str = wallet.get_my_DID()
+        coins = await wallet.select_coins(1)
+        if coins is None or coins == set():
+            return {"success": True, "wallet_id": wallet_id, "my_did": my_did}
+        else:
+            coin = coins.pop()
+            return {"success": True, "wallet_id": wallet_id, "my_did": my_did, "coin_id": coin.name()}
+
+    async def did_get_recovery_list(self, request):
+        wallet_id = int(request["wallet_id"])
+        wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+        recovery_list = wallet.did_info.backup_ids
+        recover_hex_list = []
+        for _ in recovery_list:
+            recover_hex_list.append(_.hex())
+        return {
+            "success": True,
+            "wallet_id": wallet_id,
+            "recover_list": recover_hex_list,
+            "num_required": wallet.did_info.num_of_backup_ids_needed,
+        }
+
+    async def did_recovery_spend(self, request):
+        wallet_id = int(request["wallet_id"])
+        wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+        if len(request["attest_filenames"]) < wallet.did_info.num_of_backup_ids_needed:
+            return {"success": False, "reason": "insufficient messages"}
+
+        (
+            info_list,
+            message_spend_bundle,
+        ) = await wallet.load_attest_files_for_recovery_spend(request["attest_filenames"])
+
+        if "pubkey" in request:
+            pubkey = G1Element.from_bytes(hexstr_to_bytes(request["pubkey"]))
+        else:
+            assert wallet.did_info.temp_pubkey is not None
+            pubkey = wallet.did_info.temp_pubkey
+
+        if "puzhash" in request:
+            puzhash = hexstr_to_bytes(request["puzhash"])
+        else:
+            assert wallet.did_info.temp_puzhash is not None
+            puzhash = wallet.did_info.temp_puzhash
+
+        success = await wallet.recovery_spend(
+            wallet.did_info.temp_coin,
+            puzhash,
+            info_list,
+            pubkey,
+            message_spend_bundle,
+        )
+        return {"success": success}
+
+    async def did_get_pubkey(self, request):
+        wallet_id = int(request["wallet_id"])
+        wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+        pubkey = bytes((await wallet.wallet_state_manager.get_unused_derivation_record(wallet_id)).pubkey).hex()
+        return {"success": True, "pubkey": pubkey}
+
+    async def did_create_attest(self, request):
+        wallet_id = int(request["wallet_id"])
+        wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+        info = await wallet.get_info_for_recovery()
+        coin = hexstr_to_bytes(request["coin_name"])
+        pubkey = G1Element.from_bytes(hexstr_to_bytes(request["pubkey"]))
+        spend_bundle = await wallet.create_attestment(
+            coin, hexstr_to_bytes(request["puzhash"]), pubkey, request["filename"]
+        )
+        if spend_bundle is not None:
+            return {
+                "success": True,
+                "message_spend_bundle": bytes(spend_bundle).hex(),
+                "info": [info[0].hex(), info[1].hex(), info[2]],
+            }
+        else:
+            return {"success": False}
+
+    async def did_get_information_needed_for_recovery(self, request):
+        wallet_id = int(request["wallet_id"])
+        did_wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+        my_did = did_wallet.get_my_DID()
+        coin_name = did_wallet.did_info.temp_coin.name().hex()
+        newpuzhash = (await did_wallet.get_new_puzzle()).get_tree_hash().hex()
+        pubkey = bytes(
+            (await self.service.wallet_state_manager.get_unused_derivation_record(did_wallet.wallet_info.id)).pubkey
+        ).hex()
+        return {
+            "success": True,
+            "my_did": my_did,
+            "coin_name": coin_name,
+            "newpuzhash": newpuzhash,
+            "pubkey": pubkey,
+            "backup_dids": did_wallet.did_info.backup_ids,
+        }
+
+    async def did_create_backup_file(self, request):
+        try:
+            wallet_id = int(request["wallet_id"])
+            did_wallet: DIDWallet = self.service.wallet_state_manager.wallets[wallet_id]
+            did_wallet.create_backup(request["filename"])
+            return {"success": True}
+        except Exception:
+            return {"success": False}
+
     ##########################################################################################
     # Rate Limited Wallet
     ##########################################################################################

chia/util/streamable.py

@@ -59,7 +59,13 @@ def dataclass_from_dict(klass, d):
             return None
         return dataclass_from_dict(get_args(klass)[0], d)
     elif is_type_Tuple(klass):
-        return tuple(dataclass_from_dict(get_args(klass)[0], item) for item in d)
+        # Type is tuple, can have multiple different types inside
+        i = 0
+        klass_properties = []
+        for item in d:
+            klass_properties.append(dataclass_from_dict(klass.__args__[i], item))
+            i = i + 1
+        return tuple(klass_properties)
     elif dataclasses.is_dataclass(klass):
         # Type is a dataclass, data is a dictionary
         fieldtypes = {f.name: f.type for f in dataclasses.fields(klass)}
@@ -83,7 +89,7 @@ def recurse_jsonify(d):
     Makes bytes objects and unhashable types into strings with 0x, and makes large ints into
     strings.
     """
-    if isinstance(d, list):
+    if isinstance(d, list) or isinstance(d, tuple):
         new_list = []
         for item in d:
             if type(item) in unhashable_types or issubclass(type(item), bytes):
@@ -92,6 +98,8 @@ def recurse_jsonify(d):
                 item = recurse_jsonify(item)
             if isinstance(item, list):
                 item = recurse_jsonify(item)
+            if isinstance(item, tuple):
+                item = recurse_jsonify(item)
             if isinstance(item, Enum):
                 item = item.name
             if isinstance(item, int) and type(item) in big_ints:
@@ -107,6 +115,8 @@ def recurse_jsonify(d):
                 d[key] = recurse_jsonify(value)
             if isinstance(value, list):
                 d[key] = recurse_jsonify(value)
+            if isinstance(value, tuple):
+                d[key] = recurse_jsonify(value)
             if isinstance(value, Enum):
                 d[key] = value.name
             if isinstance(value, int) and type(value) in big_ints:

chia/wallet/did_wallet/did_info.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+from chia.util.streamable import streamable, Streamable
+from chia.wallet.cc_wallet.ccparent import CCParent
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.coin import Coin
+
+
+@dataclass(frozen=True)
+@streamable
+class DIDInfo(Streamable):
+    my_did: Optional[bytes]
+    backup_ids: List[bytes]
+    num_of_backup_ids_needed: uint64
+    parent_info: List[Tuple[bytes32, Optional[CCParent]]]  # {coin.name(): CCParent}
+    current_inner: Optional[Program]  # represents a Program as bytes
+    temp_coin: Optional[Coin]  # partially recovered wallet uses these to hold info
+    temp_puzhash: Optional[bytes32]
+    temp_pubkey: Optional[bytes]