def make_solution(
self,
primaries: Optional[List[Dict[str, Any]]] = None,
min_time=0,
me=None,
coin_announcements=None,
coin_announcements_to_assert=None,
puzzle_announcements=None,
puzzle_announcements_to_assert=None,
fee=0,
) -> Program:
assert fee >= 0
condition_list = []
if primaries:
for primary in primaries:
condition_list.append(make_create_coin_condition(primary["puzzlehash"], primary["amount"]))
if min_time > 0:
condition_list.append(make_assert_seconds_now_exceeds_condition(min_time))
if me:
condition_list.append(make_assert_my_coin_id_condition(me["id"]))
if fee:
condition_list.append(make_reserve_fee_condition(fee))
if coin_announcements:
for announcement in coin_announcements:
condition_list.append(make_create_coin_announcement(announcement))
if coin_announcements_to_assert:
for announcement_hash in coin_announcements_to_assert:
condition_list.append(make_assert_coin_announcement(announcement_hash))
if puzzle_announcements:
for announcement in puzzle_announcements:
condition_list.append(make_create_puzzle_announcement(announcement))
if puzzle_announcements_to_assert:
for announcement_hash in puzzle_announcements_to_assert:
condition_list.append(make_assert_puzzle_announcement(announcement_hash))
return solution_for_conditions(condition_list)
async def test_standard_tx(self):
# this isn't a real public key, but we don't care
public_key = bytes.fromhex(
"af949b78fa6a957602c3593a3d6cb7711e08720415dad83"
"1ab18adacaa9b27ec3dda508ee32e24bc811c0abc5781ae21")
puzzle_program = SerializedProgram.from_bytes(
p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_pk(public_key))
conditions = binutils.assemble(
"((51 0x699eca24f2b6f4b25b16f7a418d0dc4fc5fce3b9145aecdda184158927738e3e 10)"
" (51 0x847bb2385534070c39a39cc5dfdc7b35e2db472dc0ab10ab4dec157a2178adbf 0x00cbba106df6))"
)
solution_program = SerializedProgram.from_bytes(
p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(
conditions))
time_start = time.time()
total_cost = 0
for i in range(0, 1000):
cost, result = puzzle_program.run_with_cost(
test_constants.MAX_BLOCK_COST_CLVM, solution_program)
total_cost += cost
time_end = time.time()
duration = time_end - time_start
log.info(f"Time spent: {duration}")
assert duration < 3
def make_solution(self, condition_dic: Dict[ConditionOpcode, List[ConditionWithArgs]]) -> Program:
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.vars[0], cvp.vars[1]))
if cvp.opcode == ConditionOpcode.CREATE_ANNOUNCEMENT:
ret.append(make_create_announcement(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.AGG_SIG:
ret.append(make_assert_aggsig_condition(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.ASSERT_ANNOUNCEMENT:
ret.append(make_assert_announcement(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.ASSERT_SECONDS_NOW_EXCEEDS:
ret.append(make_assert_seconds_now_exceeds_condition(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.ASSERT_MY_COIN_ID:
ret.append(make_assert_my_coin_id_condition(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.ASSERT_HEIGHT_NOW_EXCEEDS:
ret.append(make_assert_height_now_exceeds_condition(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.ASSERT_HEIGHT_AGE_EXCEEDS:
ret.append(make_assert_height_age_exceeds_condition(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.RESERVE_FEE:
ret.append(make_reserve_fee_condition(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.ASSERT_MY_PARENT_ID:
ret.append(make_assert_my_parent_id(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.ASSERT_MY_PUZZLEHASH:
ret.append(make_assert_my_puzzlehash(cvp.vars[0]))
if cvp.opcode == ConditionOpcode.ASSERT_MY_AMOUNT:
ret.append(make_assert_my_amount(cvp.vars[0]))
return solution_for_conditions(Program.to(ret))
def make_solution(
self, condition_dic: Dict[ConditionOpcode,
List[ConditionWithArgs]]) -> Program:
ret = []
for con_list in condition_dic.values():
for cvp in con_list:
ret.append([cvp.opcode.value] + cvp.vars)
return solution_for_conditions(Program.to(ret))
def make_solution(self, condition_dic: Dict[ConditionOpcode, List[ConditionWithArgs]]) -> Program:
ret = []
for con_list in condition_dic.values():
for cvp in con_list:
if cvp.opcode == ConditionOpcode.CREATE_COIN and len(cvp.vars) > 2:
formatted: List[Any] = []
formatted.extend(cvp.vars)
formatted[2] = cvp.vars[2:]
ret.append([cvp.opcode.value] + formatted)
else:
ret.append([cvp.opcode.value] + cvp.vars)
return solution_for_conditions(Program.to(ret))
def make_block_generator(count: int) -> SerializedProgram:
puzzle_hash_db: Dict = dict()
coins = [make_fake_coin(_, puzzle_hash_db) for _ in range(count)]
coin_solutions = []
for coin in coins:
puzzle_reveal = puzzle_hash_db[coin.puzzle_hash]
conditions = conditions_for_payment(coin)
solution = solution_for_conditions(conditions)
coin_solution = CoinSolution(coin, puzzle_reveal, solution)
coin_solutions.append(coin_solution)
spend_bundle = SpendBundle(coin_solutions, blspy.G2Element())
return best_solution_program(spend_bundle)
def make_spend_bundle(count: int) -> SpendBundle:
puzzle_hash_db: Dict = dict()
coins = [make_fake_coin(_, puzzle_hash_db) for _ in range(count)]
coin_spends = []
for coin in coins:
puzzle_reveal = puzzle_hash_db[coin.puzzle_hash]
conditions = conditions_for_payment(coin)
solution = solution_for_conditions(conditions)
coin_spend = CoinSpend(coin, puzzle_reveal, solution)
coin_spends.append(coin_spend)
spend_bundle = SpendBundle(coin_spends, blspy.G2Element())
return spend_bundle
def make_solution(
self,
primaries: List[AmountWithPuzzlehash],
min_time=0,
me=None,
coin_announcements: Optional[Set[bytes]] = None,
coin_announcements_to_assert: Optional[Set[bytes32]] = None,
puzzle_announcements: Optional[Set[bytes32]] = None,
puzzle_announcements_to_assert: Optional[Set[bytes32]] = None,
fee=0,
) -> Program:
assert fee >= 0
condition_list = []
if len(primaries) > 0:
for primary in primaries:
if "memos" in primary:
memos: Optional[List[bytes]] = primary["memos"]
if memos is not None and len(memos) == 0:
memos = None
else:
memos = None
condition_list.append(
make_create_coin_condition(primary["puzzlehash"],
primary["amount"], memos))
if min_time > 0:
condition_list.append(
make_assert_absolute_seconds_exceeds_condition(min_time))
if me:
condition_list.append(make_assert_my_coin_id_condition(me["id"]))
if fee:
condition_list.append(make_reserve_fee_condition(fee))
if coin_announcements:
for announcement in coin_announcements:
condition_list.append(
make_create_coin_announcement(announcement))
if coin_announcements_to_assert:
for announcement_hash in coin_announcements_to_assert:
condition_list.append(
make_assert_coin_announcement(announcement_hash))
if puzzle_announcements:
for announcement in puzzle_announcements:
condition_list.append(
make_create_puzzle_announcement(announcement))
if puzzle_announcements_to_assert:
for announcement_hash in puzzle_announcements_to_assert:
condition_list.append(
make_assert_puzzle_announcement(announcement_hash))
return solution_for_conditions(condition_list)
async def test_singleton_top_layer(self):
try:
# START TESTS
# Generate starting info
key_lookup = KeyTool()
pk: G1Element = public_key_for_index(1, key_lookup)
starting_puzzle: Program = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_pk(
pk) # noqa
adapted_puzzle: Program = singleton_top_layer.adapt_inner_to_singleton(
starting_puzzle) # noqa
adapted_puzzle_hash: bytes32 = adapted_puzzle.get_tree_hash()
# Get our starting standard coin created
START_AMOUNT: uint64 = 1023
sim = await SpendSim.create()
sim_client = SimClient(sim)
await sim.farm_block(starting_puzzle.get_tree_hash())
starting_coin: Coin = await sim_client.get_coin_records_by_puzzle_hash(
starting_puzzle.get_tree_hash())
starting_coin = starting_coin[0].coin
comment: List[Tuple[str, str]] = [("hello", "world")]
# LAUNCHING
# Try to create an even singleton (driver test)
try:
conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol( # noqa
starting_coin, adapted_puzzle, comment, (START_AMOUNT - 1))
raise AssertionError("This should fail due to an even amount")
except ValueError as msg:
assert str(
msg) == "Coin amount cannot be even. Subtract one mojo."
conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol( # noqa
starting_coin, adapted_puzzle, comment, START_AMOUNT)
# Creating solution for standard transaction
delegated_puzzle: Program = p2_conditions.puzzle_for_conditions(
conditions) # noqa
full_solution: Program = p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(
conditions) # noqa
starting_coinsol = CoinSpend(
starting_coin,
starting_puzzle,
full_solution,
)
await self.make_and_spend_bundle(
sim,
sim_client,
starting_coin,
delegated_puzzle,
[starting_coinsol, launcher_coinsol],
)
# EVE
singleton_eve: Coin = (await sim.all_non_reward_coins())[0]
launcher_coin: Coin = singleton_top_layer.generate_launcher_coin(
starting_coin,
START_AMOUNT,
)
launcher_id: bytes32 = launcher_coin.name()
# This delegated puzzle just recreates the coin exactly
delegated_puzzle: Program = Program.to((
1,
[[
ConditionOpcode.CREATE_COIN,
adapted_puzzle_hash,
singleton_eve.amount,
]],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
# Generate the lineage proof we will need from the launcher coin
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
launcher_coinsol) # noqa
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
singleton_eve.amount,
inner_solution,
)
singleton_eve_coinsol = CoinSpend(
singleton_eve,
puzzle_reveal,
full_solution,
)
await self.make_and_spend_bundle(
sim,
sim_client,
singleton_eve,
delegated_puzzle,
[singleton_eve_coinsol],
)
# POST-EVE
singleton: Coin = (await sim.all_non_reward_coins())[0]
# Same delegated_puzzle / inner_solution. We're just recreating ourself
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_eve_coinsol) # noqa
# Same puzzle_reveal too
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
singleton.amount,
inner_solution,
)
singleton_coinsol = CoinSpend(
singleton,
puzzle_reveal,
full_solution,
)
await self.make_and_spend_bundle(
sim,
sim_client,
singleton,
delegated_puzzle,
[singleton_coinsol],
)
# CLAIM A P2_SINGLETON
singleton_child: Coin = (await sim.all_non_reward_coins())[0]
p2_singleton_puz: Program = singleton_top_layer.pay_to_singleton_puzzle(
launcher_id)
p2_singleton_ph: bytes32 = p2_singleton_puz.get_tree_hash()
ARBITRARY_AMOUNT: uint64 = 1379
await sim.farm_block(p2_singleton_ph)
p2_singleton_coin: Coin = await sim_client.get_coin_records_by_puzzle_hash(
p2_singleton_ph)
p2_singleton_coin = p2_singleton_coin[0].coin
assertion, announcement, claim_coinsol = singleton_top_layer.claim_p2_singleton(
p2_singleton_coin,
adapted_puzzle_hash,
launcher_id,
)
delegated_puzzle: Program = Program.to((
1,
[
[
ConditionOpcode.CREATE_COIN, adapted_puzzle_hash,
singleton_eve.amount
],
assertion,
announcement,
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
singleton_eve.amount,
inner_solution,
)
singleton_claim_coinsol = CoinSpend(
singleton_child,
puzzle_reveal,
full_solution,
)
await self.make_and_spend_bundle(
sim, sim_client, singleton_child, delegated_puzzle,
[singleton_claim_coinsol, claim_coinsol])
# CLAIM A P2_SINGLETON_OR_DELAYED
singleton_child: Coin = (await sim.all_non_reward_coins())[0]
DELAY_TIME: uint64 = 1
DELAY_PH: bytes32 = adapted_puzzle_hash
p2_singleton_puz: Program = singleton_top_layer.pay_to_singleton_or_delay_puzzle(
launcher_id,
DELAY_TIME,
DELAY_PH,
)
p2_singleton_ph: bytes32 = p2_singleton_puz.get_tree_hash()
ARBITRARY_AMOUNT: uint64 = 1379
await sim.farm_block(p2_singleton_ph)
p2_singleton_coin: Coin = await sim_client.get_coin_records_by_puzzle_hash(
p2_singleton_ph)
p2_singleton_coin = p2_singleton_coin[0].coin
assertion, announcement, claim_coinsol = singleton_top_layer.claim_p2_singleton(
p2_singleton_coin,
adapted_puzzle_hash,
launcher_id,
DELAY_TIME,
DELAY_PH,
)
delegated_puzzle: Program = Program.to((
1,
[
[
ConditionOpcode.CREATE_COIN, adapted_puzzle_hash,
singleton_eve.amount
],
assertion,
announcement,
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_claim_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
singleton_eve.amount,
inner_solution,
)
delay_claim_coinsol = CoinSpend(
singleton_child,
puzzle_reveal,
full_solution,
)
# Save the height so we can rewind after this
save_height: uint64 = (
sim.get_height()
) # The last coin solution before this point is singleton_claim_coinsol
await self.make_and_spend_bundle(
sim, sim_client, singleton_child, delegated_puzzle,
[delay_claim_coinsol, claim_coinsol])
# TRY TO SPEND AWAY TOO SOON (Negative Test)
await sim.rewind(save_height)
to_delay_ph_coinsol: CoinSpend = singleton_top_layer.spend_to_delayed_puzzle(
p2_singleton_coin,
ARBITRARY_AMOUNT,
launcher_id,
DELAY_TIME,
DELAY_PH,
)
result, error = await sim_client.push_tx(
SpendBundle([to_delay_ph_coinsol], G2Element()))
assert error == Err.ASSERT_SECONDS_RELATIVE_FAILED
# SPEND TO DELAYED PUZZLE HASH
await sim.rewind(save_height)
sim.pass_time(10000005)
sim.pass_blocks(100)
await sim_client.push_tx(
SpendBundle([to_delay_ph_coinsol], G2Element()))
# CREATE MULTIPLE ODD CHILDREN (Negative Test)
singleton_child: Coin = (await sim.all_non_reward_coins())[0]
delegated_puzzle: Program = Program.to((
1,
[
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 3],
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 7],
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_claim_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof, singleton_child.amount, inner_solution)
multi_odd_coinsol = CoinSpend(
singleton_child,
puzzle_reveal,
full_solution,
)
await self.make_and_spend_bundle(
sim,
sim_client,
singleton_child,
delegated_puzzle,
[multi_odd_coinsol],
ex_error=Err.GENERATOR_RUNTIME_ERROR,
fail_msg="Too many odd children were allowed",
)
# CREATE NO ODD CHILDREN (Negative Test)
delegated_puzzle: Program = Program.to((
1,
[
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 4],
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 10],
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_claim_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof, singleton_child.amount, inner_solution)
no_odd_coinsol = CoinSpend(
singleton_child,
puzzle_reveal,
full_solution,
)
await self.make_and_spend_bundle(
sim,
sim_client,
singleton_child,
delegated_puzzle,
[no_odd_coinsol],
ex_error=Err.GENERATOR_RUNTIME_ERROR,
fail_msg="Need at least one odd child",
)
# ATTEMPT TO CREATE AN EVEN SINGLETON (Negative test)
await sim.rewind(save_height)
delegated_puzzle: Program = Program.to((
1,
[
[
ConditionOpcode.CREATE_COIN,
singleton_child.puzzle_hash,
2,
],
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 1],
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_claim_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof, singleton_child.amount, inner_solution)
singleton_even_coinsol = CoinSpend(
singleton_child,
puzzle_reveal,
full_solution,
)
await self.make_and_spend_bundle(
sim,
sim_client,
singleton_child,
delegated_puzzle,
[singleton_even_coinsol],
)
# Now try a perfectly innocent spend
evil_coin: Coin = (await sim.all_non_reward_coins())[0]
delegated_puzzle: Program = Program.to((
1,
[
[
ConditionOpcode.CREATE_COIN,
adapted_puzzle_hash,
1,
],
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_even_coinsol) # noqa
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
1,
inner_solution,
)
evil_coinsol = CoinSpend(
evil_coin,
puzzle_reveal,
full_solution,
)
await self.make_and_spend_bundle(
sim,
sim_client,
evil_coin,
delegated_puzzle,
[evil_coinsol],
ex_error=Err.ASSERT_MY_COIN_ID_FAILED,
fail_msg="This coin is even!",
)
# MELTING
# Remember, we're still spending singleton_child
await sim.rewind(save_height)
conditions = [
singleton_top_layer.MELT_CONDITION,
[
ConditionOpcode.CREATE_COIN,
adapted_puzzle_hash,
(singleton_child.amount - 1),
],
]
delegated_puzzle: Program = p2_conditions.puzzle_for_conditions(
conditions)
inner_solution: Program = p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(
conditions)
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_claim_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof, singleton_child.amount, inner_solution)
melt_coinsol = CoinSpend(
singleton_child,
puzzle_reveal,
full_solution,
)
await self.make_and_spend_bundle(
sim,
sim_client,
singleton_child,
delegated_puzzle,
[melt_coinsol],
)
melted_coin: Coin = (await sim.all_non_reward_coins())[0]
assert melted_coin.puzzle_hash == adapted_puzzle_hash
finally:
await sim.close()
def test_pool_lifecycle(self):
# START TESTS
# Generate starting info
key_lookup = KeyTool()
sk: PrivateKey = PrivateKey.from_bytes(
secret_exponent_for_index(1).to_bytes(32, "big"), )
pk: G1Element = G1Element.from_bytes(
public_key_for_index(1, key_lookup))
starting_puzzle: Program = puzzle_for_pk(pk)
starting_ph: bytes32 = starting_puzzle.get_tree_hash()
# Get our starting standard coin created
START_AMOUNT: uint64 = 1023
coin_db = CoinStore()
time = CoinTimestamp(10000000, 1)
coin_db.farm_coin(starting_ph, time, START_AMOUNT)
starting_coin: Coin = next(coin_db.all_unspent_coins())
# LAUNCHING
# Create the escaping inner puzzle
GENESIS_CHALLENGE = bytes32.fromhex(
"ccd5bb71183532bff220ba46c268991a3ff07eb358e8255a65c30a2dce0e5fbb")
launcher_coin = singleton_top_layer.generate_launcher_coin(
starting_coin,
START_AMOUNT,
)
DELAY_TIME = uint64(60800)
DELAY_PH = starting_ph
launcher_id = launcher_coin.name()
relative_lock_height: uint32 = uint32(5000)
# use a dummy pool state
pool_state = PoolState(
owner_pubkey=pk,
pool_url="",
relative_lock_height=relative_lock_height,
state=3, # farming to pool
target_puzzle_hash=starting_ph,
version=1,
)
# create a new dummy pool state for travelling
target_pool_state = PoolState(
owner_pubkey=pk,
pool_url="",
relative_lock_height=relative_lock_height,
state=2, # Leaving pool
target_puzzle_hash=starting_ph,
version=1,
)
# Standard format comment
comment = Program.to([("p", bytes(pool_state)), ("t", DELAY_TIME),
("h", DELAY_PH)])
pool_wr_innerpuz: bytes32 = create_waiting_room_inner_puzzle(
starting_ph,
relative_lock_height,
pk,
launcher_id,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH,
)
pool_wr_inner_hash = pool_wr_innerpuz.get_tree_hash()
pooling_innerpuz: Program = create_pooling_inner_puzzle(
starting_ph,
pool_wr_inner_hash,
pk,
launcher_id,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH,
)
# Driver tests
assert is_pool_singleton_inner_puzzle(pooling_innerpuz)
assert is_pool_singleton_inner_puzzle(pool_wr_innerpuz)
assert get_pubkey_from_member_inner_puzzle(pooling_innerpuz) == pk
# Generating launcher information
conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol(
starting_coin, pooling_innerpuz, comment, START_AMOUNT)
# Creating solution for standard transaction
delegated_puzzle: Program = puzzle_for_conditions(conditions)
full_solution: Program = solution_for_conditions(conditions)
starting_coinsol = CoinSolution(
starting_coin,
starting_puzzle,
full_solution,
)
# Create the spend bundle
sig: G2Element = sign_delegated_puz(delegated_puzzle, starting_coin)
spend_bundle = SpendBundle(
[starting_coinsol, launcher_coinsol],
sig,
)
# Spend it!
coin_db.update_coin_store_for_spend_bundle(
spend_bundle,
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
# Test that we can retrieve the extra data
assert get_delayed_puz_info_from_launcher_spend(launcher_coinsol) == (
DELAY_TIME, DELAY_PH)
assert solution_to_extra_data(launcher_coinsol) == pool_state
# TEST TRAVEL AFTER LAUNCH
# fork the state
fork_coin_db: CoinStore = copy.deepcopy(coin_db)
post_launch_coinsol, _ = create_travel_spend(
launcher_coinsol,
launcher_coin,
pool_state,
target_pool_state,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH,
)
# Spend it!
fork_coin_db.update_coin_store_for_spend_bundle(
SpendBundle([post_launch_coinsol], G2Element()),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
# HONEST ABSORB
time = CoinTimestamp(10000030, 2)
# create the farming reward
p2_singleton_puz: Program = create_p2_singleton_puzzle(
SINGLETON_MOD_HASH,
launcher_id,
DELAY_TIME,
DELAY_PH,
)
p2_singleton_ph: bytes32 = p2_singleton_puz.get_tree_hash()
assert uncurry_pool_waitingroom_inner_puzzle(pool_wr_innerpuz) == (
starting_ph,
relative_lock_height,
pk,
p2_singleton_ph,
)
assert launcher_id_to_p2_puzzle_hash(launcher_id, DELAY_TIME,
DELAY_PH) == p2_singleton_ph
assert get_seconds_and_delayed_puzhash_from_p2_singleton_puzzle(
p2_singleton_puz) == (DELAY_TIME, DELAY_PH)
coin_db.farm_coin(p2_singleton_ph, time, 1750000000000)
coin_sols: List[CoinSolution] = create_absorb_spend(
launcher_coinsol,
pool_state,
launcher_coin,
2,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH, # height
)
# Spend it!
coin_db.update_coin_store_for_spend_bundle(
SpendBundle(coin_sols, G2Element()),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
# ABSORB A NON EXISTENT REWARD (Negative test)
last_coinsol: CoinSolution = list(
filter(
lambda e: e.coin.amount == START_AMOUNT,
coin_sols,
))[0]
coin_sols: List[CoinSolution] = create_absorb_spend(
last_coinsol,
pool_state,
launcher_coin,
2,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH, # height
)
# filter for only the singleton solution
singleton_coinsol: CoinSolution = list(
filter(
lambda e: e.coin.amount == START_AMOUNT,
coin_sols,
))[0]
# Spend it and hope it fails!
try:
coin_db.update_coin_store_for_spend_bundle(
SpendBundle([singleton_coinsol], G2Element()),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
except BadSpendBundleError as e:
assert str(
e
) == "condition validation failure Err.ASSERT_ANNOUNCE_CONSUMED_FAILED"
# SPEND A NON-REWARD P2_SINGLETON (Negative test)
# create the dummy coin
non_reward_p2_singleton = Coin(
bytes32(32 * b"3"),
p2_singleton_ph,
uint64(1337),
)
coin_db._add_coin_entry(non_reward_p2_singleton, time)
# construct coin solution for the p2_singleton coin
bad_coinsol = CoinSolution(
non_reward_p2_singleton,
p2_singleton_puz,
Program.to([
pooling_innerpuz.get_tree_hash(),
non_reward_p2_singleton.name(),
]),
)
# Spend it and hope it fails!
try:
coin_db.update_coin_store_for_spend_bundle(
SpendBundle([singleton_coinsol, bad_coinsol], G2Element()),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
except BadSpendBundleError as e:
assert str(
e
) == "condition validation failure Err.ASSERT_ANNOUNCE_CONSUMED_FAILED"
# ENTER WAITING ROOM
# find the singleton
singleton = get_most_recent_singleton_coin_from_coin_solution(
last_coinsol)
# get the relevant coin solution
travel_coinsol, _ = create_travel_spend(
last_coinsol,
launcher_coin,
pool_state,
target_pool_state,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH,
)
# Test that we can retrieve the extra data
assert solution_to_extra_data(travel_coinsol) == target_pool_state
# sign the serialized state
data = Program.to(bytes(target_pool_state)).get_tree_hash()
sig: G2Element = AugSchemeMPL.sign(
sk,
(data + singleton.name() +
DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA),
)
# Spend it!
coin_db.update_coin_store_for_spend_bundle(
SpendBundle([travel_coinsol], sig),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
# ESCAPE TOO FAST (Negative test)
# find the singleton
singleton = get_most_recent_singleton_coin_from_coin_solution(
travel_coinsol)
# get the relevant coin solution
return_coinsol, _ = create_travel_spend(
travel_coinsol,
launcher_coin,
target_pool_state,
pool_state,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH,
)
# sign the serialized target state
sig = AugSchemeMPL.sign(
sk,
(data + singleton.name() +
DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA),
)
# Spend it and hope it fails!
try:
coin_db.update_coin_store_for_spend_bundle(
SpendBundle([return_coinsol], sig),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
except BadSpendBundleError as e:
assert str(
e
) == "condition validation failure Err.ASSERT_HEIGHT_RELATIVE_FAILED"
# ABSORB WHILE IN WAITING ROOM
time = CoinTimestamp(10000060, 3)
# create the farming reward
coin_db.farm_coin(p2_singleton_ph, time, 1750000000000)
# generate relevant coin solutions
coin_sols: List[CoinSolution] = create_absorb_spend(
travel_coinsol,
target_pool_state,
launcher_coin,
3,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH, # height
)
# Spend it!
coin_db.update_coin_store_for_spend_bundle(
SpendBundle(coin_sols, G2Element()),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
# LEAVE THE WAITING ROOM
time = CoinTimestamp(20000000, 10000)
# find the singleton
singleton_coinsol: CoinSolution = list(
filter(
lambda e: e.coin.amount == START_AMOUNT,
coin_sols,
))[0]
singleton: Coin = get_most_recent_singleton_coin_from_coin_solution(
singleton_coinsol)
# get the relevant coin solution
return_coinsol, _ = create_travel_spend(
singleton_coinsol,
launcher_coin,
target_pool_state,
pool_state,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH,
)
# Test that we can retrieve the extra data
assert solution_to_extra_data(return_coinsol) == pool_state
# sign the serialized target state
data = Program.to([
pooling_innerpuz.get_tree_hash(), START_AMOUNT,
bytes(pool_state)
]).get_tree_hash()
sig: G2Element = AugSchemeMPL.sign(
sk,
(data + singleton.name() +
DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA),
)
# Spend it!
coin_db.update_coin_store_for_spend_bundle(
SpendBundle([return_coinsol], sig),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
# ABSORB ONCE MORE FOR GOOD MEASURE
time = CoinTimestamp(20000000, 10005)
# create the farming reward
coin_db.farm_coin(p2_singleton_ph, time, 1750000000000)
coin_sols: List[CoinSolution] = create_absorb_spend(
return_coinsol,
pool_state,
launcher_coin,
10005,
GENESIS_CHALLENGE,
DELAY_TIME,
DELAY_PH, # height
)
# Spend it!
coin_db.update_coin_store_for_spend_bundle(
SpendBundle(coin_sols, G2Element()),
time,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
def test_singleton_top_layer(self):
# START TESTS
# Generate starting info
key_lookup = KeyTool()
pk: G1Element = public_key_for_index(1, key_lookup)
starting_puzzle: Program = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_pk(
pk) # noqa
adapted_puzzle: Program = singleton_top_layer.adapt_inner_to_singleton(
starting_puzzle) # noqa
adapted_puzzle_hash: bytes32 = adapted_puzzle.get_tree_hash()
# Get our starting standard coin created
START_AMOUNT: uint64 = 1023
coin_db = CoinStore()
coin_db.farm_coin(starting_puzzle.get_tree_hash(), T1, START_AMOUNT)
starting_coin: Coin = next(coin_db.all_unspent_coins())
comment: List[Tuple[str, str]] = [("hello", "world")]
# LAUNCHING
# Try to create an even singleton (driver test)
try:
conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol( # noqa
starting_coin, adapted_puzzle, comment, (START_AMOUNT - 1))
raise AssertionError("This should fail due to an even amount")
except ValueError as msg:
assert str(msg) == "Coin amount cannot be even. Subtract one mojo."
conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol( # noqa
starting_coin, adapted_puzzle, comment, START_AMOUNT)
# Creating solution for standard transaction
delegated_puzzle: Program = p2_conditions.puzzle_for_conditions(
conditions) # noqa
full_solution: Program = p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(
conditions) # noqa
starting_coinsol = CoinSolution(
starting_coin,
starting_puzzle,
full_solution,
)
make_and_spend_bundle(
coin_db,
starting_coin,
delegated_puzzle,
[starting_coinsol, launcher_coinsol],
)
# EVE
singleton_eve: Coin = next(coin_db.all_unspent_coins())
launcher_coin: Coin = singleton_top_layer.generate_launcher_coin(
starting_coin,
START_AMOUNT,
)
launcher_id: bytes32 = launcher_coin.name()
# This delegated puzzle just recreates the coin exactly
delegated_puzzle: Program = Program.to((
1,
[[
ConditionOpcode.CREATE_COIN,
adapted_puzzle_hash,
singleton_eve.amount,
]],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
# Generate the lineage proof we will need from the launcher coin
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
launcher_coinsol) # noqa
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
singleton_eve.amount,
inner_solution,
)
singleton_eve_coinsol = CoinSolution(
singleton_eve,
puzzle_reveal,
full_solution,
)
make_and_spend_bundle(
coin_db,
singleton_eve,
delegated_puzzle,
[singleton_eve_coinsol],
)
# POST-EVE
singleton: Coin = next(coin_db.all_unspent_coins())
# Same delegated_puzzle / inner_solution. We're just recreating ourself
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_eve_coinsol) # noqa
# Same puzzle_reveal too
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
singleton.amount,
inner_solution,
)
singleton_coinsol = CoinSolution(
singleton,
puzzle_reveal,
full_solution,
)
make_and_spend_bundle(
coin_db,
singleton,
delegated_puzzle,
[singleton_coinsol],
)
# CLAIM A P2_SINGLETON
singleton_child: Coin = next(coin_db.all_unspent_coins())
p2_singleton_puz: Program = singleton_top_layer.pay_to_singleton_puzzle(
launcher_id)
p2_singleton_ph: bytes32 = p2_singleton_puz.get_tree_hash()
ARBITRARY_AMOUNT: uint64 = 1379
coin_db.farm_coin(p2_singleton_ph, T1, ARBITRARY_AMOUNT)
p2_singleton_coin: Coin = list(
filter(
lambda e: e.amount == ARBITRARY_AMOUNT,
list(coin_db.all_unspent_coins()),
))[0]
assertion, announcement, claim_coinsol = singleton_top_layer.claim_p2_singleton(
p2_singleton_coin,
adapted_puzzle_hash,
launcher_id,
)
delegated_puzzle: Program = Program.to((
1,
[
[
ConditionOpcode.CREATE_COIN, adapted_puzzle_hash,
singleton_eve.amount
],
assertion,
announcement,
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
singleton_eve.amount,
inner_solution,
)
singleton_claim_coinsol = CoinSolution(
singleton_child,
puzzle_reveal,
full_solution,
)
make_and_spend_bundle(coin_db, singleton_child, delegated_puzzle,
[singleton_claim_coinsol, claim_coinsol])
# CLAIM A P2_SINGLETON_OR_DELAYED
singleton_child: Coin = next(coin_db.all_unspent_coins())
DELAY_TIME: uint64 = 1
DELAY_PH: bytes32 = adapted_puzzle_hash
p2_singleton_puz: Program = singleton_top_layer.pay_to_singleton_or_delay_puzzle(
launcher_id,
DELAY_TIME,
DELAY_PH,
)
p2_singleton_ph: bytes32 = p2_singleton_puz.get_tree_hash()
ARBITRARY_AMOUNT: uint64 = 1379
coin_db.farm_coin(p2_singleton_ph, T1, ARBITRARY_AMOUNT)
p2_singleton_coin: Coin = list(
filter(
lambda e: e.amount == ARBITRARY_AMOUNT,
list(coin_db.all_unspent_coins()),
))[0]
assertion, announcement, claim_coinsol = singleton_top_layer.claim_p2_singleton(
p2_singleton_coin,
adapted_puzzle_hash,
launcher_id,
)
delegated_puzzle: Program = Program.to((
1,
[
[
ConditionOpcode.CREATE_COIN, adapted_puzzle_hash,
singleton_eve.amount
],
assertion,
announcement,
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
singleton_eve.amount,
inner_solution,
)
delay_claim_coinsol = CoinSolution(
singleton_child,
puzzle_reveal,
full_solution,
)
# Fork it so we can try the other spend types
fork_coin_db: CoinStore = copy.deepcopy(coin_db)
fork_coin_db_2: CoinStore = copy.deepcopy(coin_db)
make_and_spend_bundle(coin_db, singleton_child, delegated_puzzle,
[delay_claim_coinsol, claim_coinsol])
# TRY TO SPEND AWAY TOO SOON (Negative Test)
to_delay_ph_coinsol = singleton_top_layer.spend_to_delayed_puzzle(
p2_singleton_coin,
ARBITRARY_AMOUNT,
launcher_id,
DELAY_TIME,
DELAY_PH,
)
try:
fork_coin_db.update_coin_store_for_spend_bundle(
SpendBundle([to_delay_ph_coinsol], G2Element()),
T1,
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
except BadSpendBundleError as e:
assert str(
e
) == "condition validation failure Err.ASSERT_SECONDS_RELATIVE_FAILED"
# SPEND TO DELAYED PUZZLE HASH
fork_coin_db_2.update_coin_store_for_spend_bundle(
SpendBundle([to_delay_ph_coinsol], G2Element()),
CoinTimestamp(100, 10000005),
DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
)
# CREATE MULTIPLE ODD CHILDREN (Negative Test)
singleton_child: Coin = next(coin_db.all_unspent_coins())
delegated_puzzle: Program = Program.to((
1,
[
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 3],
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 7],
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_coinsol) # noqa
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof, singleton_child.amount, inner_solution)
multi_odd_coinsol = CoinSolution(
singleton_child,
puzzle_reveal,
full_solution,
)
make_and_spend_bundle(
coin_db,
singleton_child,
delegated_puzzle,
[multi_odd_coinsol],
exception=BadSpendBundleError,
ex_msg="clvm validation failure Err.SEXP_ERROR",
fail_msg="Too many odd children were allowed",
)
# CREATE NO ODD CHILDREN (Negative Test)
delegated_puzzle: Program = Program.to((
1,
[
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 4],
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 10],
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_coinsol) # noqa
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof, singleton_child.amount, inner_solution)
no_odd_coinsol = CoinSolution(
singleton_child,
puzzle_reveal,
full_solution,
)
make_and_spend_bundle(
coin_db,
singleton_child,
delegated_puzzle,
[no_odd_coinsol],
exception=BadSpendBundleError,
ex_msg="clvm validation failure Err.SEXP_ERROR",
fail_msg="Need at least one odd child",
)
# ATTEMPT TO CREATE AN EVEN SINGLETON (Negative test)
fork_coin_db: CoinStore = copy.deepcopy(coin_db)
delegated_puzzle: Program = Program.to((
1,
[
[
ConditionOpcode.CREATE_COIN,
singleton_child.puzzle_hash,
2,
],
[ConditionOpcode.CREATE_COIN, adapted_puzzle_hash, 1],
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
delay_claim_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof, singleton_child.amount, inner_solution)
singleton_even_coinsol = CoinSolution(
singleton_child,
puzzle_reveal,
full_solution,
)
make_and_spend_bundle(
fork_coin_db,
singleton_child,
delegated_puzzle,
[singleton_even_coinsol],
)
# Now try a perfectly innocent spend
evil_coin: Coin = next(fork_coin_db.all_unspent_coins())
delegated_puzzle: Program = Program.to((
1,
[
[
ConditionOpcode.CREATE_COIN,
adapted_puzzle_hash,
1,
],
],
))
inner_solution: Program = Program.to([[], delegated_puzzle, []])
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
singleton_even_coinsol) # noqa
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof,
1,
inner_solution,
)
evil_coinsol = CoinSolution(
evil_coin,
puzzle_reveal,
full_solution,
)
make_and_spend_bundle(
fork_coin_db,
evil_coin,
delegated_puzzle,
[evil_coinsol],
exception=BadSpendBundleError,
ex_msg="condition validation failure Err.ASSERT_MY_COIN_ID_FAILED",
fail_msg="This coin is even!",
)
# MELTING
# Remember, we're still spending singleton_child
conditions = [
singleton_top_layer.MELT_CONDITION,
[
ConditionOpcode.CREATE_COIN,
adapted_puzzle_hash,
(singleton_child.amount - 1),
],
]
delegated_puzzle: Program = p2_conditions.puzzle_for_conditions(
conditions)
inner_solution: Program = p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(
conditions)
lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(
delay_claim_coinsol)
puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
launcher_id,
adapted_puzzle,
)
full_solution: Program = singleton_top_layer.solution_for_singleton(
lineage_proof, singleton_child.amount, inner_solution)
melt_coinsol = CoinSolution(
singleton_child,
puzzle_reveal,
full_solution,
)
make_and_spend_bundle(
coin_db,
singleton_child,
delegated_puzzle,
[melt_coinsol],
)
melted_coin = next(coin_db.all_unspent_coins())
assert melted_coin.puzzle_hash == adapted_puzzle_hash
