def test_assert_my_id(self):
run = asyncio.get_event_loop().run_until_complete
remote = make_client_server()
puzzle_program = p2_delegated_conditions.puzzle_for_pk(
public_key_bytes_for_index(8))
puzzle_hash = ProgramHash(puzzle_program)
coin_1 = farm_spendable_coin(remote, puzzle_hash)
coin_2 = farm_spendable_coin(remote, puzzle_hash)
coin_3 = farm_spendable_coin(remote, puzzle_hash)
conditions_coin_1 = [make_assert_my_coin_id_condition(coin_1.name())]
solution_1 = p2_delegated_conditions.solution_for_conditions(
puzzle_program, conditions_coin_1)
spend_bundle = build_spend_bundle(coin_1, solution_1)
r = run(remote.push_tx(tx=spend_bundle))
assert r["response"].startswith("accepted")
spend_bundle = build_spend_bundle(coin_2, solution_1)
r = run(remote.push_tx(tx=spend_bundle))
assert r.args[0].startswith(
"exception: (<Err.ASSERT_MY_COIN_ID_FAILED")
spend_bundle = build_spend_bundle(coin_3, solution_1)
r = run(remote.push_tx(tx=spend_bundle))
assert r.args[0].startswith(
"exception: (<Err.ASSERT_MY_COIN_ID_FAILED")
def make_solution(self, primaries=[], min_time=0, me={}, consumed=[]):
ret = []
for primary in primaries:
ret.append(make_create_coin_condition(
primary['puzzlehash'], primary['amount']))
for coin in consumed:
ret.append(make_assert_coin_consumed_condition(coin))
if min_time > 0:
ret.append(make_assert_min_time_condition(min_time))
if me:
ret.append(make_assert_my_coin_id_condition(me['id']))
return clvm.to_sexp_f([puzzle_for_conditions(ret), []])
def solution_maker(coin, remote):
print(coin.name())
if fuzz_coin:
coin = fuzz_coin(remote, puzzle_hash)
print(coin.name())
id_condition = make_assert_my_coin_id_condition(coin.name())
delegated_puzzle = p2_conditions.puzzle_for_conditions(
conditions + [id_condition])
delegated_solution = p2_delegated_conditions.solution_for_conditions(
delegated_puzzle, [])
solution = p2_m_of_n_delegate_direct.solution_for_delegated_puzzle(
M, pks, selectors, delegated_puzzle, delegated_solution)
return solution
def make_solution(parent,
puzzlehash,
value,
stake_factor,
primaries=[],
min_time=0,
me={},
recovery=False):
conditions = []
for primary in primaries:
conditions.append(
make_create_coin_condition(primary['puzzlehash'],
primary['amount']))
if min_time > 0:
conditions.append(make_assert_min_time_condition(min_time))
if me:
conditions.append(make_assert_my_coin_id_condition(me['id']))
conditions = [binutils.assemble("#q"), conditions]
solution = [
conditions, [], 1 if recovery else 0, parent, puzzlehash, value,
math.floor(value * stake_factor)
]
program = Program(to_sexp_f(solution))
return program
def solution_maker(coin, remote):
if fuzz_coin:
coin = fuzz_coin(remote, puzzle_hash)
id_condition = make_assert_my_coin_id_condition(coin.name())
return p2_delegated_conditions.solution_for_conditions(
puzzle_program, conditions + [id_condition])