Merge DID into main (#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
This commit is contained in:
matt-o-how
GitHub
parent
b3f70a1c68
commit
5e1bf6d5f3
|
|
@ -80,6 +80,9 @@ vdf_bench
|
|||
# Backup Files
|
||||
*.backup
|
||||
|
||||
# Attest Files
|
||||
*.attest
|
||||
|
||||
# Compiled CLVM
|
||||
main.sym
|
||||
*.recompiled
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ import time
|
|||
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.path import path_from_root
|
|||
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 @@ class WalletRpcApi:
|
|||
"/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 @@ class WalletRpcApi:
|
|||
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 @@ class WalletRpcApi:
|
|||
"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 @@ class WalletRpcApi:
|
|||
|
||||
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 @@ class WalletRpcApi:
|
|||
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
|
||||
##########################################################################################
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
|
@ -0,0 +1,858 @@
|
|||
import logging
|
||||
import time
|
||||
import json
|
||||
|
||||
from typing import Dict, Optional, List, Any, Set, Tuple, Union
|
||||
|
||||
from blspy import AugSchemeMPL, G1Element
|
||||
from secrets import token_bytes
|
||||
from chia.protocols import wallet_protocol
|
||||
from chia.protocols.wallet_protocol import RespondAdditions, RejectAdditionsRequest
|
||||
from chia.server.outbound_message import NodeType
|
||||
from chia.types.blockchain_format.coin import Coin
|
||||
from chia.types.coin_solution import CoinSolution
|
||||
|
||||
from chia.types.blockchain_format.program import Program
|
||||
from chia.types.spend_bundle import SpendBundle
|
||||
from chia.types.blockchain_format.sized_bytes import bytes32
|
||||
from chia.wallet.util.transaction_type import TransactionType
|
||||
from chia.util.ints import uint64, uint32, uint8
|
||||
|
||||
from chia.wallet.did_wallet.did_info import DIDInfo
|
||||
from chia.wallet.cc_wallet.ccparent import CCParent
|
||||
from chia.wallet.transaction_record import TransactionRecord
|
||||
from chia.wallet.util.wallet_types import WalletType
|
||||
from chia.wallet.wallet import Wallet
|
||||
from chia.wallet.wallet_coin_record import WalletCoinRecord
|
||||
from chia.wallet.wallet_info import WalletInfo
|
||||
from chia.wallet.derivation_record import DerivationRecord
|
||||
from chia.wallet.did_wallet import did_wallet_puzzles
|
||||
from chia.wallet.derive_keys import master_sk_to_wallet_sk
|
||||
|
||||
|
||||
class DIDWallet:
|
||||
wallet_state_manager: Any
|
||||
log: logging.Logger
|
||||
wallet_info: WalletInfo
|
||||
did_info: DIDInfo
|
||||
standard_wallet: Wallet
|
||||
base_puzzle_program: Optional[bytes]
|
||||
base_inner_puzzle_hash: Optional[bytes32]
|
||||
wallet_id: int
|
||||
|
||||
@staticmethod
|
||||
async def create_new_did_wallet(
|
||||
wallet_state_manager: Any,
|
||||
wallet: Wallet,
|
||||
amount: int,
|
||||
backups_ids: List = [],
|
||||
num_of_backup_ids_needed: uint64 = None,
|
||||
name: str = None,
|
||||
):
|
||||
if amount & 1 == 0:
|
||||
raise ValueError("DID amount must be odd number")
|
||||
self = DIDWallet()
|
||||
self.base_puzzle_program = None
|
||||
self.base_inner_puzzle_hash = None
|
||||
self.standard_wallet = wallet
|
||||
if name:
|
||||
self.log = logging.getLogger(name)
|
||||
else:
|
||||
self.log = logging.getLogger(__name__)
|
||||
|
||||
self.wallet_state_manager = wallet_state_manager
|
||||
if num_of_backup_ids_needed is None:
|
||||
num_of_backup_ids_needed = uint64(len(backups_ids))
|
||||
if num_of_backup_ids_needed > len(backups_ids):
|
||||
raise ValueError("Cannot require more IDs than are known.")
|
||||
self.did_info = DIDInfo(None, backups_ids, num_of_backup_ids_needed, [], None, None, None, None)
|
||||
info_as_string = json.dumps(self.did_info.to_json_dict())
|
||||
self.wallet_info = await wallet_state_manager.user_store.create_wallet(
|
||||
"DID Wallet", WalletType.DISTRIBUTED_ID.value, info_as_string
|
||||
)
|
||||
if self.wallet_info is None:
|
||||
raise ValueError("Internal Error")
|
||||
self.wallet_id = self.wallet_info.id
|
||||
bal = await self.standard_wallet.get_confirmed_balance()
|
||||
if amount > bal:
|
||||
raise ValueError("Not enough balance")
|
||||
|
||||
spend_bundle = await self.generate_new_decentralised_id(uint64(amount))
|
||||
if spend_bundle is None:
|
||||
raise ValueError("failed to generate ID for wallet")
|
||||
await self.wallet_state_manager.add_new_wallet(self, self.wallet_info.id)
|
||||
|
||||
did_puzzle_hash = did_wallet_puzzles.create_fullpuz(
|
||||
self.did_info.current_inner, self.did_info.my_did
|
||||
).get_tree_hash()
|
||||
|
||||
did_record = TransactionRecord(
|
||||
confirmed_at_height=uint32(0),
|
||||
created_at_time=uint64(int(time.time())),
|
||||
to_puzzle_hash=did_puzzle_hash,
|
||||
amount=uint64(amount),
|
||||
fee_amount=uint64(0),
|
||||
confirmed=False,
|
||||
sent=uint32(10),
|
||||
spend_bundle=None,
|
||||
additions=spend_bundle.additions(),
|
||||
removals=spend_bundle.removals(),
|
||||
wallet_id=self.id(),
|
||||
sent_to=[],
|
||||
trade_id=None,
|
||||
type=uint32(TransactionType.INCOMING_TX.value),
|
||||
name=token_bytes(),
|
||||
)
|
||||
regular_record = TransactionRecord(
|
||||
confirmed_at_height=uint32(0),
|
||||
created_at_time=uint64(int(time.time())),
|
||||
to_puzzle_hash=did_puzzle_hash,
|
||||
amount=uint64(amount),
|
||||
fee_amount=uint64(0),
|
||||
confirmed=False,
|
||||
sent=uint32(0),
|
||||
spend_bundle=spend_bundle,
|
||||
additions=spend_bundle.additions(),
|
||||
removals=spend_bundle.removals(),
|
||||
wallet_id=self.wallet_state_manager.main_wallet.id(),
|
||||
sent_to=[],
|
||||
trade_id=None,
|
||||
type=uint32(TransactionType.OUTGOING_TX.value),
|
||||
name=token_bytes(),
|
||||
)
|
||||
await self.standard_wallet.push_transaction(regular_record)
|
||||
await self.standard_wallet.push_transaction(did_record)
|
||||
return self
|
||||
|
||||
@staticmethod
|
||||
async def create_new_did_wallet_from_recovery(
|
||||
wallet_state_manager: Any,
|
||||
wallet: Wallet,
|
||||
filename: str,
|
||||
name: str = None,
|
||||
):
|
||||
self = DIDWallet()
|
||||
self.base_puzzle_program = None
|
||||
self.base_inner_puzzle_hash = None
|
||||
self.standard_wallet = wallet
|
||||
if name:
|
||||
self.log = logging.getLogger(name)
|
||||
else:
|
||||
self.log = logging.getLogger(__name__)
|
||||
|
||||
self.wallet_state_manager = wallet_state_manager
|
||||
self.did_info = DIDInfo(None, [], uint64(0), [], None, None, None, None)
|
||||
info_as_string = json.dumps(self.did_info.to_json_dict())
|
||||
self.wallet_info = await wallet_state_manager.user_store.create_wallet(
|
||||
"DID Wallet", WalletType.DISTRIBUTED_ID.value, info_as_string
|
||||
)
|
||||
await self.wallet_state_manager.add_new_wallet(self, self.wallet_info.id)
|
||||
# load backup will also set our DIDInfo
|
||||
await self.load_backup(filename)
|
||||
|
||||
if self.wallet_info is None:
|
||||
raise ValueError("Internal Error")
|
||||
self.wallet_id = self.wallet_info.id
|
||||
return self
|
||||
|
||||
@staticmethod
|
||||
async def create(
|
||||
wallet_state_manager: Any,
|
||||
wallet: Wallet,
|
||||
wallet_info: WalletInfo,
|
||||
name: str = None,
|
||||
):
|
||||
self = DIDWallet()
|
||||
|
||||
if name:
|
||||
self.log = logging.getLogger(name)
|
||||
else:
|
||||
self.log = logging.getLogger(__name__)
|
||||
|
||||
self.wallet_state_manager = wallet_state_manager
|
||||
self.wallet_info = wallet_info
|
||||
self.wallet_id = wallet_info.id
|
||||
self.standard_wallet = wallet
|
||||
self.wallet_info = wallet_info
|
||||
self.did_info = DIDInfo.from_json_dict(json.loads(wallet_info.data))
|
||||
self.base_puzzle_program = None
|
||||
self.base_inner_puzzle_hash = None
|
||||
return self
|
||||
|
||||
@classmethod
|
||||
def type(cls) -> uint8:
|
||||
return uint8(WalletType.DISTRIBUTED_ID)
|
||||
|
||||
def id(self):
|
||||
return self.wallet_info.id
|
||||
|
||||
async def get_confirmed_balance(self, record_list=None) -> uint64:
|
||||
if record_list is None:
|
||||
record_list = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(self.id())
|
||||
|
||||
amount: uint64 = uint64(0)
|
||||
for record in record_list:
|
||||
parent = await self.get_parent_for_coin(record.coin)
|
||||
if parent is not None:
|
||||
amount = uint64(amount + record.coin.amount)
|
||||
|
||||
self.log.info(f"Confirmed balance for did wallet is {amount}")
|
||||
return uint64(amount)
|
||||
|
||||
async def get_pending_change_balance(self) -> uint64:
|
||||
unconfirmed_tx = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(self.id())
|
||||
addition_amount = 0
|
||||
|
||||
for record in unconfirmed_tx:
|
||||
our_spend = False
|
||||
for coin in record.removals:
|
||||
if await self.wallet_state_manager.does_coin_belong_to_wallet(coin, self.id()):
|
||||
our_spend = True
|
||||
break
|
||||
|
||||
if our_spend is not True:
|
||||
continue
|
||||
|
||||
for coin in record.additions:
|
||||
if await self.wallet_state_manager.does_coin_belong_to_wallet(coin, self.id()):
|
||||
addition_amount += coin.amount
|
||||
|
||||
return uint64(addition_amount)
|
||||
|
||||
async def get_unconfirmed_balance(self, record_list=None) -> uint64:
|
||||
confirmed = await self.get_confirmed_balance(record_list)
|
||||
unconfirmed_tx: List[TransactionRecord] = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(
|
||||
self.wallet_info.id
|
||||
)
|
||||
addition_amount = 0
|
||||
removal_amount = 0
|
||||
|
||||
for record in unconfirmed_tx:
|
||||
if record.type == TransactionType.INCOMING_TX:
|
||||
addition_amount += record.amount
|
||||
else:
|
||||
removal_amount += record.amount
|
||||
|
||||
result = confirmed - removal_amount + addition_amount
|
||||
|
||||
self.log.info(f"Unconfirmed balance for did wallet is {result}")
|
||||
return uint64(result)
|
||||
|
||||
async def select_coins(self, amount, exclude: List[Coin] = None) -> Optional[Set[Coin]]:
|
||||
""" Returns a set of coins that can be used for generating a new transaction. """
|
||||
async with self.wallet_state_manager.lock:
|
||||
if exclude is None:
|
||||
exclude = []
|
||||
|
||||
spendable_amount = await self.get_spendable_balance()
|
||||
if amount > spendable_amount:
|
||||
self.log.warning(f"Can't select {amount}, from spendable {spendable_amount} for wallet id {self.id()}")
|
||||
return None
|
||||
|
||||
self.log.info(f"About to select coins for amount {amount}")
|
||||
unspent: List[WalletCoinRecord] = list(
|
||||
await self.wallet_state_manager.get_spendable_coins_for_wallet(self.wallet_info.id)
|
||||
)
|
||||
sum_value = 0
|
||||
used_coins: Set = set()
|
||||
|
||||
# Use older coins first
|
||||
unspent.sort(key=lambda r: r.confirmed_block_height)
|
||||
|
||||
# Try to use coins from the store, if there isn't enough of "unused"
|
||||
# coins use change coins that are not confirmed yet
|
||||
unconfirmed_removals: Dict[bytes32, Coin] = await self.wallet_state_manager.unconfirmed_removals_for_wallet(
|
||||
self.wallet_info.id
|
||||
)
|
||||
for coinrecord in unspent:
|
||||
if sum_value >= amount and len(used_coins) > 0:
|
||||
break
|
||||
if coinrecord.coin.name() in unconfirmed_removals:
|
||||
continue
|
||||
if coinrecord.coin in exclude:
|
||||
continue
|
||||
sum_value += coinrecord.coin.amount
|
||||
used_coins.add(coinrecord.coin)
|
||||
|
||||
# This happens when we couldn't use one of the coins because it's already used
|
||||
# but unconfirmed, and we are waiting for the change. (unconfirmed_additions)
|
||||
if sum_value < amount:
|
||||
raise ValueError(
|
||||
"Can't make this transaction at the moment. Waiting for the change from the previous transaction."
|
||||
)
|
||||
|
||||
self.log.info(f"Successfully selected coins: {used_coins}")
|
||||
return used_coins
|
||||
|
||||
# This will be used in the recovery case where we don't have the parent info already
|
||||
async def coin_added(self, coin: Coin, header_hash: bytes32, removals: List[Coin], height: int):
|
||||
""" Notification from wallet state manager that wallet has been received. """
|
||||
self.log.info("DID wallet has been notified that coin was added")
|
||||
inner_puzzle = await self.inner_puzzle_for_did_puzzle(coin.puzzle_hash)
|
||||
new_info = DIDInfo(
|
||||
self.did_info.my_did,
|
||||
self.did_info.backup_ids,
|
||||
self.did_info.num_of_backup_ids_needed,
|
||||
self.did_info.parent_info,
|
||||
inner_puzzle,
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
)
|
||||
await self.save_info(new_info)
|
||||
|
||||
future_parent = CCParent(
|
||||
coin.parent_coin_info,
|
||||
inner_puzzle.get_tree_hash(),
|
||||
coin.amount,
|
||||
)
|
||||
|
||||
await self.add_parent(coin.name(), future_parent)
|
||||
|
||||
def create_backup(self, filename: str):
|
||||
assert self.did_info.current_inner is not None
|
||||
try:
|
||||
f = open(filename, "w")
|
||||
output_str = f"{self.get_my_DID()}:"
|
||||
for did in self.did_info.backup_ids:
|
||||
output_str = output_str + did.hex() + ","
|
||||
output_str = output_str[:-1]
|
||||
output_str = (
|
||||
output_str + f":{bytes(self.did_info.current_inner).hex()}:{self.did_info.num_of_backup_ids_needed}"
|
||||
)
|
||||
f.write(output_str)
|
||||
f.close()
|
||||
except Exception as e:
|
||||
raise e
|
||||
return
|
||||
|
||||
async def load_backup(self, filename: str):
|
||||
try:
|
||||
f = open(filename, "r")
|
||||
details = f.readline().split(":")
|
||||
f.close()
|
||||
genesis_id = bytes.fromhex(details[0])
|
||||
backup_ids = []
|
||||
for d in details[1].split(","):
|
||||
backup_ids.append(bytes.fromhex(d))
|
||||
num_of_backup_ids_needed = uint64(int(details[3]))
|
||||
if num_of_backup_ids_needed > len(backup_ids):
|
||||
raise Exception
|
||||
innerpuz = Program.from_bytes(bytes.fromhex(details[2]))
|
||||
did_info = DIDInfo(
|
||||
genesis_id,
|
||||
backup_ids,
|
||||
num_of_backup_ids_needed,
|
||||
self.did_info.parent_info,
|
||||
innerpuz,
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
)
|
||||
await self.save_info(did_info)
|
||||
full_puz = did_wallet_puzzles.create_fullpuz(innerpuz, genesis_id)
|
||||
full_puzzle_hash = full_puz.get_tree_hash()
|
||||
(
|
||||
sub_height,
|
||||
header_hash,
|
||||
) = await self.wallet_state_manager.search_blockrecords_for_puzzlehash(full_puzzle_hash)
|
||||
assert sub_height is not None
|
||||
assert header_hash is not None
|
||||
full_nodes = self.wallet_state_manager.server.connection_by_type[NodeType.FULL_NODE]
|
||||
additions: Union[RespondAdditions, RejectAdditionsRequest, None] = None
|
||||
for id, node in full_nodes.items():
|
||||
request = wallet_protocol.RequestAdditions(sub_height, header_hash, None)
|
||||
additions = await node.request_additions(request)
|
||||
if additions is not None:
|
||||
break
|
||||
if isinstance(additions, RejectAdditionsRequest):
|
||||
continue
|
||||
|
||||
assert additions is not None
|
||||
assert isinstance(additions, RespondAdditions)
|
||||
# All additions in this block here:
|
||||
new_puzhash = (await self.get_new_puzzle()).get_tree_hash()
|
||||
new_pubkey = bytes(
|
||||
(await self.wallet_state_manager.get_unused_derivation_record(self.wallet_info.id)).pubkey
|
||||
)
|
||||
|
||||
all_parents: bytes32 = set()
|
||||
for puzzle_list_coin in additions.coins:
|
||||
puzzle_hash, coins = puzzle_list_coin
|
||||
for coin in coins:
|
||||
all_parents.add(coin.parent_coin_info)
|
||||
for puzzle_list_coin in additions.coins:
|
||||
puzzle_hash, coins = puzzle_list_coin
|
||||
if puzzle_hash == full_puzzle_hash:
|
||||
# our coin
|
||||
for coin in coins:
|
||||
future_parent = CCParent(
|
||||
coin.parent_coin_info,
|
||||
innerpuz.get_tree_hash(),
|
||||
coin.amount,
|
||||
)
|
||||
await self.add_parent(coin.name(), future_parent)
|
||||
if coin.name() in all_parents:
|
||||
continue
|
||||
did_info = DIDInfo(
|
||||
genesis_id,
|
||||
backup_ids,
|
||||
num_of_backup_ids_needed,
|
||||
self.did_info.parent_info,
|
||||
innerpuz,
|
||||
coin,
|
||||
new_puzhash,
|
||||
new_pubkey,
|
||||
)
|
||||
await self.save_info(did_info)
|
||||
|
||||
await self.wallet_state_manager.update_wallet_puzzle_hashes(self.wallet_info.id)
|
||||
return
|
||||
except Exception as e:
|
||||
raise e
|
||||
|
||||
def puzzle_for_pk(self, pubkey: bytes) -> Program:
|
||||
innerpuz = did_wallet_puzzles.create_innerpuz(
|
||||
pubkey, self.did_info.backup_ids, self.did_info.num_of_backup_ids_needed
|
||||
)
|
||||
did = self.did_info.my_did
|
||||
return did_wallet_puzzles.create_fullpuz(innerpuz, did)
|
||||
|
||||
async def get_new_puzzle(self) -> Program:
|
||||
return self.puzzle_for_pk(
|
||||
bytes((await self.wallet_state_manager.get_unused_derivation_record(self.wallet_info.id)).pubkey)
|
||||
)
|
||||
|
||||
def get_my_DID(self) -> str:
|
||||
core = self.did_info.my_did
|
||||
assert core is not None
|
||||
return core.hex()
|
||||
|
||||
# This is used to cash out, or update the id_list
|
||||
async def create_spend(self, puzhash: bytes32):
|
||||
assert self.did_info.current_inner is not None
|
||||
coins = await self.select_coins(1)
|
||||
assert coins is not None
|
||||
coin = coins.pop()
|
||||
# innerpuz solution is (mode amount new_puz identity my_puz)
|
||||
innersol: Program = Program.to([0, coin.amount, puzhash, coin.name(), coin.puzzle_hash])
|
||||
# full solution is (corehash parent_info my_amount innerpuz_reveal solution)
|
||||
innerpuz: Program = self.did_info.current_inner
|
||||
|
||||
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
|
||||
innerpuz,
|
||||
self.did_info.my_did,
|
||||
)
|
||||
parent_info = await self.get_parent_for_coin(coin)
|
||||
assert parent_info is not None
|
||||
|
||||
fullsol = Program.to(
|
||||
[
|
||||
[
|
||||
parent_info.parent_name,
|
||||
parent_info.inner_puzzle_hash,
|
||||
parent_info.amount,
|
||||
],
|
||||
coin.amount,
|
||||
innersol,
|
||||
]
|
||||
)
|
||||
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
|
||||
# sign for AGG_SIG_ME
|
||||
message = bytes(puzhash) + bytes(coin.name())
|
||||
pubkey = did_wallet_puzzles.get_pubkey_from_innerpuz(innerpuz)
|
||||
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(pubkey)
|
||||
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key, index)
|
||||
signature = AugSchemeMPL.sign(private, message)
|
||||
# assert signature.validate([signature.PkMessagePair(pubkey, message)])
|
||||
sigs = [signature]
|
||||
aggsig = AugSchemeMPL.aggregate(sigs)
|
||||
spend_bundle = SpendBundle(list_of_solutions, aggsig)
|
||||
|
||||
did_record = TransactionRecord(
|
||||
confirmed_at_height=uint32(0),
|
||||
created_at_time=uint64(int(time.time())),
|
||||
to_puzzle_hash=puzhash,
|
||||
amount=uint64(coin.amount),
|
||||
fee_amount=uint64(0),
|
||||
confirmed=False,
|
||||
sent=uint32(0),
|
||||
spend_bundle=spend_bundle,
|
||||
additions=spend_bundle.additions(),
|
||||
removals=spend_bundle.removals(),
|
||||
wallet_id=self.wallet_info.id,
|
||||
sent_to=[],
|
||||
trade_id=None,
|
||||
type=uint32(TransactionType.OUTGOING_TX.value),
|
||||
name=token_bytes(),
|
||||
)
|
||||
await self.standard_wallet.push_transaction(did_record)
|
||||
return spend_bundle
|
||||
|
||||
# Pushes the a SpendBundle to create a message coin on the blockchain
|
||||
# Returns a SpendBundle for the recoverer to spend the message coin
|
||||
async def create_attestment(
|
||||
self, recovering_coin_name: bytes32, newpuz: bytes32, pubkey: G1Element, filename=None
|
||||
) -> SpendBundle:
|
||||
assert self.did_info.current_inner is not None
|
||||
coins = await self.select_coins(1)
|
||||
assert coins is not None and coins != set()
|
||||
coin = coins.pop()
|
||||
message = did_wallet_puzzles.create_recovery_message_puzzle(recovering_coin_name, newpuz, pubkey)
|
||||
innermessage = message.get_tree_hash()
|
||||
# innerpuz solution is (mode amount new_puz identity my_puz)
|
||||
innersol = Program.to([1, coin.amount, innermessage, recovering_coin_name, coin.puzzle_hash])
|
||||
# full solution is (corehash parent_info my_amount innerpuz_reveal solution)
|
||||
innerpuz: Program = self.did_info.current_inner
|
||||
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
|
||||
innerpuz,
|
||||
self.did_info.my_did,
|
||||
)
|
||||
parent_info = await self.get_parent_for_coin(coin)
|
||||
assert parent_info is not None
|
||||
|
||||
fullsol = Program.to(
|
||||
[
|
||||
[
|
||||
parent_info.parent_name,
|
||||
parent_info.inner_puzzle_hash,
|
||||
parent_info.amount,
|
||||
],
|
||||
coin.amount,
|
||||
innersol,
|
||||
]
|
||||
)
|
||||
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
|
||||
message_spend = did_wallet_puzzles.create_spend_for_message(coin.name(), recovering_coin_name, newpuz, pubkey)
|
||||
|
||||
message_spend_bundle = SpendBundle([message_spend], AugSchemeMPL.aggregate([]))
|
||||
# sign for AGG_SIG_ME
|
||||
message = bytes(innermessage) + bytes(coin.name())
|
||||
pubkey = did_wallet_puzzles.get_pubkey_from_innerpuz(innerpuz)
|
||||
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(pubkey)
|
||||
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key, index)
|
||||
signature = AugSchemeMPL.sign(private, message)
|
||||
# assert signature.validate([signature.PkMessagePair(pubkey, message)])
|
||||
spend_bundle = SpendBundle(list_of_solutions, signature)
|
||||
did_record = TransactionRecord(
|
||||
confirmed_at_height=uint32(0),
|
||||
created_at_time=uint64(int(time.time())),
|
||||
to_puzzle_hash=coin.puzzle_hash,
|
||||
amount=uint64(coin.amount),
|
||||
fee_amount=uint64(0),
|
||||
confirmed=False,
|
||||
sent=uint32(0),
|
||||
spend_bundle=spend_bundle,
|
||||
additions=spend_bundle.additions(),
|
||||
removals=spend_bundle.removals(),
|
||||
wallet_id=self.wallet_info.id,
|
||||
sent_to=[],
|
||||
trade_id=None,
|
||||
type=uint32(TransactionType.INCOMING_TX.value),
|
||||
name=token_bytes(),
|
||||
)
|
||||
await self.standard_wallet.push_transaction(did_record)
|
||||
if filename is not None:
|
||||
f = open(filename, "w")
|
||||
f.write(self.get_my_DID())
|
||||
f.write(":")
|
||||
f.write(bytes(message_spend_bundle).hex())
|
||||
f.write(":")
|
||||
parent = coin.parent_coin_info.hex()
|
||||
innerpuzhash = self.did_info.current_inner.get_tree_hash().hex()
|
||||
amount = coin.amount
|
||||
f.write(parent)
|
||||
f.write(":")
|
||||
f.write(innerpuzhash)
|
||||
f.write(":")
|
||||
f.write(str(amount))
|
||||
f.close()
|
||||
return message_spend_bundle
|
||||
|
||||
# this is just for testing purposes, API should use create_attestment_now
|
||||
async def get_info_for_recovery(self):
|
||||
coins = await self.select_coins(1)
|
||||
coin = coins.pop()
|
||||
parent = coin.parent_coin_info
|
||||
innerpuzhash = self.did_info.current_inner.get_tree_hash()
|
||||
amount = coin.amount
|
||||
return [parent, innerpuzhash, amount]
|
||||
|
||||
async def load_attest_files_for_recovery_spend(self, filenames):
|
||||
spend_bundle_list = []
|
||||
info_dict = {}
|
||||
try:
|
||||
for i in filenames:
|
||||
f = open(i)
|
||||
info = f.read().split(":")
|
||||
info_dict[info[0]] = [
|
||||
bytes.fromhex(info[2]),
|
||||
bytes.fromhex(info[3]),
|
||||
uint64(info[4]),
|
||||
]
|
||||
|
||||
new_sb = SpendBundle.from_bytes(bytes.fromhex(info[1]))
|
||||
spend_bundle_list.append(new_sb)
|
||||
f.close()
|
||||
# info_dict {0xidentity: "(0xparent_info 0xinnerpuz amount)"}
|
||||
my_recovery_list: List[bytes] = self.did_info.backup_ids
|
||||
|
||||
# convert info dict into recovery list - same order as wallet
|
||||
info_list = []
|
||||
for entry in my_recovery_list:
|
||||
if entry.hex() in info_dict:
|
||||
info_list.append(
|
||||
[
|
||||
info_dict[entry.hex()][0],
|
||||
info_dict[entry.hex()][1],
|
||||
info_dict[entry.hex()][2],
|
||||
]
|
||||
)
|
||||
else:
|
||||
info_list.append([])
|
||||
message_spend_bundle = SpendBundle.aggregate(spend_bundle_list)
|
||||
return info_list, message_spend_bundle
|
||||
except Exception:
|
||||
raise
|
||||
|
||||
async def recovery_spend(
|
||||
self,
|
||||
coin: Coin,
|
||||
puzhash: bytes,
|
||||
parent_innerpuzhash_amounts_for_recovery_ids: List[Tuple[bytes, bytes, int]],
|
||||
pubkey: G1Element,
|
||||
spend_bundle: SpendBundle,
|
||||
) -> SpendBundle:
|
||||
# innerpuz solution is (mode amount new_puz identity my_puz parent_innerpuzhash_amounts_for_recovery_ids)
|
||||
innersol = Program.to(
|
||||
[
|
||||
2,
|
||||
coin.amount,
|
||||
puzhash,
|
||||
coin.name(),
|
||||
coin.puzzle_hash,
|
||||
parent_innerpuzhash_amounts_for_recovery_ids,
|
||||
bytes(pubkey),
|
||||
self.did_info.backup_ids,
|
||||
self.did_info.num_of_backup_ids_needed,
|
||||
]
|
||||
)
|
||||
# full solution is (parent_info my_amount solution)
|
||||
innerpuz = self.did_info.current_inner
|
||||
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
|
||||
innerpuz,
|
||||
self.did_info.my_did,
|
||||
)
|
||||
parent_info = await self.get_parent_for_coin(coin)
|
||||
assert parent_info is not None
|
||||
fullsol = Program.to(
|
||||
[
|
||||
[
|
||||
parent_info.parent_name,
|
||||
parent_info.inner_puzzle_hash,
|
||||
parent_info.amount,
|
||||
],
|
||||
coin.amount,
|
||||
innersol,
|
||||
]
|
||||
)
|
||||
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
|
||||
|
||||
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(pubkey)
|
||||
if index is None:
|
||||
raise ValueError("Unknown pubkey.")
|
||||
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key, index)
|
||||
message = bytes(puzhash)
|
||||
sigs = [AugSchemeMPL.sign(private, message)]
|
||||
for c in spend_bundle.coin_solutions:
|
||||
sigs.append(AugSchemeMPL.sign(private, message))
|
||||
aggsig = AugSchemeMPL.aggregate(sigs)
|
||||
# assert AugSchemeMPL.verify(pubkey, message, aggsig)
|
||||
if spend_bundle is None:
|
||||
spend_bundle = SpendBundle(list_of_solutions, aggsig)
|
||||
else:
|
||||
spend_bundle = spend_bundle.aggregate([spend_bundle, SpendBundle(list_of_solutions, aggsig)])
|
||||
|
||||
did_record = TransactionRecord(
|
||||
confirmed_at_height=uint32(0),
|
||||
created_at_time=uint64(int(time.time())),
|
||||
to_puzzle_hash=puzhash,
|
||||
amount=uint64(coin.amount),
|
||||
fee_amount=uint64(0),
|
||||
confirmed=False,
|
||||
sent=uint32(0),
|
||||
spend_bundle=spend_bundle,
|
||||
additions=spend_bundle.additions(),
|
||||
removals=spend_bundle.removals(),
|
||||
wallet_id=self.wallet_info.id,
|
||||
sent_to=[],
|
||||
trade_id=None,
|
||||
type=uint32(TransactionType.OUTGOING_TX.value),
|
||||
name=token_bytes(),
|
||||
)
|
||||
await self.standard_wallet.push_transaction(did_record)
|
||||
return spend_bundle
|
||||
|
||||
async def get_new_innerpuz(self) -> Program:
|
||||
devrec = await self.wallet_state_manager.get_unused_derivation_record(self.standard_wallet.id())
|
||||
pubkey = bytes(devrec.pubkey)
|
||||
innerpuz = did_wallet_puzzles.create_innerpuz(
|
||||
pubkey,
|
||||
self.did_info.backup_ids,
|
||||
uint64(self.did_info.num_of_backup_ids_needed),
|
||||
)
|
||||
|
||||
return innerpuz
|
||||
|
||||
async def get_new_inner_hash(self) -> bytes32:
|
||||
innerpuz = await self.get_new_innerpuz()
|
||||
return innerpuz.get_tree_hash()
|
||||
|
||||
async def get_innerhash_for_pubkey(self, pubkey: bytes):
|
||||
innerpuz = did_wallet_puzzles.create_innerpuz(
|
||||
pubkey,
|
||||
self.did_info.backup_ids,
|
||||
uint64(self.did_info.num_of_backup_ids_needed),
|
||||
)
|
||||
return innerpuz.get_tree_hash()
|
||||
|
||||
async def inner_puzzle_for_did_puzzle(self, did_hash: bytes32) -> Program:
|
||||
record: DerivationRecord = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
|
||||
did_hash.hex()
|
||||
)
|
||||
inner_puzzle: Program = did_wallet_puzzles.create_innerpuz(
|
||||
bytes(record.pubkey),
|
||||
self.did_info.backup_ids,
|
||||
self.did_info.num_of_backup_ids_needed,
|
||||
)
|
||||
return inner_puzzle
|
||||
|
||||
async def get_parent_for_coin(self, coin) -> Optional[CCParent]:
|
||||
parent_info = None
|
||||
for name, ccparent in self.did_info.parent_info:
|
||||
if name == coin.parent_coin_info:
|
||||
parent_info = ccparent
|
||||
|
||||
return parent_info
|
||||
|
||||
async def generate_new_decentralised_id(self, amount: uint64) -> Optional[SpendBundle]:
|
||||
|
||||
coins = await self.standard_wallet.select_coins(amount)
|
||||
if coins is None:
|
||||
return None
|
||||
|
||||
origin = coins.copy().pop()
|
||||
origin_id = origin.name()
|
||||
|
||||
did_inner: Program = await self.get_new_innerpuz()
|
||||
did_inner_hash = did_inner.get_tree_hash()
|
||||
did_puz = did_wallet_puzzles.create_fullpuz(did_inner, origin_id)
|
||||
did_puzzle_hash = did_puz.get_tree_hash()
|
||||
|
||||
tx_record: Optional[TransactionRecord] = await self.standard_wallet.generate_signed_transaction(
|
||||
amount, did_puzzle_hash, uint64(0), origin_id, coins
|
||||
)
|
||||
eve_coin = Coin(origin_id, did_puzzle_hash, amount)
|
||||
future_parent = CCParent(
|
||||
eve_coin.parent_coin_info,
|
||||
did_inner_hash,
|
||||
eve_coin.amount,
|
||||
)
|
||||
eve_parent = CCParent(
|
||||
origin.parent_coin_info,
|
||||
origin.puzzle_hash,
|
||||
origin.amount,
|
||||
)
|
||||
await self.add_parent(eve_coin.parent_coin_info, eve_parent)
|
||||
await self.add_parent(eve_coin.name(), future_parent)
|
||||
|
||||
if tx_record is None or tx_record.spend_bundle is None:
|
||||
return None
|
||||
|
||||
# Only want to save this information if the transaction is valid
|
||||
did_info: DIDInfo = DIDInfo(
|
||||
origin_id,
|
||||
self.did_info.backup_ids,
|
||||
self.did_info.num_of_backup_ids_needed,
|
||||
self.did_info.parent_info,
|
||||
did_inner,
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
)
|
||||
await self.save_info(did_info)
|
||||
eve_spend = await self.generate_eve_spend(eve_coin, did_puz, origin_id, did_inner)
|
||||
full_spend = SpendBundle.aggregate([tx_record.spend_bundle, eve_spend])
|
||||
return full_spend
|
||||
|
||||
async def generate_eve_spend(self, coin: Coin, full_puzzle: Program, origin_id: bytes, innerpuz: Program):
|
||||
# innerpuz solution is (mode amount message my_id my_puzhash parent_innerpuzhash_amounts_for_recovery_ids)
|
||||
innersol = Program.to([0, coin.amount, coin.puzzle_hash, coin.name(), coin.puzzle_hash, []])
|
||||
# full solution is (parent_info my_amount innersolution)
|
||||
fullsol = Program.to([coin.parent_coin_info, coin.amount, innersol])
|
||||
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
|
||||
# sign for AGG_SIG_ME
|
||||
message = bytes(coin.puzzle_hash) + bytes(coin.name())
|
||||
pubkey = did_wallet_puzzles.get_pubkey_from_innerpuz(innerpuz)
|
||||
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(pubkey)
|
||||
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key, index)
|
||||
signature = AugSchemeMPL.sign(private, message)
|
||||
sigs = [signature]
|
||||
aggsig = AugSchemeMPL.aggregate(sigs)
|
||||
spend_bundle = SpendBundle(list_of_solutions, aggsig)
|
||||
return spend_bundle
|
||||
|
||||
async def get_frozen_amount(self) -> uint64:
|
||||
return await self.wallet_state_manager.get_frozen_balance(self.wallet_info.id)
|
||||
|
||||
async def get_spendable_balance(self, unspent_records=None) -> uint64:
|
||||
spendable_am = await self.wallet_state_manager.get_confirmed_spendable_balance_for_wallet(
|
||||
self.wallet_info.id, unspent_records
|
||||
)
|
||||
return spendable_am
|
||||
|
||||
async def get_max_send_amount(self, records=None):
|
||||
max_send_amount = await self.get_confirmed_balance()
|
||||
|
||||
return max_send_amount
|
||||
|
||||
async def add_parent(self, name: bytes32, parent: Optional[CCParent]):
|
||||
self.log.info(f"Adding parent {name}: {parent}")
|
||||
current_list = self.did_info.parent_info.copy()
|
||||
current_list.append((name, parent))
|
||||
did_info: DIDInfo = DIDInfo(
|
||||
self.did_info.my_did,
|
||||
self.did_info.backup_ids,
|
||||
self.did_info.num_of_backup_ids_needed,
|
||||
current_list,
|
||||
self.did_info.current_inner,
|
||||
self.did_info.temp_coin,
|
||||
self.did_info.temp_puzhash,
|
||||
self.did_info.temp_pubkey,
|
||||
)
|
||||
await self.save_info(did_info)
|
||||
|
||||
async def update_recovery_list(self, recover_list: List[bytes], num_of_backup_ids_needed: uint64):
|
||||
if num_of_backup_ids_needed > len(recover_list):
|
||||
return False
|
||||
did_info: DIDInfo = DIDInfo(
|
||||
self.did_info.my_did,
|
||||
recover_list,
|
||||
num_of_backup_ids_needed,
|
||||
self.did_info.parent_info,
|
||||
self.did_info.current_inner,
|
||||
self.did_info.temp_coin,
|
||||
self.did_info.temp_puzhash,
|
||||
self.did_info.temp_pubkey,
|
||||
)
|
||||
await self.save_info(did_info)
|
||||
await self.wallet_state_manager.update_wallet_puzzle_hashes(self.wallet_info.id)
|
||||
return True
|
||||
|
||||
async def save_info(self, did_info: DIDInfo):
|
||||
self.did_info = did_info
|
||||
current_info = self.wallet_info
|
||||
data_str = json.dumps(did_info.to_json_dict())
|
||||
wallet_info = WalletInfo(current_info.id, current_info.name, current_info.type, data_str)
|
||||
self.wallet_info = wallet_info
|
||||
await self.wallet_state_manager.user_store.update_wallet(wallet_info)
|
||||
|
|
@ -0,0 +1,104 @@
|
|||
from clvm_tools import binutils
|
||||
from chia.types.blockchain_format.sized_bytes import bytes32
|
||||
from chia.types.blockchain_format.program import Program
|
||||
from typing import List, Optional, Tuple
|
||||
from blspy import G1Element
|
||||
from chia.types.blockchain_format.coin import Coin
|
||||
from chia.types.coin_solution import CoinSolution
|
||||
from chia.util.ints import uint64
|
||||
from chia.wallet.puzzles.load_clvm import load_clvm
|
||||
from chia.types.condition_opcodes import ConditionOpcode
|
||||
|
||||
DID_CORE_MOD = load_clvm("singleton_top_layer.clvm")
|
||||
DID_INNERPUZ_MOD = load_clvm("did_innerpuz.clvm")
|
||||
|
||||
|
||||
def create_innerpuz(pubkey: bytes, identities: List[bytes], num_of_backup_ids_needed: uint64) -> Program:
|
||||
backup_ids_hash = Program(Program.to(identities)).get_tree_hash()
|
||||
return DID_INNERPUZ_MOD.curry(DID_CORE_MOD.get_tree_hash(), pubkey, backup_ids_hash, num_of_backup_ids_needed)
|
||||
|
||||
|
||||
def create_fullpuz(innerpuz, genesis_id) -> Program:
|
||||
mod_hash = DID_CORE_MOD.get_tree_hash()
|
||||
return DID_CORE_MOD.curry(mod_hash, genesis_id, innerpuz)
|
||||
|
||||
|
||||
def fullpuz_hash_for_inner_puzzle_hash(mod_code, genesis_id, inner_puzzle_hash) -> bytes32:
|
||||
"""
|
||||
Given an inner puzzle hash, calculate a puzzle program hash for a specific cc.
|
||||
"""
|
||||
gid_hash = genesis_id.get_tree_hash()
|
||||
return mod_code.curry(mod_code.get_tree_hash(), gid_hash, inner_puzzle_hash).get_tree_hash(
|
||||
gid_hash, inner_puzzle_hash
|
||||
)
|
||||
|
||||
|
||||
def get_pubkey_from_innerpuz(innerpuz: Program) -> G1Element:
|
||||
ret = uncurry_innerpuz(innerpuz)
|
||||
if ret is not None:
|
||||
pubkey_program = ret[0]
|
||||
else:
|
||||
raise ValueError("Unable to extract pubkey")
|
||||
pubkey = G1Element.from_bytes(pubkey_program.as_atom())
|
||||
return pubkey
|
||||
|
||||
|
||||
def is_did_innerpuz(inner_f: Program):
|
||||
"""
|
||||
You may want to generalize this if different `CC_MOD` templates are supported.
|
||||
"""
|
||||
return inner_f == DID_INNERPUZ_MOD
|
||||
|
||||
|
||||
def is_did_core(inner_f: Program):
|
||||
return inner_f == DID_CORE_MOD
|
||||
|
||||
|
||||
def uncurry_innerpuz(puzzle: Program) -> Optional[Tuple[Program, Program]]:
|
||||
"""
|
||||
Take a puzzle and return `None` if it's not a `CC_MOD` cc, or
|
||||
a triple of `mod_hash, genesis_coin_checker, inner_puzzle` if it is.
|
||||
"""
|
||||
r = puzzle.uncurry()
|
||||
if r is None:
|
||||
return r
|
||||
inner_f, args = r
|
||||
if not is_did_innerpuz(inner_f):
|
||||
return None
|
||||
|
||||
core_mod, pubkey, id_list, num_of_backup_ids_needed = list(args.as_iter())
|
||||
return pubkey, id_list
|
||||
|
||||
|
||||
def get_innerpuzzle_from_puzzle(puzzle: Program) -> Optional[Program]:
|
||||
r = puzzle.uncurry()
|
||||
if r is None:
|
||||
return None
|
||||
inner_f, args = r
|
||||
if not is_did_core(inner_f):
|
||||
return None
|
||||
mod_hash, genesis_id, inner_puzzle = list(args.as_iter())
|
||||
return inner_puzzle
|
||||
|
||||
|
||||
def create_recovery_message_puzzle(recovering_coin: bytes32, newpuz: bytes32, pubkey: G1Element):
|
||||
puzstring = f"(q . ((0x{ConditionOpcode.CREATE_ANNOUNCEMENT.hex()} 0x{recovering_coin.hex()}) (0x{ConditionOpcode.AGG_SIG.hex()} 0x{bytes(pubkey).hex()} 0x{newpuz.hex()})))" # noqa
|
||||
puz = binutils.assemble(puzstring)
|
||||
return Program.to(puz)
|
||||
|
||||
|
||||
def create_spend_for_message(parent_of_message, recovering_coin, newpuz, pubkey):
|
||||
puzzle = create_recovery_message_puzzle(recovering_coin, newpuz, pubkey)
|
||||
coin = Coin(parent_of_message, puzzle.get_tree_hash(), uint64(0))
|
||||
solution = Program.to([])
|
||||
coinsol = CoinSolution(coin, puzzle, solution)
|
||||
return coinsol
|
||||
|
||||
|
||||
# inspect puzzle and check it is a CC puzzle
|
||||
def check_is_did_puzzle(puzzle: Program):
|
||||
r = puzzle.uncurry()
|
||||
if r is None:
|
||||
return r
|
||||
inner_f, args = r
|
||||
return is_did_core(inner_f)
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
(mod (MOD_HASH MY_PUBKEY RECOVERY_DID_LIST_HASH NUM_VERIFICATIONS_REQUIRED mode amount message my_id my_puzhash parent_innerpuzhash_amounts_for_recovery_ids pubkey recovery_list_reveal)
|
||||
;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.clvm)
|
||||
|
||||
(defmacro and ARGS
|
||||
(if ARGS
|
||||
(qq (if (unquote (f ARGS))
|
||||
(unquote (c and (r ARGS)))
|
||||
()
|
||||
))
|
||||
1)
|
||||
)
|
||||
|
||||
(defmacro not (ARGS)
|
||||
(qq (if (unquote ARGS) 0 1))
|
||||
)
|
||||
|
||||
(defun is-in-list (atom items)
|
||||
;; returns 1 iff `atom` is in the list of `items`
|
||||
(if items
|
||||
(if (= atom (f items))
|
||||
1
|
||||
(is-in-list atom (r items))
|
||||
)
|
||||
0
|
||||
)
|
||||
)
|
||||
|
||||
; 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)
|
||||
)
|
||||
)
|
||||
|
||||
;; utility function used by `curry_args`
|
||||
(defun fix_curry_args (items core)
|
||||
(if items
|
||||
(qq (c (q . (unquote (f items))) (unquote (fix_curry_args (r items) core))))
|
||||
core
|
||||
)
|
||||
)
|
||||
|
||||
; (curry_args sum (list 50 60)) => returns a function that is like (sum 50 60 ...)
|
||||
(defun curry_args (func list_of_args) (qq (a (q . (unquote func)) (unquote (fix_curry_args list_of_args (q . 1))))))
|
||||
|
||||
;; (curry sum 50 60) => returns a function that is like (sum 50 60 ...)
|
||||
(defun curry (func . args) (curry_args func args))
|
||||
|
||||
;; hash a tree with escape values representing already-hashed subtrees
|
||||
;; This optimization can be useful if you know the puzzle hash of a sub-expression.
|
||||
;; You probably actually want to use `curry_and_hash` though.
|
||||
(defun sha256tree_esc_list
|
||||
(TREE LITERALS)
|
||||
(if (l TREE)
|
||||
(sha256 2 (sha256tree_esc_list (f TREE) LITERALS) (sha256tree_esc_list (r TREE) LITERALS))
|
||||
(if (is-in-list TREE LITERALS)
|
||||
TREE
|
||||
(sha256 1 TREE)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;; hash a tree with escape values representing already-hashed subtrees
|
||||
;; This optimization can be useful if you know the tree hash of a sub-expression.
|
||||
(defun sha256tree_esc
|
||||
(TREE . LITERAL)
|
||||
(sha256tree_esc_list TREE LITERAL)
|
||||
)
|
||||
|
||||
;recovery message module - gets values curried in to make the puzzle
|
||||
;TODO - this should probably be imported
|
||||
(defun make_message_puzzle (recovering_coin newpuz pubkey)
|
||||
(qq (q . (((unquote CREATE_ANNOUNCEMENT) (unquote recovering_coin)) ((unquote AGG_SIG) (unquote pubkey) (unquote newpuz)))))
|
||||
)
|
||||
|
||||
(defun create_consume_message (coin_id my_id new_innerpuz pubkey)
|
||||
(list ASSERT_ANNOUNCEMENT (sha256 (sha256 coin_id (sha256tree1 (make_message_puzzle my_id new_innerpuz pubkey))) my_id))
|
||||
)
|
||||
|
||||
;; return the puzzle hash for a cc with the given `genesis-coin-checker-hash` & `inner-puzzle`
|
||||
(defun create_fullpuzhash (mod_hash mod_hash_hash genesis_id inner_puzzle_hash)
|
||||
(sha256tree_esc (curry mod_hash mod_hash_hash genesis_id inner_puzzle_hash)
|
||||
mod_hash
|
||||
mod_hash_hash
|
||||
inner_puzzle_hash)
|
||||
)
|
||||
|
||||
(defun create_coin_ID_for_recovery (mod_hash mod_hash_hash did parent innerpuzhash amount)
|
||||
(sha256 parent (create_fullpuzhash mod_hash mod_hash_hash did innerpuzhash) amount)
|
||||
)
|
||||
|
||||
(defmacro recreate_self (my_puzhash amount)
|
||||
(qq (c CREATE_COIN (c (unquote my_puzhash) (c (unquote amount) ()))))
|
||||
)
|
||||
|
||||
(defmacro create_new_coin (amount new_puz)
|
||||
(qq (c CREATE_COIN (c (unquote new_puz) (c (unquote amount) ()))))
|
||||
)
|
||||
|
||||
(defun check_messages_from_identities (mod_hash mod_hash_hash num_verifications_required identities my_id output new_puz parent_innerpuzhash_amounts_for_recovery_ids pubkey num_verifications)
|
||||
(if identities
|
||||
(if (f parent_innerpuzhash_amounts_for_recovery_ids)
|
||||
(check_messages_from_identities
|
||||
mod_hash
|
||||
mod_hash_hash
|
||||
num_verifications_required
|
||||
(r identities)
|
||||
my_id
|
||||
(c
|
||||
(create_consume_message
|
||||
; create coin_id from DID
|
||||
(create_coin_ID_for_recovery
|
||||
mod_hash
|
||||
mod_hash_hash
|
||||
(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)
|
||||
output)
|
||||
new_puz
|
||||
(r parent_innerpuzhash_amounts_for_recovery_ids)
|
||||
pubkey
|
||||
(+ num_verifications 1)
|
||||
)
|
||||
(check_messages_from_identities
|
||||
mod_hash
|
||||
mod_hash_hash
|
||||
num_verifications_required
|
||||
(r identities)
|
||||
my_id
|
||||
output
|
||||
new_puz
|
||||
(r parent_innerpuzhash_amounts_for_recovery_ids)
|
||||
pubkey
|
||||
num_verifications
|
||||
)
|
||||
)
|
||||
;if we're out of identites to check for, return our output
|
||||
(if (> num_verifications num_verifications_required)
|
||||
(c (list AGG_SIG pubkey new_puz) output)
|
||||
(if (= num_verifications num_verifications_required)
|
||||
(c (list AGG_SIG pubkey new_puz) output)
|
||||
(x "not enough verifications")
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;Spend modes:
|
||||
;0 = normal spend
|
||||
;1 = attest
|
||||
;2 (or anything else) = recovery
|
||||
|
||||
;MAIN
|
||||
|
||||
(if mode
|
||||
(if (= mode 1)
|
||||
; mode one - create message
|
||||
; formerly (list (recreate_self my_puzhash amount) (attest_to_id_and_newpuz identity new_puz) (list AGG_SIG_ME MY_PUBKEY new_puz))
|
||||
(list (recreate_self my_puzhash amount) (list CREATE_COIN message 0) (list AGG_SIG_ME MY_PUBKEY message))
|
||||
; mode two - recovery
|
||||
; check that recovery list is not empty
|
||||
(if recovery_list_reveal
|
||||
(if (= (sha256tree1 recovery_list_reveal) RECOVERY_DID_LIST_HASH)
|
||||
(check_messages_from_identities MOD_HASH (sha256tree1 MOD_HASH) NUM_VERIFICATIONS_REQUIRED recovery_list_reveal my_id (list (create_new_coin amount message)) message parent_innerpuzhash_amounts_for_recovery_ids pubkey 0)
|
||||
(x "recovery list reveal did not match hash")
|
||||
)
|
||||
(x "DID recovery disabled")
|
||||
)
|
||||
)
|
||||
; mode zero - normal spend
|
||||
(list (create_new_coin amount message) (list AGG_SIG_ME MY_PUBKEY message))
|
||||
)
|
||||
|
||||
)
|
||||
|
|
@ -0,0 +1 @@
|
|||
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
|
||||
|
|
@ -0,0 +1 @@
|
|||
d5eae13eb8203bb9a11760d09da2019fff6949e0d0c95026c98592ed720e842e
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
(mod (mod_hash genesis_id innerpuz parent_info my_amount inner_solution)
|
||||
|
||||
;mod_hash, genesis_id, innerpuz are curried in
|
||||
|
||||
; EXAMPLE SOLUTION '(0xfadeddab 0xdeadbeef 1 (0xdeadbeef 0xcafef00d 200) 50 ((51 0xfadeddab 100) (60 "trash") (51 deadbeef 0)))'
|
||||
|
||||
(include condition_codes.clvm)
|
||||
|
||||
; This is for the core
|
||||
|
||||
(defmacro and ARGS
|
||||
(if ARGS
|
||||
(qq (if (unquote (f ARGS))
|
||||
(unquote (c and (r ARGS)))
|
||||
()
|
||||
))
|
||||
1)
|
||||
)
|
||||
|
||||
(defmacro not (ARGS)
|
||||
(qq (if (unquote ARGS) 0 1))
|
||||
)
|
||||
|
||||
(defun is-in-list (atom items)
|
||||
;; returns 1 iff `atom` is in the list of `items`
|
||||
(if items
|
||||
(if (= atom (f items))
|
||||
1
|
||||
(is-in-list atom (r items))
|
||||
)
|
||||
0
|
||||
)
|
||||
)
|
||||
|
||||
; 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)
|
||||
)
|
||||
)
|
||||
|
||||
;; utility function used by `curry_args`
|
||||
(defun fix_curry_args (items core)
|
||||
(if items
|
||||
(qq (c (q . (unquote (f items))) (unquote (fix_curry_args (r items) core))))
|
||||
core
|
||||
)
|
||||
)
|
||||
|
||||
; (curry_args sum (list 50 60)) => returns a function that is like (sum 50 60 ...)
|
||||
(defun curry_args (func list_of_args) (qq (a (q . (unquote func)) (unquote (fix_curry_args list_of_args (q . 1))))))
|
||||
|
||||
;; (curry sum 50 60) => returns a function that is like (sum 50 60 ...)
|
||||
(defun curry (func . args) (curry_args func args))
|
||||
|
||||
;; hash a tree with escape values representing already-hashed subtrees
|
||||
;; This optimization can be useful if you know the puzzle hash of a sub-expression.
|
||||
;; You probably actually want to use `curry_and_hash` though.
|
||||
(defun sha256tree_esc_list
|
||||
(TREE LITERALS)
|
||||
(if (l TREE)
|
||||
(sha256 2 (sha256tree_esc_list (f TREE) LITERALS) (sha256tree_esc_list (r TREE) LITERALS))
|
||||
(if (is-in-list TREE LITERALS)
|
||||
TREE
|
||||
(sha256 1 TREE)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;; hash a tree with escape values representing already-hashed subtrees
|
||||
;; This optimization can be useful if you know the tree hash of a sub-expression.
|
||||
(defun sha256tree_esc
|
||||
(TREE . LITERAL)
|
||||
(sha256tree_esc_list TREE LITERAL)
|
||||
)
|
||||
|
||||
;; return the puzzle hash for a cc with the given `genesis-coin-checker-hash` & `inner-puzzle`
|
||||
(defun-inline create_fullpuzhash (mod_hash mod_hash_hash genesis_id inner_puzzle_hash)
|
||||
(sha256tree_esc (curry mod_hash mod_hash_hash genesis_id inner_puzzle_hash)
|
||||
mod_hash
|
||||
mod_hash_hash
|
||||
inner_puzzle_hash)
|
||||
)
|
||||
|
||||
; assembles information from the solution to create our own full ID including asserting our parent is a coloured coin
|
||||
(defun-inline create_my_ID (mod_hash mod_hash_hash genesis_id innerpuzhash parent_parent parent_innerpuz parent_amount my_amount)
|
||||
(sha256 (sha256 parent_parent (create_fullpuzhash mod_hash mod_hash_hash genesis_id parent_innerpuz) parent_amount) (create_fullpuzhash mod_hash mod_hash_hash genesis_id my_innerpuzhash) my_amount)
|
||||
)
|
||||
|
||||
(defun check_my_amount_and_ID (mod_hash mod_hash_hash genesis_id my_innerpuzhash parent_info my_amount)
|
||||
(if (logand my_amount 1)
|
||||
(if (l parent_info)
|
||||
(list ASSERT_MY_COIN_ID (create_my_ID mod_hash mod_hash_hash genesis_id my_innerpuzhash (f parent_info) (f (r parent_info)) (f (r (r parent_info))) my_amount))
|
||||
(list ASSERT_MY_COIN_ID (sha256 genesis_id (create_fullpuzhash mod_hash mod_hash_hash genesis_id my_innerpuzhash) my_amount))
|
||||
)
|
||||
(x)
|
||||
)
|
||||
)
|
||||
|
||||
; Check that only one output with odd value exists
|
||||
(defun check_outputs_value (outputs_loop flag)
|
||||
(if outputs_loop
|
||||
(if (= (f (f outputs_loop)) CREATE_COIN)
|
||||
(if (logand (f (r (r (f outputs_loop)))) 1)
|
||||
(if flag
|
||||
(x)
|
||||
(check_outputs_value (r outputs_loop) 1)
|
||||
)
|
||||
(check_outputs_value (r outputs_loop) flag)
|
||||
)
|
||||
(check_outputs_value (r outputs_loop) flag)
|
||||
)
|
||||
1
|
||||
)
|
||||
)
|
||||
|
||||
(defun check_id_and_check_outputs (mod_hash mod_hash_hash genesis_id parent_info innerpuzhash my_amount outputs)
|
||||
(if (check_outputs_value outputs 0)
|
||||
(c (check_my_amount_and_ID mod_hash mod_hash_hash genesis_id innerpuzhash parent_info my_amount) outputs)
|
||||
(x)
|
||||
)
|
||||
)
|
||||
|
||||
;main
|
||||
(check_id_and_check_outputs mod_hash (sha256 1 mod_hash) genesis_id parent_info (sha256tree1 innerpuz) my_amount (a innerpuz inner_solution))
|
||||
|
||||
)
|
||||
|
|
@ -0,0 +1 @@
|
|||
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
|
||||
|
|
@ -0,0 +1 @@
|
|||
16cdcc16e1ae4bf9895cde32545554344d73742ba5f24609a7296fc43c94fd62
|
||||
|
|
@ -147,7 +147,10 @@ class WalletNode:
|
|||
path = path_from_root(self.root_path, db_path_replaced)
|
||||
mkdir(path.parent)
|
||||
|
||||
self.wallet_state_manager = await WalletStateManager.create(private_key, self.config, path, self.constants)
|
||||
assert self.server is not None
|
||||
self.wallet_state_manager = await WalletStateManager.create(
|
||||
private_key, self.config, path, self.constants, self.server
|
||||
)
|
||||
|
||||
self.wsm_close_task = None
|
||||
|
||||
|
|
|
|||
|
|
@ -53,6 +53,8 @@ from chia.wallet.wallet_puzzle_store import WalletPuzzleStore
|
|||
from chia.wallet.wallet_sync_store import WalletSyncStore
|
||||
from chia.wallet.wallet_transaction_store import WalletTransactionStore
|
||||
from chia.wallet.wallet_user_store import WalletUserStore
|
||||
from chia.server.server import ChiaServer
|
||||
from chia.wallet.did_wallet.did_wallet import DIDWallet
|
||||
|
||||
|
||||
class WalletStateManager:
|
||||
|
|
@ -93,6 +95,7 @@ class WalletStateManager:
|
|||
coin_store: WalletCoinStore
|
||||
sync_store: WalletSyncStore
|
||||
weight_proof_handler: Any
|
||||
server: ChiaServer
|
||||
|
||||
@staticmethod
|
||||
async def create(
|
||||
|
|
@ -100,12 +103,14 @@ class WalletStateManager:
|
|||
config: Dict,
|
||||
db_path: Path,
|
||||
constants: ConsensusConstants,
|
||||
server: ChiaServer,
|
||||
name: str = None,
|
||||
):
|
||||
self = WalletStateManager()
|
||||
self.new_wallet = False
|
||||
self.config = config
|
||||
self.constants = constants
|
||||
self.server = server
|
||||
|
||||
if name:
|
||||
self.log = logging.getLogger(name)
|
||||
|
|
@ -148,22 +153,28 @@ class WalletStateManager:
|
|||
|
||||
self.wallets = {main_wallet_info.id: self.main_wallet}
|
||||
|
||||
wallet = None
|
||||
for wallet_info in await self.get_all_wallet_info_entries():
|
||||
# self.log.info(f"wallet_info {wallet_info}")
|
||||
if wallet_info.type == WalletType.STANDARD_WALLET:
|
||||
if wallet_info.id == 1:
|
||||
continue
|
||||
wallet = await Wallet.create(config, wallet_info)
|
||||
self.wallets[wallet_info.id] = wallet
|
||||
elif wallet_info.type == WalletType.COLOURED_COIN:
|
||||
wallet = await CCWallet.create(
|
||||
self,
|
||||
self.main_wallet,
|
||||
wallet_info,
|
||||
)
|
||||
self.wallets[wallet_info.id] = wallet
|
||||
elif wallet_info.type == WalletType.RATE_LIMITED:
|
||||
wallet = await RLWallet.create(self, wallet_info)
|
||||
elif wallet_info.type == WalletType.DISTRIBUTED_ID:
|
||||
wallet = await DIDWallet.create(
|
||||
self,
|
||||
self.main_wallet,
|
||||
wallet_info,
|
||||
)
|
||||
if wallet is not None:
|
||||
self.wallets[wallet_info.id] = wallet
|
||||
|
||||
async with self.puzzle_store.lock:
|
||||
|
|
@ -205,6 +216,13 @@ class WalletStateManager:
|
|||
wallet_info,
|
||||
)
|
||||
self.wallets[wallet_info.id] = wallet
|
||||
elif wallet_info.type == WalletType.DISTRIBUTED_ID:
|
||||
wallet = await DIDWallet.create(
|
||||
self,
|
||||
self.main_wallet,
|
||||
wallet_info,
|
||||
)
|
||||
self.wallets[wallet_info.id] = wallet
|
||||
|
||||
async def get_keys(self, puzzle_hash: bytes32) -> Optional[Tuple[G1Element, PrivateKey]]:
|
||||
index_for_puzzlehash = await self.puzzle_store.index_for_puzzle_hash(puzzle_hash)
|
||||
|
|
@ -297,6 +315,33 @@ class WalletStateManager:
|
|||
if unused > 0:
|
||||
await self.puzzle_store.set_used_up_to(uint32(unused - 1))
|
||||
|
||||
async def update_wallet_puzzle_hashes(self, wallet_id):
|
||||
derivation_paths: List[DerivationRecord] = []
|
||||
target_wallet = self.wallets[wallet_id]
|
||||
last: Optional[uint32] = await self.puzzle_store.get_last_derivation_path_for_wallet(wallet_id)
|
||||
unused: Optional[uint32] = await self.puzzle_store.get_unused_derivation_path()
|
||||
if unused is None:
|
||||
# This handles the case where the database has entries but they have all been used
|
||||
unused = await self.puzzle_store.get_last_derivation_path()
|
||||
if unused is None:
|
||||
# This handles the case where the database is empty
|
||||
unused = uint32(0)
|
||||
for index in range(unused, last):
|
||||
pubkey: G1Element = self.get_public_key(uint32(index))
|
||||
puzzle: Program = target_wallet.puzzle_for_pk(bytes(pubkey))
|
||||
puzzlehash: bytes32 = puzzle.get_tree_hash()
|
||||
self.log.info(f"Generating public key at index {index} puzzle hash {puzzlehash.hex()}")
|
||||
derivation_paths.append(
|
||||
DerivationRecord(
|
||||
uint32(index),
|
||||
puzzlehash,
|
||||
pubkey,
|
||||
target_wallet.wallet_info.type,
|
||||
uint32(target_wallet.wallet_info.id),
|
||||
)
|
||||
)
|
||||
await self.puzzle_store.add_derivation_paths(derivation_paths)
|
||||
|
||||
async def get_unused_derivation_record(self, wallet_id: uint32) -> DerivationRecord:
|
||||
"""
|
||||
Creates a puzzle hash for the given wallet, and then makes more puzzle hashes
|
||||
|
|
@ -659,8 +704,8 @@ class WalletStateManager:
|
|||
)
|
||||
await self.coin_store.add_coin_record(coin_record)
|
||||
|
||||
if wallet_type == WalletType.COLOURED_COIN:
|
||||
wallet: CCWallet = self.wallets[wallet_id]
|
||||
if wallet_type == WalletType.COLOURED_COIN or wallet_type == WalletType.DISTRIBUTED_ID:
|
||||
wallet = self.wallets[wallet_id]
|
||||
header_hash: bytes32 = self.blockchain.height_to_hash(height)
|
||||
block: Optional[HeaderBlockRecord] = await self.block_store.get_header_block_record(header_hash)
|
||||
assert block is not None
|
||||
|
|
@ -965,6 +1010,29 @@ class WalletStateManager:
|
|||
self.wallets[uint32(wallet_id)] = wallet
|
||||
await self.create_more_puzzle_hashes()
|
||||
|
||||
# search through the blockrecords and return the most recent coin to use a given puzzlehash
|
||||
async def search_blockrecords_for_puzzlehash(self, puzzlehash: bytes32):
|
||||
header_hash_of_interest = None
|
||||
heighest_block_height = 0
|
||||
peak: Optional[BlockRecord] = self.blockchain.get_peak()
|
||||
if peak is None:
|
||||
return None, None
|
||||
peak_block: Optional[HeaderBlockRecord] = await self.blockchain.block_store.get_header_block_record(
|
||||
peak.header_hash
|
||||
)
|
||||
while peak_block is not None:
|
||||
tx_filter = PyBIP158([b for b in peak_block.header.transactions_filter])
|
||||
if tx_filter.Match(bytearray(puzzlehash)) and peak_block.height > heighest_block_height:
|
||||
header_hash_of_interest = peak_block.header_hash
|
||||
heighest_block_height = peak_block.height
|
||||
break
|
||||
else:
|
||||
peak_block = await self.blockchain.block_store.get_header_block_record(
|
||||
peak_block.header.prev_header_hash
|
||||
)
|
||||
|
||||
return heighest_block_height, header_hash_of_interest
|
||||
|
||||
async def get_spendable_coins_for_wallet(self, wallet_id: int, records=None) -> Set[WalletCoinRecord]:
|
||||
if self.peak is None:
|
||||
return set()
|
||||
|
|
|
|||
1
setup.py
1
setup.py
|
|
@ -75,6 +75,7 @@ kwargs = dict(
|
|||
"chia.wallet.puzzles",
|
||||
"chia.wallet.rl_wallet",
|
||||
"chia.wallet.cc_wallet",
|
||||
"chia.wallet.did_wallet",
|
||||
"chia.wallet.settings",
|
||||
"chia.wallet.trading",
|
||||
"chia.wallet.util",
|
||||
|
|
|
|||
|
|
@ -24,6 +24,8 @@ wallet_program_files = set(
|
|||
"chia/wallet/puzzles/rl_aggregation.clvm",
|
||||
"chia/wallet/puzzles/rl.clvm",
|
||||
"chia/wallet/puzzles/sha256tree_module.clvm",
|
||||
"chia/wallet/puzzles/singleton_top_layer.clvm",
|
||||
"chia/wallet/puzzles/did_innerpuz.clvm",
|
||||
]
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,619 @@
|
|||
import asyncio
|
||||
import time
|
||||
import pytest
|
||||
from chia.simulator.simulator_protocol import FarmNewBlockProtocol
|
||||
from chia.types.peer_info import PeerInfo
|
||||
from chia.util.ints import uint16, uint32, uint64
|
||||
from tests.setup_nodes import setup_simulators_and_wallets
|
||||
from chia.wallet.did_wallet.did_wallet import DIDWallet
|
||||
from chia.wallet.did_wallet import did_wallet_puzzles
|
||||
from clvm_tools import binutils
|
||||
from chia.types.blockchain_format.program import Program
|
||||
from chia.wallet.derivation_record import DerivationRecord
|
||||
from chia.types.coin_solution import CoinSolution
|
||||
from blspy import AugSchemeMPL
|
||||
from chia.types.spend_bundle import SpendBundle
|
||||
from chia.wallet.transaction_record import TransactionRecord
|
||||
from chia.wallet.derive_keys import master_sk_to_wallet_sk
|
||||
from chia.consensus.block_rewards import calculate_pool_reward, calculate_base_farmer_reward
|
||||
from tests.time_out_assert import time_out_assert
|
||||
from secrets import token_bytes
|
||||
from chia.wallet.util.transaction_type import TransactionType
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def event_loop():
|
||||
loop = asyncio.get_event_loop()
|
||||
yield loop
|
||||
|
||||
|
||||
class TestDIDWallet:
|
||||
@pytest.fixture(scope="function")
|
||||
async def wallet_node(self):
|
||||
async for _ in setup_simulators_and_wallets(1, 1, {}):
|
||||
yield _
|
||||
|
||||
@pytest.fixture(scope="function")
|
||||
async def two_wallet_nodes(self):
|
||||
async for _ in setup_simulators_and_wallets(1, 2, {}):
|
||||
yield _
|
||||
|
||||
@pytest.fixture(scope="function")
|
||||
async def two_wallet_nodes_five_freeze(self):
|
||||
async for _ in setup_simulators_and_wallets(1, 2, {}):
|
||||
yield _
|
||||
|
||||
@pytest.fixture(scope="function")
|
||||
async def three_sim_two_wallets(self):
|
||||
async for _ in setup_simulators_and_wallets(3, 2, {}):
|
||||
yield _
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_creation_from_backup_file(self, two_wallet_nodes):
|
||||
num_blocks = 5
|
||||
full_nodes, wallets = two_wallet_nodes
|
||||
full_node_api = full_nodes[0]
|
||||
full_node_server = full_node_api.server
|
||||
wallet_node_0, server_2 = wallets[0]
|
||||
wallet_node_1, server_3 = wallets[1]
|
||||
wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
|
||||
wallet_1 = wallet_node_1.wallet_state_manager.main_wallet
|
||||
|
||||
ph = await wallet_0.get_new_puzzlehash()
|
||||
|
||||
await server_2.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
|
||||
await server_3.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
funds = sum(
|
||||
[
|
||||
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
|
||||
for i in range(1, num_blocks - 1)
|
||||
]
|
||||
)
|
||||
|
||||
await time_out_assert(10, wallet_0.get_unconfirmed_balance, funds)
|
||||
await time_out_assert(10, wallet_0.get_confirmed_balance, funds)
|
||||
|
||||
# Wallet1 sets up DIDWallet1 without any backup set
|
||||
did_wallet_0: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node_0.wallet_state_manager, wallet_0, uint64(101)
|
||||
)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, did_wallet_0.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet_0.get_unconfirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet_0.get_pending_change_balance, 0)
|
||||
# Wallet1 sets up DIDWallet_1 with DIDWallet_0 as backup
|
||||
backup_ids = [bytes.fromhex(did_wallet_0.get_my_DID())]
|
||||
did_wallet_1: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node_0.wallet_state_manager, wallet_0, uint64(201), backup_ids
|
||||
)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, did_wallet_1.get_confirmed_balance, 201)
|
||||
await time_out_assert(15, did_wallet_1.get_unconfirmed_balance, 201)
|
||||
await time_out_assert(15, did_wallet_1.get_pending_change_balance, 0)
|
||||
|
||||
filename = "test.backup"
|
||||
did_wallet_1.create_backup(filename)
|
||||
|
||||
# Wallet2 recovers DIDWallet2 to a new set of keys
|
||||
did_wallet_2 = await DIDWallet.create_new_did_wallet_from_recovery(
|
||||
wallet_node_1.wallet_state_manager, wallet_1, filename
|
||||
)
|
||||
coins = await did_wallet_1.select_coins(1)
|
||||
coin = coins.copy().pop()
|
||||
assert did_wallet_2.did_info.temp_coin == coin
|
||||
newpuz = await did_wallet_2.get_new_puzzle()
|
||||
newpuzhash = newpuz.get_tree_hash()
|
||||
pubkey = bytes(
|
||||
(await did_wallet_2.wallet_state_manager.get_unused_derivation_record(did_wallet_2.wallet_info.id)).pubkey
|
||||
)
|
||||
message_spend_bundle = await did_wallet_0.create_attestment(
|
||||
did_wallet_2.did_info.temp_coin.name(), newpuzhash, pubkey, "test.attest"
|
||||
)
|
||||
print(f"pubkey: {pubkey}")
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
(
|
||||
test_info_list,
|
||||
test_message_spend_bundle,
|
||||
) = await did_wallet_2.load_attest_files_for_recovery_spend(["test.attest"])
|
||||
assert message_spend_bundle == test_message_spend_bundle
|
||||
|
||||
await did_wallet_2.recovery_spend(
|
||||
did_wallet_2.did_info.temp_coin,
|
||||
newpuzhash,
|
||||
test_info_list,
|
||||
pubkey,
|
||||
test_message_spend_bundle,
|
||||
)
|
||||
print(f"pubkey: {did_wallet_2}")
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(45, did_wallet_2.get_confirmed_balance, 201)
|
||||
await time_out_assert(45, did_wallet_2.get_unconfirmed_balance, 201)
|
||||
|
||||
# DIDWallet3 spends the money back to itself
|
||||
ph2 = await wallet_1.get_new_puzzlehash()
|
||||
await did_wallet_2.create_spend(ph2)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, wallet_1.get_confirmed_balance, 201)
|
||||
await time_out_assert(15, wallet_1.get_unconfirmed_balance, 201)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_did_recovery_with_multiple_backup_dids(self, two_wallet_nodes):
|
||||
num_blocks = 5
|
||||
full_nodes, wallets = two_wallet_nodes
|
||||
full_node_1 = full_nodes[0]
|
||||
server_1 = full_node_1.server
|
||||
wallet_node, server_2 = wallets[0]
|
||||
wallet_node_2, server_3 = wallets[1]
|
||||
wallet = wallet_node.wallet_state_manager.main_wallet
|
||||
wallet2 = wallet_node_2.wallet_state_manager.main_wallet
|
||||
|
||||
ph = await wallet.get_new_puzzlehash()
|
||||
|
||||
await server_2.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
await server_3.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
funds = sum(
|
||||
[
|
||||
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
|
||||
for i in range(1, num_blocks - 1)
|
||||
]
|
||||
)
|
||||
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, funds)
|
||||
|
||||
did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node.wallet_state_manager, wallet, uint64(101)
|
||||
)
|
||||
|
||||
ph = await wallet2.get_new_puzzlehash()
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
|
||||
|
||||
recovery_list = [bytes.fromhex(did_wallet.get_my_DID())]
|
||||
|
||||
did_wallet_2: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node_2.wallet_state_manager, wallet2, uint64(101), recovery_list
|
||||
)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, did_wallet_2.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet_2.get_unconfirmed_balance, 101)
|
||||
|
||||
assert did_wallet_2.did_info.backup_ids == recovery_list
|
||||
|
||||
recovery_list.append(bytes.fromhex(did_wallet_2.get_my_DID()))
|
||||
|
||||
did_wallet_3: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node_2.wallet_state_manager, wallet2, uint64(201), recovery_list
|
||||
)
|
||||
|
||||
ph2 = await wallet.get_new_puzzlehash()
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
|
||||
assert did_wallet_3.did_info.backup_ids == recovery_list
|
||||
await time_out_assert(15, did_wallet_3.get_confirmed_balance, 201)
|
||||
await time_out_assert(15, did_wallet_3.get_unconfirmed_balance, 201)
|
||||
coins = await did_wallet_3.select_coins(1)
|
||||
coin = coins.pop()
|
||||
pubkey = (
|
||||
await did_wallet_2.wallet_state_manager.get_unused_derivation_record(did_wallet_2.wallet_info.id)
|
||||
).pubkey
|
||||
message_spend_bundle = await did_wallet.create_attestment(coin.name(), ph, pubkey, "test1.attest")
|
||||
message_spend_bundle2 = await did_wallet_2.create_attestment(coin.name(), ph, pubkey, "test2.attest")
|
||||
message_spend_bundle = message_spend_bundle.aggregate([message_spend_bundle, message_spend_bundle2])
|
||||
|
||||
(
|
||||
test_info_list,
|
||||
test_message_spend_bundle,
|
||||
) = await did_wallet_3.load_attest_files_for_recovery_spend(["test1.attest", "test2.attest"])
|
||||
assert message_spend_bundle == test_message_spend_bundle
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
|
||||
await did_wallet_3.recovery_spend(coin, ph, test_info_list, pubkey, message_spend_bundle)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
# ends in 899 so it got the 201 back
|
||||
await time_out_assert(15, wallet2.get_confirmed_balance, 15999999999899)
|
||||
await time_out_assert(15, wallet2.get_unconfirmed_balance, 15999999999899)
|
||||
await time_out_assert(15, did_wallet_3.get_confirmed_balance, 0)
|
||||
await time_out_assert(15, did_wallet_3.get_unconfirmed_balance, 0)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_did_recovery_with_empty_set(self, two_wallet_nodes):
|
||||
num_blocks = 5
|
||||
full_nodes, wallets = two_wallet_nodes
|
||||
full_node_1 = full_nodes[0]
|
||||
server_1 = full_node_1.server
|
||||
wallet_node, server_2 = wallets[0]
|
||||
wallet_node_2, server_3 = wallets[1]
|
||||
wallet = wallet_node.wallet_state_manager.main_wallet
|
||||
|
||||
ph = await wallet.get_new_puzzlehash()
|
||||
|
||||
await server_2.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
await server_3.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
funds = sum(
|
||||
[
|
||||
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
|
||||
for i in range(1, num_blocks - 1)
|
||||
]
|
||||
)
|
||||
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, funds)
|
||||
|
||||
did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node.wallet_state_manager, wallet, uint64(101)
|
||||
)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
|
||||
coins = await did_wallet.select_coins(1)
|
||||
coin = coins.pop()
|
||||
info = Program.to([])
|
||||
pubkey = (await did_wallet.wallet_state_manager.get_unused_derivation_record(did_wallet.wallet_info.id)).pubkey
|
||||
spend_bundle = await did_wallet.recovery_spend(
|
||||
coin, ph, info, pubkey, SpendBundle([], AugSchemeMPL.aggregate([]))
|
||||
)
|
||||
additions = spend_bundle.additions()
|
||||
assert additions == []
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_did_attest_after_recovery(self, two_wallet_nodes):
|
||||
num_blocks = 5
|
||||
full_nodes, wallets = two_wallet_nodes
|
||||
full_node_1 = full_nodes[0]
|
||||
server_1 = full_node_1.server
|
||||
wallet_node, server_2 = wallets[0]
|
||||
wallet_node_2, server_3 = wallets[1]
|
||||
wallet = wallet_node.wallet_state_manager.main_wallet
|
||||
wallet2 = wallet_node_2.wallet_state_manager.main_wallet
|
||||
ph = await wallet.get_new_puzzlehash()
|
||||
|
||||
await server_2.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
await server_3.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
funds = sum(
|
||||
[
|
||||
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
|
||||
for i in range(1, num_blocks - 1)
|
||||
]
|
||||
)
|
||||
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, funds)
|
||||
|
||||
did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node.wallet_state_manager, wallet, uint64(101)
|
||||
)
|
||||
|
||||
ph2 = await wallet2.get_new_puzzlehash()
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
|
||||
recovery_list = [bytes.fromhex(did_wallet.get_my_DID())]
|
||||
|
||||
did_wallet_2: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node_2.wallet_state_manager, wallet2, uint64(101), recovery_list
|
||||
)
|
||||
ph = await wallet.get_new_puzzlehash()
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
await time_out_assert(15, did_wallet_2.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet_2.get_unconfirmed_balance, 101)
|
||||
assert did_wallet_2.did_info.backup_ids == recovery_list
|
||||
|
||||
# Update coin with new ID info
|
||||
recovery_list = [bytes.fromhex(did_wallet_2.get_my_DID())]
|
||||
await did_wallet.update_recovery_list(recovery_list, uint64(1))
|
||||
assert did_wallet.did_info.backup_ids == recovery_list
|
||||
updated_puz = await did_wallet.get_new_puzzle()
|
||||
await did_wallet.create_spend(updated_puz.get_tree_hash())
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
|
||||
|
||||
# DID Wallet 2 recovers into itself with new innerpuz
|
||||
new_puz = await did_wallet_2.get_new_puzzle()
|
||||
new_ph = new_puz.get_tree_hash()
|
||||
coins = await did_wallet_2.select_coins(1)
|
||||
coin = coins.pop()
|
||||
pubkey = (
|
||||
await did_wallet_2.wallet_state_manager.get_unused_derivation_record(did_wallet_2.wallet_info.id)
|
||||
).pubkey
|
||||
message_spend_bundle = await did_wallet.create_attestment(coin.name(), new_ph, pubkey, "test.attest")
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
|
||||
(
|
||||
info,
|
||||
message_spend_bundle,
|
||||
) = await did_wallet_2.load_attest_files_for_recovery_spend(["test.attest"])
|
||||
await did_wallet_2.recovery_spend(coin, new_ph, info, pubkey, message_spend_bundle)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, did_wallet_2.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet_2.get_unconfirmed_balance, 101)
|
||||
|
||||
# Recovery spend
|
||||
coins = await did_wallet.select_coins(1)
|
||||
coin = coins.pop()
|
||||
|
||||
pubkey = (await did_wallet.wallet_state_manager.get_unused_derivation_record(did_wallet.wallet_info.id)).pubkey
|
||||
await did_wallet_2.create_attestment(coin.name(), ph, pubkey, "test.attest")
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
(
|
||||
test_info_list,
|
||||
test_message_spend_bundle,
|
||||
) = await did_wallet.load_attest_files_for_recovery_spend(["test.attest"])
|
||||
await did_wallet.recovery_spend(coin, ph, test_info_list, pubkey, test_message_spend_bundle)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, 30000000000000)
|
||||
await time_out_assert(15, wallet.get_unconfirmed_balance, 30000000000000)
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 0)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 0)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_make_double_output(self, two_wallet_nodes):
|
||||
num_blocks = 5
|
||||
full_nodes, wallets = two_wallet_nodes
|
||||
full_node_1 = full_nodes[0]
|
||||
server_1 = full_node_1.server
|
||||
wallet_node, server_2 = wallets[0]
|
||||
wallet_node_2, server_3 = wallets[1]
|
||||
wallet = wallet_node.wallet_state_manager.main_wallet
|
||||
wallet2 = wallet_node_2.wallet_state_manager.main_wallet
|
||||
ph = await wallet.get_new_puzzlehash()
|
||||
|
||||
await server_2.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
await server_3.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
funds = sum(
|
||||
[
|
||||
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
|
||||
for i in range(1, num_blocks - 1)
|
||||
]
|
||||
)
|
||||
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, funds)
|
||||
|
||||
did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node.wallet_state_manager, wallet, uint64(101)
|
||||
)
|
||||
ph2 = await wallet2.get_new_puzzlehash()
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_spendable_balance, 101)
|
||||
|
||||
# Lock up with non DID innerpuz so that we can create two outputs
|
||||
# Innerpuz will output the innersol, so we just pass in ((51 0xMyPuz 49) (51 0xMyPuz 51))
|
||||
innerpuz = Program.to(binutils.assemble("1"))
|
||||
innerpuzhash = innerpuz.get_tree_hash()
|
||||
|
||||
puz = did_wallet_puzzles.create_fullpuz(
|
||||
innerpuzhash,
|
||||
did_wallet.did_info.my_did,
|
||||
)
|
||||
|
||||
# Add the hacked puzzle to the puzzle store so that it is recognised as "our" puzzle
|
||||
old_devrec = await did_wallet.wallet_state_manager.get_unused_derivation_record(did_wallet.wallet_info.id)
|
||||
devrec = DerivationRecord(
|
||||
old_devrec.index,
|
||||
puz.get_tree_hash(),
|
||||
old_devrec.pubkey,
|
||||
old_devrec.wallet_type,
|
||||
old_devrec.wallet_id,
|
||||
)
|
||||
await did_wallet.wallet_state_manager.puzzle_store.add_derivation_paths([devrec])
|
||||
await did_wallet.create_spend(puz.get_tree_hash())
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_spendable_balance, 101)
|
||||
|
||||
# Create spend by hand so that we can use the weird innersol
|
||||
coins = await did_wallet.select_coins(1)
|
||||
coin = coins.pop()
|
||||
# innerpuz is our desired output
|
||||
innersol = Program.to([[51, coin.puzzle_hash, 45], [51, coin.puzzle_hash, 56]])
|
||||
# full solution is (corehash parent_info my_amount innerpuz_reveal solution)
|
||||
parent_info = await did_wallet.get_parent_for_coin(coin)
|
||||
fullsol = Program.to(
|
||||
[
|
||||
[
|
||||
parent_info.parent_name,
|
||||
parent_info.inner_puzzle_hash,
|
||||
parent_info.amount,
|
||||
],
|
||||
coin.amount,
|
||||
innersol,
|
||||
]
|
||||
)
|
||||
try:
|
||||
cost, result = puz.run_with_cost(fullsol)
|
||||
except Exception as e:
|
||||
assert e.args == ("path into atom",)
|
||||
else:
|
||||
assert False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_make_fake_coin(self, two_wallet_nodes):
|
||||
num_blocks = 5
|
||||
full_nodes, wallets = two_wallet_nodes
|
||||
full_node_1 = full_nodes[0]
|
||||
server_1 = full_node_1.server
|
||||
wallet_node, server_2 = wallets[0]
|
||||
wallet_node_2, server_3 = wallets[1]
|
||||
await server_2.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
wallet = wallet_node.wallet_state_manager.main_wallet
|
||||
wallet2 = wallet_node_2.wallet_state_manager.main_wallet
|
||||
ph = await wallet.get_new_puzzlehash()
|
||||
|
||||
await server_3.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
funds = sum(
|
||||
[
|
||||
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
|
||||
for i in range(1, num_blocks - 1)
|
||||
]
|
||||
)
|
||||
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, funds)
|
||||
|
||||
did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
|
||||
wallet_node.wallet_state_manager, wallet, uint64(101)
|
||||
)
|
||||
ph2 = await wallet2.get_new_puzzlehash()
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph2))
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
|
||||
await time_out_assert(15, did_wallet.get_spendable_balance, 101)
|
||||
|
||||
coins = await did_wallet.select_coins(1)
|
||||
coin = coins.pop()
|
||||
|
||||
# copy info for later
|
||||
parent_info = await did_wallet.get_parent_for_coin(coin)
|
||||
id_puzhash = coin.puzzle_hash
|
||||
|
||||
await did_wallet.create_spend(ph)
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
await time_out_assert(15, did_wallet.get_confirmed_balance, 0)
|
||||
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 0)
|
||||
|
||||
tx_record = await wallet.generate_signed_transaction(101, id_puzhash)
|
||||
await wallet.push_transaction(tx_record)
|
||||
|
||||
for i in range(1, num_blocks):
|
||||
await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(ph))
|
||||
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, 21999999999899)
|
||||
await time_out_assert(15, wallet.get_unconfirmed_balance, 21999999999899)
|
||||
|
||||
coins = await did_wallet.select_coins(1)
|
||||
assert len(coins) >= 1
|
||||
|
||||
coin = coins.pop()
|
||||
|
||||
# Write spend by hand
|
||||
# innerpuz solution is (mode amount new_puz identity my_puz)
|
||||
innersol = Program.to([0, coin.amount, ph, coin.name(), coin.puzzle_hash])
|
||||
# full solution is (corehash parent_info my_amount innerpuz_reveal solution)
|
||||
innerpuz = did_wallet.did_info.current_inner
|
||||
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
|
||||
innerpuz,
|
||||
did_wallet.did_info.my_did,
|
||||
)
|
||||
fullsol = Program.to(
|
||||
[
|
||||
[
|
||||
parent_info.parent_name,
|
||||
parent_info.inner_puzzle_hash,
|
||||
parent_info.amount,
|
||||
],
|
||||
coin.amount,
|
||||
innersol,
|
||||
]
|
||||
)
|
||||
|
||||
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
|
||||
# sign for AGG_SIG_ME
|
||||
message = bytes(coin.puzzle_hash) + bytes(coin.name())
|
||||
pubkey = did_wallet_puzzles.get_pubkey_from_innerpuz(innerpuz)
|
||||
index = await did_wallet.wallet_state_manager.puzzle_store.index_for_pubkey(pubkey)
|
||||
private = master_sk_to_wallet_sk(did_wallet.wallet_state_manager.private_key, index)
|
||||
signature = AugSchemeMPL.sign(private, message)
|
||||
sigs = [signature]
|
||||
aggsig = AugSchemeMPL.aggregate(sigs)
|
||||
spend_bundle = SpendBundle(list_of_solutions, aggsig)
|
||||
|
||||
did_record = TransactionRecord(
|
||||
confirmed_at_height=uint32(0),
|
||||
created_at_time=uint64(int(time.time())),
|
||||
to_puzzle_hash=ph,
|
||||
amount=uint64(coin.amount),
|
||||
fee_amount=uint64(0),
|
||||
confirmed=False,
|
||||
sent=uint32(0),
|
||||
spend_bundle=spend_bundle,
|
||||
additions=spend_bundle.additions(),
|
||||
removals=spend_bundle.removals(),
|
||||
wallet_id=did_wallet.wallet_info.id,
|
||||
sent_to=[],
|
||||
trade_id=None,
|
||||
type=uint32(TransactionType.OUTGOING_TX.value),
|
||||
name=token_bytes(),
|
||||
)
|
||||
|
||||
await did_wallet.standard_wallet.push_transaction(did_record)
|
||||
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, 21999999999899)
|
||||
await time_out_assert(15, wallet.get_unconfirmed_balance, 21999999999899)
|
||||
ph2 = Program.to(binutils.assemble("()")).get_tree_hash()
|
||||
for i in range(1, num_blocks + 3):
|
||||
await full_node_1.farm_new_block(FarmNewBlockProtocol(ph2))
|
||||
# It ends in 900 so it's not gone through
|
||||
# Assert coin ID is failing
|
||||
await time_out_assert(15, wallet.get_confirmed_balance, 23999999999899)
|
||||
await time_out_assert(15, wallet.get_unconfirmed_balance, 23999999999899)
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
from chia.wallet.puzzles.load_clvm import load_clvm
|
||||
from chia.types.blockchain_format.program import Program
|
||||
|
||||
DID_CORE_MOD = load_clvm("singleton_top_layer.clvm")
|
||||
|
||||
|
||||
def test_only_odd_coins():
|
||||
did_core_hash = DID_CORE_MOD.get_tree_hash()
|
||||
solution = Program.to(
|
||||
[did_core_hash, did_core_hash, 1, [0xDEADBEEF, 0xCAFEF00D, 200], 200, [[51, 0xCAFEF00D, 200]]]
|
||||
)
|
||||
try:
|
||||
result, cost = DID_CORE_MOD.run_with_cost(solution)
|
||||
except Exception as e:
|
||||
assert e.args == ("clvm raise",)
|
||||
else:
|
||||
assert False
|
||||
solution = Program.to(
|
||||
[did_core_hash, did_core_hash, 1, [0xDEADBEEF, 0xCAFEF00D, 210], 205, [[51, 0xCAFEF00D, 205]]]
|
||||
)
|
||||
try:
|
||||
result, cost = DID_CORE_MOD.run_with_cost(solution)
|
||||
except Exception:
|
||||
assert False
|
||||
|
||||
|
||||
def test_only_one_odd_coin_created():
|
||||
did_core_hash = DID_CORE_MOD.get_tree_hash()
|
||||
solution = Program.to(
|
||||
[
|
||||
did_core_hash,
|
||||
did_core_hash,
|
||||
1,
|
||||
[0xDEADBEEF, 0xCAFEF00D, 411],
|
||||
411,
|
||||
[[51, 0xCAFEF00D, 203], [51, 0xFADEDDAB, 203]],
|
||||
]
|
||||
)
|
||||
try:
|
||||
result, cost = DID_CORE_MOD.run_with_cost(solution)
|
||||
except Exception as e:
|
||||
assert e.args == ("clvm raise",)
|
||||
else:
|
||||
assert False
|
||||
solution = Program.to(
|
||||
[
|
||||
did_core_hash,
|
||||
did_core_hash,
|
||||
1,
|
||||
[0xDEADBEEF, 0xCAFEF00D, 411],
|
||||
411,
|
||||
[[51, 0xCAFEF00D, 203], [51, 0xFADEDDAB, 202], [51, 0xFADEDDAB, 4]],
|
||||
]
|
||||
)
|
||||
try:
|
||||
result, cost = DID_CORE_MOD.run_with_cost(solution)
|
||||
except Exception:
|
||||
assert False
|
||||
Loading…
Reference in New Issue