async def test_wallet_coinbase_reorg(self, wallet_node):
num_blocks = 5
full_nodes, wallets = wallet_node
full_node_api = full_nodes[0]
fn_server = full_node_api.full_node.server
wallet_node, server_2 = wallets[0]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(
PeerInfo(self_hostname, uint16(fn_server._port)), None)
for i in range(0, num_blocks):
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(5, wallet.get_confirmed_balance, funds)
await full_node_api.reorg_from_index_to_new_index(
ReorgProtocol(uint32(3), uint32(num_blocks + 6), 32 * b"0"))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks - 2)
])
await time_out_assert(5, wallet.get_confirmed_balance, funds)
async def test_wallet_make_transaction_with_fee(self, two_wallet_nodes):
num_blocks = 5
full_nodes, wallets = two_wallet_nodes
full_node_1 = full_nodes[0]
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(
PeerInfo(self_hostname,
uint16(full_node_1.full_node.server._port)), None)
for i in range(0, num_blocks):
await full_node_1.farm_new_block(FarmNewBlockProtocol(ph))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(5, wallet.get_confirmed_balance, funds)
await time_out_assert(5, wallet.get_unconfirmed_balance, funds)
assert await wallet.get_confirmed_balance() == funds
assert await wallet.get_unconfirmed_balance() == funds
tx_amount = 3200000000000
tx_fee = 10
tx = await wallet.generate_signed_transaction(
tx_amount,
await
wallet_node_2.wallet_state_manager.main_wallet.get_new_puzzlehash(
),
tx_fee,
)
fees = tx.spend_bundle.fees()
assert fees == tx_fee
await wallet.push_transaction(tx)
await time_out_assert(5, wallet.get_confirmed_balance, funds)
await time_out_assert(5, wallet.get_unconfirmed_balance,
funds - tx_amount - tx_fee)
for i in range(0, num_blocks):
await full_node_1.farm_new_block(FarmNewBlockProtocol(32 * b"0"))
new_funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks + 1)
])
await time_out_assert(5, wallet.get_confirmed_balance,
new_funds - tx_amount - tx_fee)
await time_out_assert(5, wallet.get_unconfirmed_balance,
new_funds - tx_amount - tx_fee)
async def test_wallet_make_transaction(self, two_wallet_nodes):
num_blocks = 5
full_nodes, wallets = two_wallet_nodes
full_node_api = full_nodes[0]
server_1 = full_node_api.full_node.server
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(
PeerInfo(self_hostname, uint16(server_1._port)), None)
for i in range(0, num_blocks):
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(5, wallet.get_confirmed_balance, funds)
await time_out_assert(5, wallet.get_unconfirmed_balance, funds)
tx = await wallet.generate_signed_transaction(
10,
await
wallet_node_2.wallet_state_manager.main_wallet.get_new_puzzlehash(
),
0,
)
await wallet.push_transaction(tx)
await time_out_assert(5, wallet.get_confirmed_balance, funds)
await time_out_assert(5, wallet.get_unconfirmed_balance, funds - 10)
for i in range(0, num_blocks):
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
new_funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, (2 * num_blocks))
])
await time_out_assert(5, wallet.get_confirmed_balance, new_funds - 10)
await time_out_assert(5, wallet.get_unconfirmed_balance,
new_funds - 10)
async def test_get_wallet_for_colour(self, two_wallet_nodes):
num_blocks = 3
full_nodes, wallets = two_wallet_nodes
full_node_api = full_nodes[0]
full_node_server = full_node_api.server
wallet_node, server_2 = wallets[0]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
funds = sum(
[
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks - 1)
]
)
await time_out_assert(15, wallet.get_confirmed_balance, funds)
cc_wallet: CCWallet = await CCWallet.create_new_cc(wallet_node.wallet_state_manager, wallet, uint64(100))
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
colour = cc_wallet.get_colour()
assert await wallet_node.wallet_state_manager.get_wallet_for_colour(colour) == cc_wallet
async def test_colour_creation(self, two_wallet_nodes):
num_blocks = 3
full_nodes, wallets = two_wallet_nodes
full_node_api = full_nodes[0]
full_node_server = full_node_api.server
wallet_node, server_2 = wallets[0]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
funds = sum(
[
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks - 1)
]
)
await time_out_assert(15, wallet.get_confirmed_balance, funds)
cc_wallet: CCWallet = await CCWallet.create_new_cc(wallet_node.wallet_state_manager, wallet, uint64(100))
tx_queue: List[TransactionRecord] = await wallet_node.wallet_state_manager.get_send_queue()
tx_record = tx_queue[0]
await time_out_assert(
15, tx_in_pool, True, full_node_api.full_node.mempool_manager, tx_record.spend_bundle.name()
)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(15, cc_wallet.get_confirmed_balance, 100)
await time_out_assert(15, cc_wallet.get_unconfirmed_balance, 100)
async def main():
rpc_port = 8555
self_hostname = "localhost"
path = DEFAULT_ROOT_PATH
config = load_config(path, "config.yaml")
client = await FullNodeRpcClient.create(self_hostname, rpc_port, path,
config)
try:
farmer_prefarm = (
await
client.get_block_record_by_height(1)).reward_claims_incorporated[1]
pool_prefarm = (
await
client.get_block_record_by_height(1)).reward_claims_incorporated[0]
pool_amounts = int(calculate_pool_reward(uint32(0)) / 2)
farmer_amounts = int(calculate_base_farmer_reward(uint32(0)) / 2)
print(farmer_prefarm.amount, farmer_amounts)
assert farmer_amounts == farmer_prefarm.amount // 2
assert pool_amounts == pool_prefarm.amount // 2
address1 = "txch15gx26ndmacfaqlq8m0yajeggzceu7cvmaz4df0hahkukes695rss6lej7h" # Gene wallet (m/12381/8444/2/42):
address2 = (
"txch1c2cguswhvmdyz9hr3q6hak2h6p9dw4rz82g4707k2xy2sarv705qcce4pn" # Mariano address (m/12381/8444/2/0)
)
ph1 = decode_puzzle_hash(address1)
ph2 = decode_puzzle_hash(address2)
p_farmer_2 = Program.to(
binutils.assemble(
f"(q . ((51 0x{ph1.hex()} {farmer_amounts}) (51 0x{ph2.hex()} {farmer_amounts})))"
))
p_pool_2 = Program.to(
binutils.assemble(
f"(q . ((51 0x{ph1.hex()} {pool_amounts}) (51 0x{ph2.hex()} {pool_amounts})))"
))
p_solution = Program.to(binutils.assemble("()"))
sb_farmer = SpendBundle(
[CoinSolution(farmer_prefarm, p_farmer_2, p_solution)],
G2Element())
sb_pool = SpendBundle(
[CoinSolution(pool_prefarm, p_pool_2, p_solution)], G2Element())
print(sb_pool, sb_farmer)
# res = await client.push_tx(sb_farmer)
res = await client.push_tx(sb_pool)
print(res)
up = await client.get_coin_records_by_puzzle_hash(
farmer_prefarm.puzzle_hash, True)
uf = await client.get_coin_records_by_puzzle_hash(
pool_prefarm.puzzle_hash, True)
print(up)
print(uf)
finally:
client.close()
async def main():
rpc_port = 8555
self_hostname = "localhost"
path = DEFAULT_ROOT_PATH
config = load_config(path, "config.yaml")
client = await FullNodeRpcClient.create(self_hostname, rpc_port, path,
config)
try:
farmer_prefarm = (
await
client.get_block_record_by_height(1)).reward_claims_incorporated[1]
pool_prefarm = (
await
client.get_block_record_by_height(1)).reward_claims_incorporated[0]
pool_amounts = int(calculate_pool_reward(uint32(0)) / 2)
farmer_amounts = int(calculate_base_farmer_reward(uint32(0)) / 2)
print(farmer_prefarm.amount, farmer_amounts)
assert farmer_amounts == farmer_prefarm.amount // 2
assert pool_amounts == pool_prefarm.amount // 2
address1 = "txch1k50glwkdffp2mrqq64rsgjtxj4waphuf72stqayz4qqk6mj9hd4qp7lrek" # Gene wallet (m/12381/8444/2/51):
address2 = "txch1430mtj60hvzyuyz4t45dyxwjdjsvphhl2fgreyry362reca4zpkszhjd3e" # farmer1 key (m/12381/8444/2/51)
ph1 = decode_puzzle_hash(address1)
ph2 = decode_puzzle_hash(address2)
p_farmer_2 = Program.to(
binutils.assemble(
f"(q . ((51 0x{ph1.hex()} {farmer_amounts}) (51 0x{ph2.hex()} {farmer_amounts})))"
))
p_pool_2 = Program.to(
binutils.assemble(
f"(q . ((51 0x{ph1.hex()} {pool_amounts}) (51 0x{ph2.hex()} {pool_amounts})))"
))
p_solution = Program.to(binutils.assemble("()"))
sb_farmer = SpendBundle(
[CoinSolution(farmer_prefarm, p_farmer_2, p_solution)],
G2Element())
sb_pool = SpendBundle(
[CoinSolution(pool_prefarm, p_pool_2, p_solution)], G2Element())
print(sb_pool, sb_farmer)
# res = await client.push_tx(sb_farmer)
# res = await client.push_tx(sb_pool)
# print(res)
up = await client.get_coin_records_by_puzzle_hash(
farmer_prefarm.puzzle_hash, True)
uf = await client.get_coin_records_by_puzzle_hash(
pool_prefarm.puzzle_hash, True)
print(up)
print(uf)
finally:
client.close()
async def test_generate_zero_val(self, two_wallet_nodes):
num_blocks = 4
full_nodes, wallets = two_wallet_nodes
full_node_api = full_nodes[0]
full_node_server = full_node_api.server
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
wallet = wallet_node.wallet_state_manager.main_wallet
wallet2 = wallet_node_2.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
await server_3.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
funds = sum(
[
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks - 1)
]
)
await time_out_assert(15, wallet.get_confirmed_balance, funds)
cc_wallet: CCWallet = await CCWallet.create_new_cc(wallet_node.wallet_state_manager, wallet, uint64(100))
ph = await wallet2.get_new_puzzlehash()
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
await time_out_assert(15, cc_wallet.get_confirmed_balance, 100)
await time_out_assert(15, cc_wallet.get_unconfirmed_balance, 100)
assert cc_wallet.cc_info.my_genesis_checker is not None
colour = cc_wallet.get_colour()
cc_wallet_2: CCWallet = await CCWallet.create_wallet_for_cc(wallet_node_2.wallet_state_manager, wallet2, colour)
assert cc_wallet.cc_info.my_genesis_checker == cc_wallet_2.cc_info.my_genesis_checker
spend_bundle = await cc_wallet_2.generate_zero_val_coin()
await time_out_assert(15, tx_in_pool, True, full_node_api.full_node.mempool_manager, spend_bundle.name())
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
async def unspent_count():
unspent: List[WalletCoinRecord] = list(
await cc_wallet_2.wallet_state_manager.get_spendable_coins_for_wallet(cc_wallet_2.id())
)
return len(unspent)
await time_out_assert(15, unspent_count, 1)
unspent: List[WalletCoinRecord] = list(
await cc_wallet_2.wallet_state_manager.get_spendable_coins_for_wallet(cc_wallet_2.id())
)
assert unspent.pop().coin.amount == 0
async def test_invalid_block(self, wallet_node_30_freeze):
num_blocks = 5
full_nodes, wallets = wallet_node_30_freeze
full_node_api: FullNodeSimulator = full_nodes[0]
full_node_server = full_node_api.server
wallet_node, server_2 = wallets[0]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(PeerInfo(self_hostname, uint16(full_node_server._port)), None)
for i in range(num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
funds = sum(
[calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)]
)
# funds += calculate_base_farmer_reward(0)
await asyncio.sleep(2)
print(await wallet.get_confirmed_balance(), funds)
await time_out_assert(10, wallet.get_confirmed_balance, funds)
tx: TransactionRecord = await wallet.generate_signed_transaction(100, ph, 0)
current_blocks = await full_node_api.get_all_full_blocks()
new_blocks = bt.get_consecutive_blocks(
1, block_list_input=current_blocks, transaction_data=tx.spend_bundle, guarantee_transaction_block=True
)
last_block = new_blocks[-1:][0]
new_blocks_no_tx = bt.get_consecutive_blocks(
1, block_list_input=current_blocks, guarantee_transaction_block=True
)
last_block_no_tx = new_blocks_no_tx[-1:][0]
result, error, fork = await full_node_api.full_node.blockchain.receive_block(last_block, None)
assert error is not None
assert error is Err.INITIAL_TRANSACTION_FREEZE
assert result is ReceiveBlockResult.INVALID_BLOCK
result, error, fork = await full_node_api.full_node.blockchain.receive_block(last_block_no_tx, None)
assert error is None
assert result is ReceiveBlockResult.NEW_PEAK
after_freeze_blocks = bt.get_consecutive_blocks(24, block_list_input=new_blocks_no_tx)
for block in after_freeze_blocks:
await full_node_api.full_node.blockchain.receive_block(block, None)
assert full_node_api.full_node.blockchain.get_peak_height() == 30
new_blocks = bt.get_consecutive_blocks(
1, block_list_input=after_freeze_blocks, transaction_data=tx.spend_bundle, guarantee_transaction_block=True
)
last_block = new_blocks[-1:][0]
result, error, fork = await full_node_api.full_node.blockchain.receive_block(last_block, None)
assert error is None
assert result is ReceiveBlockResult.NEW_PEAK
async def test_wallet_reorg_get_coinbase(self, wallet_node_simulator,
default_400_blocks):
full_nodes, wallets = wallet_node_simulator
full_node_api = full_nodes[0]
wallet_node, server_2 = wallets[0]
fn_server = full_node_api.full_node.server
wsm = wallet_node.wallet_state_manager
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(
PeerInfo(self_hostname, uint16(fn_server._port)), None)
# Insert 400 blocks
for block in default_400_blocks:
await full_node_api.full_node.respond_block(
full_node_protocol.RespondBlock(block))
# Reorg blocks that carry reward
num_blocks_reorg = 30
blocks_reorg = bt.get_consecutive_blocks(
num_blocks_reorg, block_list_input=default_400_blocks[:-5])
for block in blocks_reorg[:-5]:
await full_node_api.full_node.respond_block(
full_node_protocol.RespondBlock(block))
async def get_tx_count(wallet_id):
txs = await wsm.get_all_transactions(wallet_id)
return len(txs)
await time_out_assert(10, get_tx_count, 0, 1)
num_blocks_reorg_1 = 40
blocks_reorg_1 = bt.get_consecutive_blocks(
1,
pool_reward_puzzle_hash=ph,
farmer_reward_puzzle_hash=ph,
block_list_input=blocks_reorg[:-30])
blocks_reorg_2 = bt.get_consecutive_blocks(
num_blocks_reorg_1, block_list_input=blocks_reorg_1)
for block in blocks_reorg_2[-41:]:
await full_node_api.full_node.respond_block(
full_node_protocol.RespondBlock(block))
await disconnect_all_and_reconnect(server_2, fn_server)
# Confirm we have the funds
funds = calculate_pool_reward(uint32(
len(blocks_reorg_1))) + calculate_base_farmer_reward(
uint32(len(blocks_reorg_1)))
await time_out_assert(10, get_tx_count, 2, 1)
await time_out_assert(10, wallet.get_confirmed_balance, funds)
async def test_transaction_freeze(self, wallet_node_30_freeze):
num_blocks = 5
full_nodes, wallets = wallet_node_30_freeze
full_node_api: FullNodeSimulator = full_nodes[0]
full_node_server = full_node_api.server
wallet_node, server_2 = wallets[0]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
incoming_queue, node_id = await add_dummy_connection(full_node_server, 12312)
await server_2.start_client(PeerInfo(self_hostname, uint16(full_node_server._port)), None)
for i in range(num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
funds = sum(
[calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)]
)
# funds += calculate_base_farmer_reward(0)
await asyncio.sleep(2)
print(await wallet.get_confirmed_balance(), funds)
await time_out_assert(10, wallet.get_confirmed_balance, funds)
tx: TransactionRecord = await wallet.generate_signed_transaction(100, ph, 0)
spend = wallet_protocol.SendTransaction(tx.spend_bundle)
response = await full_node_api.send_transaction(spend)
assert wallet_protocol.TransactionAck.from_bytes(response.data).status == MempoolInclusionStatus.FAILED
new_spend = full_node_protocol.NewTransaction(tx.spend_bundle.name(), 1, 0)
response = await full_node_api.new_transaction(new_spend)
assert response is None
peer = full_node_server.all_connections[node_id]
new_spend = full_node_protocol.RespondTransaction(tx.spend_bundle)
response = await full_node_api.respond_transaction(new_spend, peer=peer)
assert response is None
for i in range(26):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
new_spend = full_node_protocol.NewTransaction(tx.spend_bundle.name(), 1, 0)
response = await full_node_api.new_transaction(new_spend)
assert response is not None
assert ProtocolMessageTypes(response.type) == ProtocolMessageTypes.request_transaction
tx: TransactionRecord = await wallet.generate_signed_transaction(100, ph, 0)
spend = wallet_protocol.SendTransaction(tx.spend_bundle)
response = await full_node_api.send_transaction(spend)
assert response is not None
assert wallet_protocol.TransactionAck.from_bytes(response.data).status == MempoolInclusionStatus.SUCCESS
assert ProtocolMessageTypes(response.type) == ProtocolMessageTypes.transaction_ack
async def test_wallet_reorg_sync(self, wallet_node_simulator,
default_400_blocks):
num_blocks = 5
full_nodes, wallets = wallet_node_simulator
full_node_api = full_nodes[0]
wallet_node, server_2 = wallets[0]
fn_server = full_node_api.full_node.server
wsm: WalletStateManager = wallet_node.wallet_state_manager
wallet = wsm.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(
PeerInfo(self_hostname, uint16(fn_server._port)), None)
# Insert 400 blocks
for block in default_400_blocks:
await full_node_api.full_node.respond_block(
full_node_protocol.RespondBlock(block))
# Farm few more with reward
for i in range(0, num_blocks):
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
# Confirm we have the funds
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(5, wallet.get_confirmed_balance, funds)
async def get_tx_count(wallet_id):
txs = await wsm.get_all_transactions(wallet_id)
return len(txs)
await time_out_assert(5, get_tx_count, 2 * (num_blocks - 1), 1)
# Reorg blocks that carry reward
num_blocks = 30
blocks_reorg = bt.get_consecutive_blocks(
num_blocks, block_list_input=default_400_blocks[:-5])
for block in blocks_reorg[-30:]:
await full_node_api.full_node.respond_block(
full_node_protocol.RespondBlock(block))
await time_out_assert(5, get_tx_count, 0, 1)
await time_out_assert(5, wallet.get_confirmed_balance, 0)
async def test_wallet_coinbase(self, wallet_node):
num_blocks = 10
full_nodes, wallets = wallet_node
full_node_api = full_nodes[0]
server_1: ChiaServer = full_node_api.full_node.server
wallet_node, server_2 = wallets[0]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(
PeerInfo(self_hostname, uint16(server_1._port)), None)
for i in range(0, num_blocks):
await full_node_api.farm_new_block(FarmNewBlockProtocol(ph))
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph)
)
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph)
)
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks + 2)
])
async def check_tx_are_pool_farm_rewards():
wsm: WalletStateManager = wallet_node.wallet_state_manager
all_txs = await wsm.get_all_transactions(1)
expected_count = (num_blocks + 1) * 2
if len(all_txs) != expected_count:
return False
pool_rewards = 0
farm_rewards = 0
for tx in all_txs:
if tx.type == TransactionType.COINBASE_REWARD:
pool_rewards += 1
elif tx.type == TransactionType.FEE_REWARD:
farm_rewards += 1
if pool_rewards != expected_count / 2:
return False
if farm_rewards != expected_count / 2:
return False
return True
await time_out_assert(10, check_tx_are_pool_farm_rewards, True)
await time_out_assert(5, wallet.get_confirmed_balance, funds)
def get_future_reward_coins(block: FullBlock) -> Tuple[Coin, Coin]:
pool_amount = calculate_pool_reward(block.height)
farmer_amount = calculate_base_farmer_reward(block.height)
if block.is_transaction_block():
assert block.transactions_info is not None
farmer_amount = uint64(farmer_amount + block.transactions_info.fees)
pool_coin: Coin = create_pool_coin(
block.height, block.foliage.foliage_block_data.pool_target.puzzle_hash,
pool_amount, constants.GENESIS_CHALLENGE)
farmer_coin: Coin = create_farmer_coin(
block.height,
block.foliage.foliage_block_data.farmer_reward_puzzle_hash,
farmer_amount,
constants.GENESIS_CHALLENGE,
)
return pool_coin, farmer_coin
def get_future_reward_coins(self, height: uint32) -> Tuple[Coin, Coin]:
pool_amount = calculate_pool_reward(height)
farmer_amount = calculate_base_farmer_reward(height)
if self.is_block():
assert self.transactions_info is not None
farmer_amount = uint64(farmer_amount + self.transactions_info.fees)
pool_coin: Coin = create_pool_coin(
self.sub_block_height,
self.foliage_sub_block.foliage_sub_block_data.pool_target.
puzzle_hash,
pool_amount,
)
farmer_coin: Coin = create_farmer_coin(
self.sub_block_height,
self.foliage_sub_block.foliage_sub_block_data.
farmer_reward_puzzle_hash,
farmer_amount,
)
return pool_coin, farmer_coin
async def test_wallet_coinbase(self, wallet_node):
num_blocks = 5
full_nodes, wallets = wallet_node
full_node_api = full_nodes[0]
full_node_server = full_node_api.server
wallet_node, server_2 = wallets[0]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(
PeerInfo(self_hostname, uint16(full_node_server._port)), None)
for i in range(num_blocks):
await full_node_api.farm_new_block(FarmNewBlockProtocol(ph))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
# funds += calculate_base_farmer_reward(0)
await asyncio.sleep(2)
print(await wallet.get_confirmed_balance(), funds)
await time_out_assert(10, wallet.get_confirmed_balance, funds)
async def validate_block_body(
constants: ConsensusConstants,
sub_blocks: Dict[bytes32, SubBlockRecord],
sub_height_to_hash: Dict[uint32, bytes32],
block_store: BlockStore,
coin_store: CoinStore,
peak: Optional[SubBlockRecord],
block: Union[FullBlock, UnfinishedBlock],
sub_height: uint32,
height: Optional[uint32],
cached_cost_result: Optional[CostResult] = None,
) -> Optional[Err]:
"""
This assumes the header block has been completely validated.
Validates the transactions and body of the block. Returns None if everything
validates correctly, or an Err if something does not validate.
"""
if isinstance(block, FullBlock):
assert sub_height == block.sub_block_height
if height is not None:
assert height == block.height
assert block.is_block()
else:
assert not block.is_block()
# 1. For non block sub-blocks, foliage block, transaction filter, transactions info, and generator must be empty
# If it is a sub block but not a block, there is no body to validate. Check that all fields are None
if block.foliage_sub_block.foliage_block_hash is None:
if (block.foliage_block is not None
or block.transactions_info is not None
or block.transactions_generator is not None):
return Err.NOT_BLOCK_BUT_HAS_DATA
return None # This means the sub-block is valid
# 2. For blocks, foliage block, transaction filter, transactions info must not be empty
if block.foliage_block is None or block.foliage_block.filter_hash is None or block.transactions_info is None:
return Err.IS_BLOCK_BUT_NO_DATA
# keeps track of the reward coins that need to be incorporated
expected_reward_coins: Set[Coin] = set()
# 3. The transaction info hash in the Foliage block must match the transaction info
if block.foliage_block.transactions_info_hash != std_hash(
block.transactions_info):
return Err.INVALID_TRANSACTIONS_INFO_HASH
# 4. The foliage block hash in the foliage sub block must match the foliage block
if block.foliage_sub_block.foliage_block_hash != std_hash(
block.foliage_block):
return Err.INVALID_FOLIAGE_BLOCK_HASH
# 5. The prev generators root must be valid
# TODO(straya): implement prev generators
# 6. The generator root must be the tree-hash of the generator (or zeroes if no generator)
if block.transactions_generator is not None:
if block.transactions_generator.get_tree_hash(
) != block.transactions_info.generator_root:
return Err.INVALID_TRANSACTIONS_GENERATOR_ROOT
else:
if block.transactions_info.generator_root != bytes([0] * 32):
return Err.INVALID_TRANSACTIONS_GENERATOR_ROOT
# 7. The reward claims must be valid for the previous sub-blocks, and current block fees
if sub_height > 0:
# Add reward claims for all sub-blocks from the prev prev block, until the prev block (including the latter)
prev_block = sub_blocks[block.foliage_block.prev_block_hash]
assert prev_block.fees is not None
pool_coin = create_pool_coin(
prev_block.sub_block_height,
prev_block.pool_puzzle_hash,
calculate_pool_reward(prev_block.height),
)
farmer_coin = create_farmer_coin(
prev_block.sub_block_height,
prev_block.farmer_puzzle_hash,
uint64(
calculate_base_farmer_reward(prev_block.height) +
prev_block.fees),
)
# Adds the previous block
expected_reward_coins.add(pool_coin)
expected_reward_coins.add(farmer_coin)
# For the second block in the chain, don't go back further
if prev_block.sub_block_height > 0:
curr_sb = sub_blocks[prev_block.prev_hash]
curr_height = curr_sb.height
while not curr_sb.is_block:
expected_reward_coins.add(
create_pool_coin(
curr_sb.sub_block_height,
curr_sb.pool_puzzle_hash,
calculate_pool_reward(curr_height),
))
expected_reward_coins.add(
create_farmer_coin(
curr_sb.sub_block_height,
curr_sb.farmer_puzzle_hash,
calculate_base_farmer_reward(curr_height),
))
curr_sb = sub_blocks[curr_sb.prev_hash]
if set(block.transactions_info.reward_claims_incorporated
) != expected_reward_coins:
return Err.INVALID_REWARD_COINS
removals: List[bytes32] = []
coinbase_additions: List[Coin] = list(expected_reward_coins)
additions: List[Coin] = []
npc_list: List[NPC] = []
removals_puzzle_dic: Dict[bytes32, bytes32] = {}
cost: uint64 = uint64(0)
if block.transactions_generator is not None:
# Get List of names removed, puzzles hashes for removed coins and conditions crated
if cached_cost_result is not None:
result: CostResult = cached_cost_result
else:
result = calculate_cost_of_program(
block.transactions_generator,
constants.CLVM_COST_RATIO_CONSTANT)
cost = result.cost
npc_list = result.npc_list
# 8. Check that cost <= MAX_BLOCK_COST_CLVM
if cost > constants.MAX_BLOCK_COST_CLVM:
return Err.BLOCK_COST_EXCEEDS_MAX
if result.error is not None:
return Err(result.error)
for npc in npc_list:
removals.append(npc.coin_name)
removals_puzzle_dic[npc.coin_name] = npc.puzzle_hash
additions = additions_for_npc(npc_list)
# 9. Check that the correct cost is in the transactions info
if block.transactions_info.cost != cost:
return Err.INVALID_BLOCK_COST
additions_dic: Dict[bytes32, Coin] = {}
# 10. Check additions for max coin amount
for coin in additions + coinbase_additions:
additions_dic[coin.name()] = coin
if coin.amount >= constants.MAX_COIN_AMOUNT:
return Err.COIN_AMOUNT_EXCEEDS_MAXIMUM
# 11. Validate addition and removal roots
root_error = validate_block_merkle_roots(
block.foliage_block.additions_root,
block.foliage_block.removals_root,
additions + coinbase_additions,
removals,
)
if root_error:
return root_error
# 12. The additions and removals must result in the correct filter
byte_array_tx: List[bytes32] = []
for coin in additions + coinbase_additions:
byte_array_tx.append(bytearray(coin.puzzle_hash))
for coin_name in removals:
byte_array_tx.append(bytearray(coin_name))
bip158: PyBIP158 = PyBIP158(byte_array_tx)
encoded_filter = bytes(bip158.GetEncoded())
filter_hash = std_hash(encoded_filter)
if filter_hash != block.foliage_block.filter_hash:
return Err.INVALID_TRANSACTIONS_FILTER_HASH
# 13. Check for duplicate outputs in additions
addition_counter = collections.Counter(
_.name() for _ in additions + coinbase_additions)
for k, v in addition_counter.items():
if v > 1:
return Err.DUPLICATE_OUTPUT
# 14. Check for duplicate spends inside block
removal_counter = collections.Counter(removals)
for k, v in removal_counter.items():
if v > 1:
return Err.DOUBLE_SPEND
# 15. Check if removals exist and were not previously spent. (unspent_db + diff_store + this_block)
if peak is None or sub_height == 0:
fork_sub_h: int = -1
else:
fork_sub_h = find_fork_point_in_chain(
sub_blocks, peak, sub_blocks[block.prev_header_hash])
if fork_sub_h == -1:
coin_store_reorg_height = -1
else:
last_sb_in_common = sub_blocks[sub_height_to_hash[uint32(fork_sub_h)]]
if last_sb_in_common.is_block:
coin_store_reorg_height = last_sb_in_common.height
else:
coin_store_reorg_height = last_sb_in_common.height - 1
# Get additions and removals since (after) fork_h but not including this block
additions_since_fork: Dict[bytes32, Tuple[Coin, uint32]] = {}
removals_since_fork: Set[bytes32] = set()
coinbases_since_fork: Dict[bytes32, uint32] = {}
if sub_height > 0:
curr: Optional[FullBlock] = await block_store.get_full_block(
block.prev_header_hash)
assert curr is not None
while curr.sub_block_height > fork_sub_h:
removals_in_curr, additions_in_curr = curr.tx_removals_and_additions(
)
for c_name in removals_in_curr:
removals_since_fork.add(c_name)
for c in additions_in_curr:
additions_since_fork[c.name()] = (c, curr.sub_block_height)
for coinbase_coin in curr.get_included_reward_coins():
additions_since_fork[coinbase_coin.name()] = (
coinbase_coin, curr.sub_block_height)
coinbases_since_fork[
coinbase_coin.name()] = curr.sub_block_height
if curr.sub_block_height == 0:
break
curr = await block_store.get_full_block(curr.prev_header_hash)
assert curr is not None
removal_coin_records: Dict[bytes32, CoinRecord] = {}
for rem in removals:
if rem in additions_dic:
# Ephemeral coin
rem_coin: Coin = additions_dic[rem]
new_unspent: CoinRecord = CoinRecord(
rem_coin,
sub_height,
uint32(0),
False,
False,
block.foliage_block.timestamp,
)
removal_coin_records[new_unspent.name] = new_unspent
else:
unspent = await coin_store.get_coin_record(rem)
if unspent is not None and unspent.confirmed_block_index <= coin_store_reorg_height:
# Spending something in the current chain, confirmed before fork
# (We ignore all coins confirmed after fork)
if unspent.spent == 1 and unspent.spent_block_index <= coin_store_reorg_height:
# Check for coins spent in an ancestor block
return Err.DOUBLE_SPEND
removal_coin_records[unspent.name] = unspent
else:
# This coin is not in the current heaviest chain, so it must be in the fork
if rem not in additions_since_fork:
# Check for spending a coin that does not exist in this fork
# TODO: fix this, there is a consensus bug here
return Err.UNKNOWN_UNSPENT
new_coin, confirmed_height = additions_since_fork[rem]
new_coin_record: CoinRecord = CoinRecord(
new_coin,
confirmed_height,
uint32(0),
False,
(rem in coinbases_since_fork),
block.foliage_block.timestamp,
)
removal_coin_records[new_coin_record.name] = new_coin_record
# This check applies to both coins created before fork (pulled from coin_store),
# and coins created after fork (additions_since_fork)>
if rem in removals_since_fork:
# This coin was spent in the fork
return Err.DOUBLE_SPEND
removed = 0
for unspent in removal_coin_records.values():
removed += unspent.coin.amount
added = 0
for coin in additions:
added += coin.amount
# 16. Check that the total coin amount for added is <= removed
if removed < added:
return Err.MINTING_COIN
fees = removed - added
assert_fee_sum: uint64 = uint64(0)
for npc in npc_list:
if ConditionOpcode.ASSERT_FEE in npc.condition_dict:
fee_list: List[ConditionVarPair] = npc.condition_dict[
ConditionOpcode.ASSERT_FEE]
for cvp in fee_list:
fee = int_from_bytes(cvp.vars[0])
assert_fee_sum = assert_fee_sum + fee
# 17. Check that the assert fee sum <= fees
if fees < assert_fee_sum:
return Err.ASSERT_FEE_CONDITION_FAILED
# 18. Check that the computed fees are equal to the fees in the block header
if block.transactions_info.fees != fees:
return Err.INVALID_BLOCK_FEE_AMOUNT
# 19. Verify that removed coin puzzle_hashes match with calculated puzzle_hashes
for unspent in removal_coin_records.values():
if unspent.coin.puzzle_hash != removals_puzzle_dic[unspent.name]:
return Err.WRONG_PUZZLE_HASH
# 20. Verify conditions
# create hash_key list for aggsig check
pairs_pks = []
pairs_msgs = []
for npc in npc_list:
assert height is not None
unspent = removal_coin_records[npc.coin_name]
error = blockchain_check_conditions_dict(
unspent,
removal_coin_records,
npc.condition_dict,
height,
block.foliage_block.timestamp,
)
if error:
return error
for pk, m in pkm_pairs_for_conditions_dict(npc.condition_dict,
npc.coin_name):
pairs_pks.append(pk)
pairs_msgs.append(m)
# 21. Verify aggregated signature
# TODO: move this to pre_validate_blocks_multiprocessing so we can sync faster
if not block.transactions_info.aggregated_signature:
return Err.BAD_AGGREGATE_SIGNATURE
if len(pairs_pks) == 0:
if len(
pairs_msgs
) != 0 or block.transactions_info.aggregated_signature != G2Element.infinity(
):
return Err.BAD_AGGREGATE_SIGNATURE
else:
# noinspection PyTypeChecker
validates = AugSchemeMPL.aggregate_verify(
pairs_pks, pairs_msgs,
block.transactions_info.aggregated_signature)
if not validates:
return Err.BAD_AGGREGATE_SIGNATURE
return None
async def test_wallet_make_transaction(self, two_wallet_nodes):
test_rpc_port = uint16(21529)
num_blocks = 5
full_nodes, wallets = two_wallet_nodes
full_node_api = full_nodes[0]
full_node_server = full_node_api.full_node.server
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
wallet = wallet_node.wallet_state_manager.main_wallet
wallet_2 = wallet_node_2.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
ph_2 = await wallet_2.get_new_puzzlehash()
await server_2.start_client(
PeerInfo("localhost", uint16(full_node_server._port)), None)
for i in range(0, num_blocks):
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
initial_funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
initial_funds_eventually = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks + 1)
])
wallet_rpc_api = WalletRpcApi(wallet_node)
config = bt.config
hostname = config["self_hostname"]
daemon_port = config["daemon_port"]
def stop_node_cb():
pass
rpc_cleanup = await start_rpc_server(
wallet_rpc_api,
hostname,
daemon_port,
test_rpc_port,
stop_node_cb,
bt.root_path,
config,
connect_to_daemon=False,
)
await time_out_assert(5, wallet.get_confirmed_balance, initial_funds)
await time_out_assert(5, wallet.get_unconfirmed_balance, initial_funds)
client = await WalletRpcClient.create("localhost", test_rpc_port,
bt.root_path, config)
try:
addr = encode_puzzle_hash(
await wallet_node_2.wallet_state_manager.main_wallet.
get_new_puzzlehash(), "xch")
tx_amount = 15600000
try:
await client.send_transaction("1", 100000000000000001, addr)
raise Exception("Should not create high value tx")
except ValueError:
pass
tx = await client.send_transaction("1", tx_amount, addr)
transaction_id = tx.name
async def tx_in_mempool():
tx = await client.get_transaction("1", transaction_id)
return tx.is_in_mempool()
await time_out_assert(5, tx_in_mempool, True)
await time_out_assert(5, wallet.get_unconfirmed_balance,
initial_funds - tx_amount)
assert (
await client.get_wallet_balance("1")
)["unconfirmed_wallet_balance"] == initial_funds - tx_amount
assert (await client.get_wallet_balance("1")
)["confirmed_wallet_balance"] == initial_funds
for i in range(0, 5):
await client.farm_block(encode_puzzle_hash(ph_2, "xch"))
await asyncio.sleep(1)
async def eventual_balance():
return (
await
client.get_wallet_balance("1"))["confirmed_wallet_balance"]
await time_out_assert(5, eventual_balance,
initial_funds_eventually - tx_amount)
address = await client.get_next_address("1")
assert len(address) > 10
transactions = await client.get_transactions("1")
assert len(transactions) > 1
pks = await client.get_public_keys()
assert len(pks) == 1
assert (await client.get_height_info()) > 0
sk_dict = await client.get_private_key(pks[0])
assert sk_dict["fingerprint"] == pks[0]
assert sk_dict["sk"] is not None
assert sk_dict["pk"] is not None
assert sk_dict["seed"] is not None
mnemonic = await client.generate_mnemonic()
assert len(mnemonic) == 24
await client.add_key(mnemonic)
pks = await client.get_public_keys()
assert len(pks) == 2
await client.log_in_and_skip(pks[1])
sk_dict = await client.get_private_key(pks[1])
assert sk_dict["fingerprint"] == pks[1]
await client.delete_key(pks[0])
await client.log_in_and_skip(pks[1])
assert len(await client.get_public_keys()) == 1
assert not (await client.get_sync_status())
wallets = await client.get_wallets()
assert len(wallets) == 1
balance = await client.get_wallet_balance(wallets[0]["id"])
assert balance["unconfirmed_wallet_balance"] == 0
test_wallet_backup_path = Path("test_wallet_backup_file")
await client.create_backup(test_wallet_backup_path)
assert test_wallet_backup_path.exists()
test_wallet_backup_path.unlink()
try:
await client.send_transaction(wallets[0]["id"], 100, addr)
raise Exception("Should not create tx if no balance")
except ValueError:
pass
await client.delete_all_keys()
assert len(await client.get_public_keys()) == 0
finally:
# Checks that the RPC manages to stop the node
client.close()
await client.await_closed()
await rpc_cleanup()
async def test_cc_spend(self, two_wallet_nodes):
num_blocks = 3
full_nodes, wallets = two_wallet_nodes
full_node_api = full_nodes[0]
full_node_server = full_node_api.server
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
wallet = wallet_node.wallet_state_manager.main_wallet
wallet2 = wallet_node_2.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
await server_3.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
funds = sum(
[
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks - 1)
]
)
await time_out_assert(15, wallet.get_confirmed_balance, funds)
cc_wallet: CCWallet = await CCWallet.create_new_cc(wallet_node.wallet_state_manager, wallet, uint64(100))
tx_queue: List[TransactionRecord] = await wallet_node.wallet_state_manager.get_send_queue()
tx_record = tx_queue[0]
await time_out_assert(
15, tx_in_pool, True, full_node_api.full_node.mempool_manager, tx_record.spend_bundle.name()
)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(15, cc_wallet.get_confirmed_balance, 100)
await time_out_assert(15, cc_wallet.get_unconfirmed_balance, 100)
assert cc_wallet.cc_info.my_genesis_checker is not None
colour = cc_wallet.get_colour()
cc_wallet_2: CCWallet = await CCWallet.create_wallet_for_cc(wallet_node_2.wallet_state_manager, wallet2, colour)
assert cc_wallet.cc_info.my_genesis_checker == cc_wallet_2.cc_info.my_genesis_checker
cc_2_hash = await cc_wallet_2.get_new_inner_hash()
tx_record = await cc_wallet.generate_signed_transaction([uint64(60)], [cc_2_hash])
await wallet.wallet_state_manager.add_pending_transaction(tx_record)
await time_out_assert(
15, tx_in_pool, True, full_node_api.full_node.mempool_manager, tx_record.spend_bundle.name()
)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
await time_out_assert(15, cc_wallet.get_confirmed_balance, 40)
await time_out_assert(15, cc_wallet.get_unconfirmed_balance, 40)
await time_out_assert(30, cc_wallet_2.get_confirmed_balance, 60)
await time_out_assert(30, cc_wallet_2.get_unconfirmed_balance, 60)
cc_hash = await cc_wallet.get_new_inner_hash()
tx_record = await cc_wallet_2.generate_signed_transaction([uint64(15)], [cc_hash])
await wallet.wallet_state_manager.add_pending_transaction(tx_record)
await time_out_assert(
15, tx_in_pool, True, full_node_api.full_node.mempool_manager, tx_record.spend_bundle.name()
)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
await time_out_assert(15, cc_wallet.get_confirmed_balance, 55)
await time_out_assert(15, cc_wallet.get_unconfirmed_balance, 55)
async def test_cc_max_amount_send(self, two_wallet_nodes):
num_blocks = 3
full_nodes, wallets = two_wallet_nodes
full_node_api = full_nodes[0]
full_node_server = full_node_api.server
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
await server_3.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
funds = sum(
[
calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks - 1)
]
)
await time_out_assert(15, wallet.get_confirmed_balance, funds)
cc_wallet: CCWallet = await CCWallet.create_new_cc(wallet_node.wallet_state_manager, wallet, uint64(100000))
tx_queue: List[TransactionRecord] = await wallet_node.wallet_state_manager.get_send_queue()
tx_record = tx_queue[0]
await time_out_assert(
15, tx_in_pool, True, full_node_api.full_node.mempool_manager, tx_record.spend_bundle.name()
)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(15, cc_wallet.get_confirmed_balance, 100000)
await time_out_assert(15, cc_wallet.get_unconfirmed_balance, 100000)
assert cc_wallet.cc_info.my_genesis_checker is not None
cc_2_hash = await cc_wallet.get_new_inner_hash()
amounts = []
puzzle_hashes = []
for i in range(1, 50):
amounts.append(uint64(i))
puzzle_hashes.append(cc_2_hash)
spent_coint = (await cc_wallet.get_cc_spendable_coins())[0].coin
tx_record = await cc_wallet.generate_signed_transaction(amounts, puzzle_hashes, coins={spent_coint})
await wallet.wallet_state_manager.add_pending_transaction(tx_record)
await time_out_assert(
15, tx_in_pool, True, full_node_api.full_node.mempool_manager, tx_record.spend_bundle.name()
)
for i in range(1, num_blocks):
await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
await asyncio.sleep(2)
async def check_all_there():
spendable = await cc_wallet.get_cc_spendable_coins()
spendable_name_set = set()
for record in spendable:
spendable_name_set.add(record.coin.name())
puzzle_hash = cc_puzzle_hash_for_inner_puzzle_hash(CC_MOD, cc_wallet.cc_info.my_genesis_checker, cc_2_hash)
for i in range(1, 50):
coin = Coin(spent_coint.name(), puzzle_hash, i)
if coin.name() not in spendable_name_set:
return False
return True
await time_out_assert(15, check_all_there, True)
await asyncio.sleep(5)
max_sent_amount = await cc_wallet.get_max_send_amount()
# 1) Generate transaction that is under the limit
under_limit_tx = None
try:
under_limit_tx = await cc_wallet.generate_signed_transaction(
[max_sent_amount - 1],
[ph],
)
except ValueError:
assert ValueError
assert under_limit_tx is not None
# 2) Generate transaction that is equal to limit
at_limit_tx = None
try:
at_limit_tx = await cc_wallet.generate_signed_transaction(
[max_sent_amount],
[ph],
)
except ValueError:
assert ValueError
assert at_limit_tx is not None
# 3) Generate transaction that is greater than limit
above_limit_tx = None
try:
above_limit_tx = await cc_wallet.generate_signed_transaction(
[max_sent_amount + 1],
[ph],
)
except ValueError:
pass
assert above_limit_tx is None
from clvm_tools import binutils
from src.types.blockchain_format.program import Program
from src.types.condition_opcodes import ConditionOpcode
from src.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
from src.util.condition_tools import parse_sexp_to_conditions
from src.consensus.block_rewards import calculate_pool_reward, calculate_base_farmer_reward
from src.util.ints import uint32
address1 = "txch15gx26ndmacfaqlq8m0yajeggzceu7cvmaz4df0hahkukes695rss6lej7h" # Gene wallet (m/12381/8444/2/42):
address2 = "txch1c2cguswhvmdyz9hr3q6hak2h6p9dw4rz82g4707k2xy2sarv705qcce4pn" # Mariano address (m/12381/8444/2/0)
ph1 = decode_puzzle_hash(address1)
ph2 = decode_puzzle_hash(address2)
pool_amounts = int(calculate_pool_reward(uint32(0)) / 2)
farmer_amounts = int(calculate_base_farmer_reward(uint32(0)) / 2)
assert pool_amounts * 2 == calculate_pool_reward(uint32(0))
assert farmer_amounts * 2 == calculate_base_farmer_reward(uint32(0))
def make_puzzle(amount: int) -> int:
puzzle = f"(q . ((51 0x{ph1.hex()} {amount}) (51 0x{ph2.hex()} {amount})))"
# print(puzzle)
puzzle_prog = Program.to(binutils.assemble(puzzle))
print("Program: ", puzzle_prog)
puzzle_hash = puzzle_prog.get_tree_hash()
solution = "()"
async def test_mempool_tx_sync(self, three_nodes_two_wallets):
num_blocks = 5
full_nodes, wallets = three_nodes_two_wallets
wallet_0, wallet_server_0 = wallets[0]
full_node_api_0 = full_nodes[0]
server_0 = full_node_api_0.server
full_node_api_1 = full_nodes[1]
server_1 = full_node_api_1.server
full_node_api_2 = full_nodes[2]
server_2 = full_node_api_2.server
ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash(
)
# wallet0 <-> sever0 <-> server1
await wallet_server_0.start_client(
PeerInfo(self_hostname, uint16(server_0._port)), None)
await server_0.start_client(
PeerInfo(self_hostname, uint16(server_1._port)), None)
for i in range(num_blocks):
await full_node_api_0.farm_new_block(FarmNewBlockProtocol(ph))
all_blocks = await full_node_api_0.get_all_full_blocks()
for block in all_blocks:
await full_node_api_2.full_node.respond_sub_block(
full_node_protocol.RespondSubBlock(block))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(
10,
wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance,
funds)
tx = await wallet_0.wallet_state_manager.main_wallet.generate_signed_transaction(
10, token_bytes(), 0)
await wallet_0.wallet_state_manager.main_wallet.push_transaction(tx)
await time_out_assert(
10,
full_node_api_0.full_node.mempool_manager.get_spendbundle,
tx.spend_bundle,
tx.name,
)
await time_out_assert(
10,
full_node_api_1.full_node.mempool_manager.get_spendbundle,
tx.spend_bundle,
tx.name,
)
await time_out_assert(
10,
full_node_api_2.full_node.mempool_manager.get_spendbundle,
None,
tx.name,
)
# make a final connection.
# wallet0 <-> sever0 <-> server1 <-> server2
await server_1.start_client(
PeerInfo(self_hostname, uint16(server_2._port)), None)
await time_out_assert(
10,
full_node_api_0.full_node.mempool_manager.get_spendbundle,
tx.spend_bundle,
tx.name,
)
await time_out_assert(
10,
full_node_api_1.full_node.mempool_manager.get_spendbundle,
tx.spend_bundle,
tx.name,
)
await time_out_assert(
10,
full_node_api_2.full_node.mempool_manager.get_spendbundle,
tx.spend_bundle,
tx.name,
)
async def test_wallet_create_hit_max_send_amount(self, two_wallet_nodes):
num_blocks = 5
full_nodes, wallets = two_wallet_nodes
full_node_1 = full_nodes[0]
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
wallet = wallet_node.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_2.start_client(
PeerInfo(self_hostname,
uint16(full_node_1.full_node.server._port)), None)
for i in range(0, num_blocks):
await full_node_1.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(5, wallet.get_confirmed_balance, funds)
primaries = []
for i in range(0, 600):
primaries.append({"puzzlehash": ph, "amount": 100000000 + i})
tx_split_coins = await wallet.generate_signed_transaction(
1, ph, 0, primaries=primaries)
await wallet.push_transaction(tx_split_coins)
await time_out_assert(15, tx_in_pool, True,
full_node_1.full_node.mempool_manager,
tx_split_coins.spend_bundle.name())
for i in range(0, num_blocks):
await full_node_1.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks + 1)
])
await time_out_assert(90, wallet.get_confirmed_balance, funds)
max_sent_amount = await wallet.get_max_send_amount()
# 1) Generate transaction that is under the limit
under_limit_tx = None
try:
under_limit_tx = await wallet.generate_signed_transaction(
max_sent_amount - 1,
ph,
0,
)
except ValueError:
assert ValueError
assert under_limit_tx is not None
# 2) Generate transaction that is equal to limit
at_limit_tx = None
try:
at_limit_tx = await wallet.generate_signed_transaction(
max_sent_amount,
ph,
0,
)
except ValueError:
assert ValueError
assert at_limit_tx is not None
# 3) Generate transaction that is greater than limit
above_limit_tx = None
try:
above_limit_tx = await wallet.generate_signed_transaction(
max_sent_amount + 1,
ph,
0,
)
except ValueError:
pass
assert above_limit_tx is None
async def test_wallet_make_transaction_hop(self,
two_wallet_nodes_five_freeze):
num_blocks = 10
full_nodes, wallets = two_wallet_nodes_five_freeze
full_node_api_0 = full_nodes[0]
full_node_0 = full_node_api_0.full_node
server_0 = full_node_0.server
wallet_node_0, wallet_0_server = wallets[0]
wallet_node_1, wallet_1_server = wallets[1]
wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
wallet_1 = wallet_node_1.wallet_state_manager.main_wallet
ph = await wallet_0.get_new_puzzlehash()
await wallet_0_server.start_client(
PeerInfo(self_hostname, uint16(server_0._port)), None)
await wallet_1_server.start_client(
PeerInfo(self_hostname, uint16(server_0._port)), None)
for i in range(0, num_blocks):
await full_node_api_0.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(5, wallet_0.get_confirmed_balance, funds)
await time_out_assert(5, wallet_0.get_unconfirmed_balance, funds)
assert await wallet_0.get_confirmed_balance() == funds
assert await wallet_0.get_unconfirmed_balance() == funds
tx = await wallet_0.generate_signed_transaction(
10,
await
wallet_node_1.wallet_state_manager.main_wallet.get_new_puzzlehash(
),
0,
)
await wallet_0.push_transaction(tx)
# Full node height 11, wallet height 9
await time_out_assert(5, wallet_0.get_confirmed_balance, funds)
await time_out_assert(5, wallet_0.get_unconfirmed_balance, funds - 10)
for i in range(0, 4):
await full_node_api_0.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
# here it's num_blocks + 1 because our last reward is included in the first block that we just farmed
new_funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks + 1)
])
# Full node height 17, wallet height 15
await time_out_assert(5, wallet_0.get_confirmed_balance,
new_funds - 10)
await time_out_assert(5, wallet_0.get_unconfirmed_balance,
new_funds - 10)
await time_out_assert(5, wallet_1.get_confirmed_balance, 10)
tx = await wallet_1.generate_signed_transaction(
5, await wallet_0.get_new_puzzlehash(), 0)
await wallet_1.push_transaction(tx)
for i in range(0, 4):
await full_node_api_0.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await wallet_0.get_confirmed_balance()
await wallet_0.get_unconfirmed_balance()
await wallet_1.get_confirmed_balance()
await time_out_assert(5, wallet_0.get_confirmed_balance, new_funds - 5)
await time_out_assert(5, wallet_0.get_unconfirmed_balance,
new_funds - 5)
await time_out_assert(5, wallet_1.get_confirmed_balance, 5)
async def test_tx_propagation(self, three_nodes_two_wallets):
num_blocks = 5
full_nodes, wallets = three_nodes_two_wallets
wallet_0, wallet_server_0 = wallets[0]
wallet_1, wallet_server_1 = wallets[1]
full_node_api_0 = full_nodes[0]
server_0 = full_node_api_0.server
full_node_api_1 = full_nodes[1]
server_1 = full_node_api_1.server
full_node_api_2 = full_nodes[2]
server_2 = full_node_api_2.server
ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash(
)
ph1 = await wallet_1.wallet_state_manager.main_wallet.get_new_puzzlehash(
)
#
# wallet0 <-> sever0 <-> server1 <-> server2 <-> wallet1
#
await wallet_server_0.start_client(
PeerInfo(self_hostname, uint16(server_0._port)), None)
await server_0.start_client(
PeerInfo(self_hostname, uint16(server_1._port)), None)
await server_1.start_client(
PeerInfo(self_hostname, uint16(server_2._port)), None)
await wallet_server_1.start_client(
PeerInfo(self_hostname, uint16(server_2._port)), None)
for i in range(num_blocks):
await full_node_api_0.farm_new_block(FarmNewBlockProtocol(ph))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(
10,
wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance,
funds)
tx = await wallet_0.wallet_state_manager.main_wallet.generate_signed_transaction(
10, ph1, 0)
await wallet_0.wallet_state_manager.main_wallet.push_transaction(tx)
await time_out_assert(
10,
full_node_api_0.full_node.mempool_manager.get_spendbundle,
tx.spend_bundle,
tx.name,
)
await time_out_assert(
10,
full_node_api_1.full_node.mempool_manager.get_spendbundle,
tx.spend_bundle,
tx.name,
)
await time_out_assert(
10,
full_node_api_2.full_node.mempool_manager.get_spendbundle,
tx.spend_bundle,
tx.name,
)
# Farm another block
for i in range(1, 8):
await full_node_api_1.farm_new_block(
FarmNewBlockProtocol(token_bytes()))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks + 1)
])
print(f"Funds: {funds}")
await time_out_assert(
10,
wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance,
(funds - 10),
)
await time_out_assert(
15,
wallet_1.wallet_state_manager.main_wallet.get_confirmed_balance,
10)
def create_foliage(
constants: ConsensusConstants,
reward_block_unfinished: RewardChainBlockUnfinished,
spend_bundle: Optional[SpendBundle],
additions: List[Coin],
removals: List[Coin],
prev_block: Optional[BlockRecord],
blocks: BlockchainInterface,
total_iters_sp: uint128,
timestamp: uint64,
farmer_reward_puzzlehash: bytes32,
pool_target: PoolTarget,
get_plot_signature: Callable[[bytes32, G1Element], G2Element],
get_pool_signature: Callable[[PoolTarget, Optional[G1Element]],
Optional[G2Element]],
seed: bytes32 = b"",
) -> Tuple[Foliage, Optional[FoliageTransactionBlock],
Optional[TransactionsInfo], Optional[SerializedProgram]]:
"""
Creates a foliage for a given reward chain block. This may or may not be a tx block. In the case of a tx block,
the return values are not None. This is called at the signage point, so some of this information may be
tweaked at the infusion point.
Args:
constants: consensus constants being used for this chain
reward_block_unfinished: the reward block to look at, potentially at the signage point
spend_bundle: the spend bundle including all transactions
prev_block: the previous block at the signage point
blocks: dict from header hash to blocks, of all ancestor blocks
total_iters_sp: total iters at the signage point
timestamp: timestamp to put into the foliage block
farmer_reward_puzzlehash: where to pay out farming reward
pool_target: where to pay out pool reward
get_plot_signature: retrieve the signature corresponding to the plot public key
get_pool_signature: retrieve the signature corresponding to the pool public key
seed: seed to randomize block
"""
if prev_block is not None:
res = get_prev_transaction_block(prev_block, blocks, total_iters_sp)
is_transaction_block: bool = res[0]
prev_transaction_block: Optional[BlockRecord] = res[1]
else:
# Genesis is a transaction block
prev_transaction_block = None
is_transaction_block = True
random.seed(seed)
# Use the extension data to create different blocks based on header hash
extension_data: bytes32 = random.randint(0, 100000000).to_bytes(32, "big")
if prev_block is None:
height: uint32 = uint32(0)
else:
height = uint32(prev_block.height + 1)
# Create filter
byte_array_tx: List[bytes32] = []
tx_additions: List[Coin] = []
tx_removals: List[bytes32] = []
pool_target_signature: Optional[G2Element] = get_pool_signature(
pool_target, reward_block_unfinished.proof_of_space.pool_public_key)
foliage_data = FoliageBlockData(
reward_block_unfinished.get_hash(),
pool_target,
pool_target_signature,
farmer_reward_puzzlehash,
extension_data,
)
foliage_block_data_signature: G2Element = get_plot_signature(
foliage_data.get_hash(),
reward_block_unfinished.proof_of_space.plot_public_key,
)
prev_block_hash: bytes32 = constants.GENESIS_CHALLENGE
if height != 0:
assert prev_block is not None
prev_block_hash = prev_block.header_hash
solution_program: Optional[SerializedProgram] = None
if is_transaction_block:
spend_bundle_fees: int = 0
aggregate_sig: G2Element = G2Element.infinity()
cost = uint64(0)
if spend_bundle is not None:
solution_program = best_solution_program(spend_bundle)
aggregate_sig = spend_bundle.aggregated_signature
# Calculate the cost of transactions
if solution_program is not None:
result: CostResult = calculate_cost_of_program(
solution_program, constants.CLVM_COST_RATIO_CONSTANT)
cost = result.cost
removal_amount = 0
addition_amount = 0
for coin in removals:
removal_amount += coin.amount
for coin in additions:
addition_amount += coin.amount
spend_bundle_fees = removal_amount - addition_amount
else:
spend_bundle_fees = 0
# TODO: prev generators root
reward_claims_incorporated = []
if height > 0:
assert prev_transaction_block is not None
assert prev_block is not None
curr: BlockRecord = prev_block
while not curr.is_transaction_block:
curr = blocks.block_record(curr.prev_hash)
assert curr.fees is not None
pool_coin = create_pool_coin(
curr.height,
curr.pool_puzzle_hash,
calculate_pool_reward(curr.height),
)
farmer_coin = create_farmer_coin(
curr.height,
curr.farmer_puzzle_hash,
uint64(calculate_base_farmer_reward(curr.height) + curr.fees),
)
assert curr.header_hash == prev_transaction_block.header_hash
reward_claims_incorporated += [pool_coin, farmer_coin]
if curr.height > 0:
curr = blocks.block_record(curr.prev_hash)
# Prev block is not genesis
while not curr.is_transaction_block:
pool_coin = create_pool_coin(
curr.height,
curr.pool_puzzle_hash,
calculate_pool_reward(curr.height),
)
farmer_coin = create_farmer_coin(
curr.height,
curr.farmer_puzzle_hash,
calculate_base_farmer_reward(curr.height),
)
reward_claims_incorporated += [pool_coin, farmer_coin]
curr = blocks.block_record(curr.prev_hash)
additions.extend(reward_claims_incorporated.copy())
for coin in additions:
tx_additions.append(coin)
byte_array_tx.append(bytearray(coin.puzzle_hash))
for coin in removals:
tx_removals.append(coin.name())
byte_array_tx.append(bytearray(coin.name()))
bip158: PyBIP158 = PyBIP158(byte_array_tx)
encoded = bytes(bip158.GetEncoded())
removal_merkle_set = MerkleSet()
addition_merkle_set = MerkleSet()
# Create removal Merkle set
for coin_name in tx_removals:
removal_merkle_set.add_already_hashed(coin_name)
# Create addition Merkle set
puzzlehash_coin_map: Dict[bytes32, List[Coin]] = {}
for coin in tx_additions:
if coin.puzzle_hash in puzzlehash_coin_map:
puzzlehash_coin_map[coin.puzzle_hash].append(coin)
else:
puzzlehash_coin_map[coin.puzzle_hash] = [coin]
# Addition Merkle set contains puzzlehash and hash of all coins with that puzzlehash
for puzzle, coins in puzzlehash_coin_map.items():
addition_merkle_set.add_already_hashed(puzzle)
addition_merkle_set.add_already_hashed(hash_coin_list(coins))
additions_root = addition_merkle_set.get_root()
removals_root = removal_merkle_set.get_root()
generator_hash = solution_program.get_tree_hash(
) if solution_program is not None else bytes32([0] * 32)
filter_hash: bytes32 = std_hash(encoded)
transactions_info: Optional[TransactionsInfo] = TransactionsInfo(
bytes([0] * 32),
generator_hash,
aggregate_sig,
uint64(spend_bundle_fees),
cost,
reward_claims_incorporated,
)
if prev_transaction_block is None:
prev_transaction_block_hash: bytes32 = constants.GENESIS_CHALLENGE
else:
prev_transaction_block_hash = prev_transaction_block.header_hash
assert transactions_info is not None
foliage_transaction_block: Optional[
FoliageTransactionBlock] = FoliageTransactionBlock(
prev_transaction_block_hash,
timestamp,
filter_hash,
additions_root,
removals_root,
transactions_info.get_hash(),
)
assert foliage_transaction_block is not None
foliage_transaction_block_hash: Optional[
bytes32] = foliage_transaction_block.get_hash()
foliage_transaction_block_signature: Optional[
G2Element] = get_plot_signature(
foliage_transaction_block_hash,
reward_block_unfinished.proof_of_space.plot_public_key)
assert foliage_transaction_block_signature is not None
else:
foliage_transaction_block_hash = None
foliage_transaction_block_signature = None
foliage_transaction_block = None
transactions_info = None
assert (foliage_transaction_block_hash is
None) == (foliage_transaction_block_signature is None)
foliage = Foliage(
prev_block_hash,
reward_block_unfinished.get_hash(),
foliage_data,
foliage_block_data_signature,
foliage_transaction_block_hash,
foliage_transaction_block_signature,
)
return foliage, foliage_transaction_block, transactions_info, solution_program
async def test_wallet_send_to_three_peers(self, three_sim_two_wallets):
num_blocks = 10
full_nodes, wallets = three_sim_two_wallets
wallet_0, wallet_server_0 = wallets[0]
full_node_api_0 = full_nodes[0]
full_node_api_1 = full_nodes[1]
full_node_api_2 = full_nodes[2]
full_node_0 = full_node_api_0.full_node
full_node_1 = full_node_api_1.full_node
full_node_2 = full_node_api_2.full_node
server_0 = full_node_0.server
server_1 = full_node_1.server
server_2 = full_node_2.server
ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash(
)
# wallet0 <-> sever0
await wallet_server_0.start_client(
PeerInfo(self_hostname, uint16(server_0._port)), None)
for i in range(0, num_blocks):
await full_node_api_0.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
all_blocks = await full_node_api_0.get_all_full_blocks()
for block in all_blocks:
await full_node_1.respond_block(RespondBlock(block))
await full_node_2.respond_block(RespondBlock(block))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
await time_out_assert(
5, wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance,
funds)
tx = await wallet_0.wallet_state_manager.main_wallet.generate_signed_transaction(
10, 32 * b"0", 0)
await wallet_0.wallet_state_manager.main_wallet.push_transaction(tx)
await time_out_assert_not_none(
5, full_node_0.mempool_manager.get_spendbundle,
tx.spend_bundle.name())
# wallet0 <-> sever1
await wallet_server_0.start_client(
PeerInfo(self_hostname, uint16(server_1._port)),
wallet_0.on_connect)
await time_out_assert_not_none(
5, full_node_1.mempool_manager.get_spendbundle,
tx.spend_bundle.name())
# wallet0 <-> sever2
await wallet_server_0.start_client(
PeerInfo(self_hostname, uint16(server_2._port)),
wallet_0.on_connect)
await time_out_assert_not_none(
5, full_node_2.mempool_manager.get_spendbundle,
tx.spend_bundle.name())
