def make_solution(self, condition_dic: Dict[ConditionOpcode,
List[ConditionVarPair]]):
ret = []
for con_list in condition_dic.values():
for cvp in con_list:
if cvp.opcode == ConditionOpcode.CREATE_COIN:
ret.append(make_create_coin_condition(cvp.var1, cvp.var2))
if cvp.opcode == ConditionOpcode.AGG_SIG:
ret.append(make_assert_aggsig_condition(cvp.var1))
if cvp.opcode == ConditionOpcode.ASSERT_COIN_CONSUMED:
ret.append(make_assert_coin_consumed_condition(cvp.var1))
if cvp.opcode == ConditionOpcode.ASSERT_TIME_EXCEEDS:
ret.append(make_assert_time_exceeds_condition(cvp.var1))
if cvp.opcode == ConditionOpcode.ASSERT_MY_COIN_ID:
ret.append(make_assert_my_coin_id_condition(cvp.var1))
if cvp.opcode == ConditionOpcode.ASSERT_BLOCK_INDEX_EXCEEDS:
ret.append(
make_assert_block_index_exceeds_condition(cvp.var1))
if cvp.opcode == ConditionOpcode.ASSERT_BLOCK_AGE_EXCEEDS:
ret.append(
make_assert_block_age_exceeds_condition(cvp.var1))
if cvp.opcode == ConditionOpcode.ASSERT_FEE:
ret.append(make_assert_fee_condition(cvp.var1))
return Program.to([puzzle_for_conditions(ret), []])
def test_p2_conditions(self):
key_lookup = KeyTool()
payments, conditions = default_payments_and_conditions(1, key_lookup)
puzzle = p2_conditions.puzzle_for_conditions(conditions)
solution = p2_conditions.solution_for_conditions(conditions)
do_test_spend(puzzle, solution, payments, key_lookup)
def do_test_spend_p2_delegated_puzzle_or_hidden_puzzle_with_delegated_puzzle(
self, hidden_pub_key_index):
key_lookup = KeyTool()
payments, conditions = default_payments_and_conditions(1, key_lookup)
hidden_puzzle = p2_conditions.puzzle_for_conditions(conditions)
hidden_public_key = public_key_for_index(hidden_pub_key_index,
key_lookup)
puzzle = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_public_key_and_hidden_puzzle(
hidden_public_key, hidden_puzzle)
payable_payments, payable_conditions = default_payments_and_conditions(
5, key_lookup)
delegated_puzzle = p2_conditions.puzzle_for_conditions(
payable_conditions)
delegated_solution = []
synthetic_public_key = p2_delegated_puzzle_or_hidden_puzzle.calculate_synthetic_public_key(
hidden_public_key, hidden_puzzle.get_tree_hash())
solution = p2_delegated_puzzle_or_hidden_puzzle.solution_for_delegated_puzzle(
delegated_puzzle, delegated_solution)
hidden_puzzle_hash = hidden_puzzle.get_tree_hash()
synthetic_offset = p2_delegated_puzzle_or_hidden_puzzle.calculate_synthetic_offset(
hidden_public_key, hidden_puzzle_hash)
hidden_pub_key_point = G1Element.from_bytes(hidden_public_key)
assert synthetic_public_key == int_to_public_key(
synthetic_offset) + hidden_pub_key_point
secret_exponent = key_lookup.get(hidden_public_key)
assert int_to_public_key(secret_exponent) == hidden_pub_key_point
synthetic_secret_exponent = secret_exponent + synthetic_offset
key_lookup.add_secret_exponents([synthetic_secret_exponent])
do_test_spend(puzzle, solution, payable_payments, key_lookup)
def test_p2_delegated_puzzle_or_hidden_puzzle_with_hidden_puzzle(self):
key_lookup = KeyTool()
payments, conditions = default_payments_and_conditions(1, key_lookup)
hidden_puzzle = p2_conditions.puzzle_for_conditions(conditions)
hidden_public_key = public_key_for_index(10, key_lookup)
puzzle = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_public_key_and_hidden_puzzle(
hidden_public_key, hidden_puzzle)
solution = p2_delegated_puzzle_or_hidden_puzzle.solution_for_hidden_puzzle(
hidden_public_key, hidden_puzzle, Program.to(0))
do_test_spend(puzzle, solution, payments, key_lookup)
def test_p2_m_of_n_delegated_puzzle(self):
key_lookup = KeyTool()
payments, conditions = default_payments_and_conditions(1, key_lookup)
pks = [public_key_for_index(_, key_lookup) for _ in range(1, 6)]
M = 3
delegated_puzzle = p2_conditions.puzzle_for_conditions(conditions)
delegated_solution = []
puzzle_program = p2_m_of_n_delegate_direct.puzzle_for_m_of_public_key_list(M, pks)
selectors = [1, [], [], 1, 1]
solution = p2_m_of_n_delegate_direct.solution_for_delegated_puzzle(
M, selectors, delegated_puzzle, delegated_solution
)
do_test_spend(puzzle_program, solution, payments, key_lookup)
def make_solution(
self, primaries=None, min_time=0, me=None, consumed=None, fee=None
):
condition_list = []
if primaries:
for primary in primaries:
condition_list.append(
make_create_coin_condition(primary["puzzlehash"], primary["amount"])
)
if consumed:
for coin in consumed:
condition_list.append(make_assert_coin_consumed_condition(coin))
if min_time > 0:
condition_list.append(make_assert_time_exceeds_condition(min_time))
if me:
condition_list.append(make_assert_my_coin_id_condition(me["id"]))
if fee:
condition_list.append(make_assert_fee_condition(fee))
return Program.to([puzzle_for_conditions(condition_list), []])
