def run_and_return_cost_time(chialisp):
start = time.time()
clvm_loop = "((c (q ((c (f (a)) (c (f (a)) (c (f (r (a))) (c (f (r (r (a))))"
" (q ()))))))) (c (q ((c (i (f (r (a))) (q (i (q 1) ((c (f (a)) (c (f (a))"
" (c (- (f (r (a))) (q 1)) (c (f (r (r (a)))) (q ()))))))"
" ((c (f (r (r (a)))) (q ()))))) (q (q ()))) (a)))) (a))))"
loop_program = Program(binutils.assemble(clvm_loop))
clvm_loop_solution = f"(1000 {chialisp})"
solution_program = Program(binutils.assemble(clvm_loop_solution))
cost, sexp = loop_program.run_with_cost(solution_program)
end = time.time()
total_time = end - start
return cost, total_time
def get_name_puzzle_conditions(
block_program: Program, ) -> Tuple[Optional[Err], List[NPC], uint64]:
"""
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 = block_program.run_with_cost([])
cost_sum += cost_run
except Program.EvalError:
return Err.INVALID_COIN_SOLUTION, [], uint64(0)
npc_list = []
for name_solution in sexp.as_iter():
_ = name_solution.as_python()
if len(_) != 2:
return Err.INVALID_COIN_SOLUTION, [], uint64(cost_sum)
if not isinstance(_[0], bytes) or len(_[0]) != 32:
return Err.INVALID_COIN_SOLUTION, [], uint64(cost_sum)
coin_name = bytes32(_[0])
if not isinstance(_[1], list) or len(_[1]) != 2:
return Err.INVALID_COIN_SOLUTION, [], uint64(cost_sum)
puzzle_solution_program = name_solution.rest().first()
puzzle_program = puzzle_solution_program.first()
puzzle_hash = Program(puzzle_program).get_tree_hash()
try:
error, conditions_dict, cost_run = conditions_dict_for_solution(
puzzle_solution_program)
cost_sum += cost_run
if error:
return error, [], uint64(cost_sum)
except Program.EvalError:
return Err.INVALID_COIN_SOLUTION, [], uint64(cost_sum)
if conditions_dict is None:
conditions_dict = {}
npc: NPC = NPC(coin_name, puzzle_hash, conditions_dict)
npc_list.append(npc)
return None, npc_list, uint64(cost_sum)
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 = block_program.run_with_cost([])
cost_sum += cost_run
except Program.EvalError:
return False
parents = []
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 Program.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.id():
continue
coin = None
for removed in removals:
if removed.name() == coin_name:
coin = removed
break
if coin is not None:
r = uncurry_cc(puzzle_program)
if r is not None:
mod_hash, genesis_coin_checker, inner_puzzle = r
self.log.info(
f"parent: {coin_name} inner_puzzle for parent is {inner_puzzle}"
)
lineage_proof = get_lineage_proof_from_coin_and_puz(
coin, puzzle_program)
parents.append(lineage_proof)
await self.add_lineage(coin_name, lineage_proof)
return len(parents) > 0
