def test_not_enough_funds_to_run_payment_code(payment_node_network):
network = payment_node_network
node0: DockerNode = network.docker_nodes[0]
blocks = parse_show_blocks(node0.d_client.show_blocks(1000))
genesis_hash = blocks[0].summary.block_hash
assert len(
blocks) == 1 # There should be only one block - the genesis block
genesis_balance = node0.d_client.get_balance(
account_address=GENESIS_ACCOUNT.public_key_hex,
block_hash=genesis_hash)
assert genesis_balance == INITIAL_MOTES_AMOUNT
session_args = ABI.args([
ABI.account("account", GENESIS_ACCOUNT.public_key_hex),
ABI.u64("amount", 10**7),
])
node0.p_client.deploy(
from_address=GENESIS_ACCOUNT.public_key_hex,
session_contract=Contract.TRANSFER_TO_ACCOUNT,
payment_contract=Contract.STANDARD_PAYMENT,
public_key=GENESIS_ACCOUNT.public_key_path,
private_key=GENESIS_ACCOUNT.private_key_path,
gas_price=1,
session_args=session_args,
payment_args=ABI.args([ABI.u512("amount", 450)]),
)
latest_block_hash = parse_show_blocks(
node0.d_client.show_blocks(1000))[0].summary.block_hash
genesis_balance_after_transfer = node0.d_client.get_balance(
account_address=GENESIS_ACCOUNT.public_key_hex,
block_hash=latest_block_hash)
assert genesis_balance == genesis_balance_after_transfer
def test_refund_after_session_code_error(payment_node_network):
network = payment_node_network
node0: DockerNode = network.docker_nodes[0]
blocks = parse_show_blocks(node0.d_client.show_blocks(1000))
genesis_init_balance = node0.client.get_balance(
account_address=GENESIS_ACCOUNT.public_key_hex,
block_hash=blocks[0].summary.block_hash,
)
deploy_hash = node0.p_client.deploy(
from_address=GENESIS_ACCOUNT.public_key_hex,
session_contract=Contract.ARGS_U512,
payment_contract=Contract.STANDARD_PAYMENT,
public_key=GENESIS_ACCOUNT.public_key_path,
private_key=GENESIS_ACCOUNT.private_key_path,
gas_price=1,
session_args=ABI.args([ABI.u512("number", 100)]),
payment_args=ABI.args([ABI.u32("amount", 10**6)])
# 100 is a revert code.
)
result = node0.p_client.client.wait_for_deploy_processed(
deploy_hash, on_error_raise=False)
last_processing_result = result.processing_results[0]
block_hash = last_processing_result.block_info.summary.block_hash.hex()
cost = last_processing_result.cost
assert cost == MAX_PAYMENT_COST / CONV_RATE
motes = cost * CONV_RATE
later_balance = node0.client.get_balance(
account_address=GENESIS_ACCOUNT.public_key_hex, block_hash=block_hash)
expected_sum = later_balance + motes
assert genesis_init_balance == expected_sum
def transfer_command(casperlabs_client, args):
_set_session(args, "transfer_to_account_u512.wasm")
if not args.session_args:
target_account_bytes = base64.b64decode(args.target_account)
if len(target_account_bytes) != 32:
target_account_bytes = bytes.fromhex(args.target_account)
if len(target_account_bytes) != 32:
raise Exception(
"--target_account must be 32 bytes base64 or base16 encoded"
)
args.session_args = ABI.args_to_json(
ABI.args([
ABI.account("account", target_account_bytes),
ABI.u512("amount", args.amount),
]))
return deploy_command(casperlabs_client, args)
def make_transfers(client, account, target_account, amount, n):
"""
Makes n transfers from account to account_target,
n must be greater than 1.
First n-1 deploys depends on a deploy that is sent to the node as the last one.
This is in order to ensure that node doesn't put part of the set of deploys on a block
before receiving all of them.
Returns tuple (deploy_hash, [deploy_hashes]), where deploy_hash is the special
deploy that all other deploys depend on.
"""
if not n > 1:
raise Exception("n must be > 1")
deploy = client.make_deploy(
from_addr=account.public_key_hex,
session=bundled_contract("transfer_to_account_u512.wasm"),
session_args=ABI.args([
ABI.account("account",
bytes.fromhex(target_account.public_key_hex)),
ABI.u512("amount", amount),
]),
payment_amount=10000000,
)
deploy = client.sign_deploy(deploy, account.public_key_hex,
account.private_key_path)
deploy_hash = deploy.deploy_hash.hex()
deploy_hashes = [
client.transfer(
private_key=account.private_key_path,
from_addr=account.public_key_hex,
target_account_hex=target_account.public_key_hex,
payment_amount=10000000,
amount=1,
dependencies=[deploy_hash],
) for _ in range(n - 1)
]
client.send_deploy(deploy)
return deploy_hash, deploy_hashes
def test_error_in_payment_contract(payment_node_network):
network = payment_node_network
node0: DockerNode = network.docker_nodes[0]
node0.use_docker_client()
blocks = parse_show_blocks(node0.d_client.show_blocks(1000))
genesis_hash = blocks[0].summary.block_hash
assert len(
blocks) == 1 # There should be only one block - the genesis block
genesis_balance = node0.client.get_balance(
account_address=GENESIS_ACCOUNT.public_key_hex,
block_hash=genesis_hash)
assert genesis_balance == INITIAL_MOTES_AMOUNT
from_account = Account("genesis")
to_account = Account(1)
session_args = ABI.args([
ABI.account("account", to_account.public_key_hex),
ABI.u64("amount", 10**7)
])
payment_args = ABI.args([ABI.u512("amount", 10**6)])
node0.p_client.deploy(
from_address=from_account.public_key_hex,
session_contract=Contract.TRANSFER_TO_ACCOUNT,
payment_contract=Contract.DIRECT_REVERT,
public_key=from_account.public_key_path,
private_key=from_account.private_key_path,
gas_price=1,
session_args=session_args,
payment_args=payment_args,
)
genesis_balance_after_transfer = node0.client.get_balance(
account_address=GENESIS_ACCOUNT.public_key_hex,
block_hash=parse_show_blocks(
node0.d_client.show_blocks(1000))[0].summary.block_hash,
)
assert genesis_balance == genesis_balance_after_transfer
def transfer_to_account(
self,
to_account_id: int,
amount: int,
from_account_id: Union[str, int] = "genesis",
session_contract: str = Contract.TRANSFER_TO_ACCOUNT,
payment_contract: str = Contract.STANDARD_PAYMENT,
payment_args: bytes = MAX_PAYMENT_ABI,
gas_price: int = 1,
is_deploy_error_check: bool = True,
) -> str:
"""
Performs a transfer using the from account if given (or genesis if not)
:param to_account_id: 1-20 index of test account for transfer into
:param amount: amount of motes to transfer (mote = smallest unit of token)
:param from_account_id: default 'genesis' account, but previously funded account_id is also valid.
:param session_contract: session contract to execute.
:param payment_contract: Payment contract to execute.
:param payment_args: Payment Amount ABI
:param gas_price: Gas price
:param is_deploy_error_check: Check that amount transfer is success.
:returns block_hash in hex str
"""
logging.info(f"=== Transferring {amount} to {to_account_id}")
assert (
is_valid_account(to_account_id) and to_account_id != "genesis"
), "Can transfer only to non-genesis accounts in test framework (1-20)."
assert is_valid_account(
from_account_id
), "Must transfer from a valid account_id: 1-20 or 'genesis'"
from_account = Account(from_account_id)
to_account = Account(to_account_id)
session_args = ABI.args(
[
ABI.account("account", to_account.public_key_binary),
ABI.u512("amount", amount),
]
)
deploy_hash = self.p_client.deploy(
from_address=from_account.public_key_hex,
session_contract=session_contract,
payment_contract=payment_contract,
public_key=from_account.public_key_path,
private_key=from_account.private_key_path,
gas_price=gas_price,
session_args=session_args,
payment_args=payment_args,
)
client = self.p_client.client
result = client.wait_for_deploy_processed(
deploy_hash, on_error_raise=is_deploy_error_check
)
last_processing_result = result.processing_results[0]
block_hash = last_processing_result.block_info.summary.block_hash.hex()
if is_deploy_error_check and last_processing_result.is_error:
raise Exception(
f"transfer_to_account: {last_processing_result.error_message}"
)
return block_hash