async def coin_added(
self, coin: Coin, height: int, header_hash: bytes32, removals: List[Coin]
):
""" Notification from wallet state manager that wallet has been received. """
self.log.info("CC wallet has been notified that coin was added")
search_for_parent: bool = True
inner_puzzle = await self.inner_puzzle_for_cc_puzzle(coin.puzzle_hash)
future_parent = CCParent(
coin.parent_coin_info, inner_puzzle.get_tree_hash(), coin.amount
)
await self.add_parent(coin.name(), future_parent)
for name, ccparent in self.cc_info.parent_info:
if coin.parent_coin_info == name:
search_for_parent = False
break
# breakpoint()
if search_for_parent:
data: Dict[str, Any] = {
"data": {
"action_data": {
"api_name": "request_generator",
"height": height,
"header_hash": header_hash,
}
}
}
data_str = dict_to_json_str(data)
await self.wallet_state_manager.create_action(
name="request_generator",
wallet_id=self.wallet_info.id,
type=self.wallet_info.type,
callback="generator_received",
done=False,
data=data_str,
)
async def generate_zero_val_coin(
self,
send=True,
exclude: List[Coin] = None) -> Optional[SpendBundle]:
if self.cc_info.my_core is None:
return None
if exclude is None:
exclude = []
coins = await self.standard_wallet.select_coins(0, exclude)
if coins == set() or coins is None:
return None
origin = coins.copy().pop()
origin_id = origin.name()
parent_info = {}
parent_info[origin_id] = (
origin.parent_coin_info,
origin.puzzle_hash,
origin.amount,
)
cc_inner = await self.get_new_inner_hash()
cc_puzzle = cc_wallet_puzzles.cc_make_puzzle(cc_inner,
self.cc_info.my_core)
cc_puzzle_hash = cc_puzzle.get_tree_hash()
tx = await self.standard_wallet.generate_signed_transaction(
uint64(0), cc_puzzle_hash, uint64(0), origin_id, coins)
self.log.info(
f"Generate zero val coin: cc_puzzle_hash is {cc_puzzle_hash}")
eve_coin = Coin(origin_id, cc_puzzle_hash, uint64(0))
if tx is None or tx.spend_bundle is None:
return None
eve_spend = cc_generate_eve_spend(eve_coin, cc_puzzle)
full_spend = SpendBundle.aggregate([tx.spend_bundle, eve_spend])
future_parent = CCParent(eve_coin.parent_coin_info, cc_inner,
eve_coin.amount)
eve_parent = CCParent(origin.parent_coin_info, origin.puzzle_hash,
origin.amount)
await self.add_parent(eve_coin.name(), future_parent)
await self.add_parent(eve_coin.parent_coin_info, eve_parent)
if send:
regular_record = TransactionRecord(
confirmed_at_index=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=cc_puzzle_hash,
amount=uint64(0),
fee_amount=uint64(0),
incoming=False,
confirmed=False,
sent=uint32(10),
spend_bundle=full_spend,
additions=full_spend.additions(),
removals=full_spend.removals(),
wallet_id=uint32(1),
sent_to=[],
trade_id=None,
)
cc_record = TransactionRecord(
confirmed_at_index=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=cc_puzzle_hash,
amount=uint64(0),
fee_amount=uint64(0),
incoming=True,
confirmed=False,
sent=uint32(0),
spend_bundle=full_spend,
additions=full_spend.additions(),
removals=full_spend.removals(),
wallet_id=self.wallet_info.id,
sent_to=[],
trade_id=None,
)
await self.wallet_state_manager.add_transaction(regular_record)
await self.wallet_state_manager.add_pending_transaction(cc_record)
return full_spend
async def search_for_parent_info(self, block_program: Program,
removals: List[Coin]) -> bool:
"""
Returns an error if it's unable to evaluate, otherwise
returns a list of NPC (coin_name, solved_puzzle_hash, conditions_dict)
"""
cost_sum = 0
try:
cost_run, sexp = run_program(block_program, [])
cost_sum += cost_run
except EvalError:
return False
for name_solution in sexp.as_iter():
_ = name_solution.as_python()
if len(_) != 2:
return False
if not isinstance(_[0], bytes) or len(_[0]) != 32:
return False
coin_name = bytes32(_[0])
if not isinstance(_[1], list) or len(_[1]) != 2:
return False
puzzle_solution_program = name_solution.rest().first()
puzzle_program = puzzle_solution_program.first()
try:
error, conditions_dict, cost_run = conditions_dict_for_solution(
puzzle_solution_program)
cost_sum += cost_run
if error:
return False
except EvalError:
return False
if conditions_dict is None:
conditions_dict = {}
if ConditionOpcode.CREATE_COIN in conditions_dict:
created_output_conditions = conditions_dict[
ConditionOpcode.CREATE_COIN]
else:
continue
for cvp in created_output_conditions:
result = await self.wallet_state_manager.puzzle_store.wallet_info_for_puzzle_hash(
cvp.var1)
if result is None:
continue
wallet_id, wallet_type = result
if wallet_id != self.wallet_info.id:
continue
coin = None
for removed in removals:
if removed.name() == coin_name:
coin = removed
break
if coin is not None:
if cc_wallet_puzzles.check_is_cc_puzzle(puzzle_program):
puzzle_string = binutils.disassemble(puzzle_program)
inner_puzzle_hash = hexstr_to_bytes(
get_innerpuzzle_from_puzzle(puzzle_string))
self.log.info(
f"parent: {coin_name} inner_puzzle for parent is {inner_puzzle_hash.hex()}"
)
await self.add_parent(
coin_name,
CCParent(coin.parent_coin_info, inner_puzzle_hash,
coin.amount),
)
return True
return False