def run_test(self):
block_number = 2000
# Setup balance for each node
client = RpcClient(self.nodes[0])
for i in range(self.num_nodes):
pub_key = self.nodes[i].key
addr = self.nodes[i].addr
self.log.info("%d has addr=%s pubkey=%s", i, encode_hex(addr),
pub_key)
tx = client.new_tx(
value=int(default_config["TOTAL_COIN"] / self.num_nodes) -
21000,
receiver=encode_hex(addr),
nonce=i)
client.send_tx(tx)
for i in range(1, block_number):
chosen_peer = random.randint(0, self.num_nodes - 1)
self.log.debug("%d try to generate", chosen_peer)
block_hash = RpcClient(
self.nodes[chosen_peer]).generate_block(1000)
self.log.info("%d generate block %s", chosen_peer, block_hash)
time.sleep(random.random() / 15)
wait_for_block_count(self.nodes[0], block_number)
sync_blocks(self.nodes, timeout=30)
hasha = self.nodes[0].getbestblockhash()
block_a = client.block_by_hash(hasha)
self.log.info("Final height = %s", block_a['height'])
self.log.info("Pass")
def __init__(self, genesis: str, remote=False):
super().__init__()
# Track number of messages of each type received and the most recent
# message of each type
self.message_count = defaultdict(int)
self.protocol_message_count = defaultdict(int)
self.last_message = {}
self.last_protocol_message = {}
# Default protocol version
self.protocol = b'cfx'
self.protocol_version = 3
# Store genesis_hash
self.genesis = decode_hex(genesis)
self.best_block_hash = self.genesis
self.blocks = {self.genesis: self.genesis}
self.peer_pubkey = None
self.priv_key, self.pub_key = ec_random_keys()
x, y = self.pub_key
self.key = "0x" + utils.encode_hex(bytes(
int_to_32bytearray(x))) + utils.encode_hex(
bytes(int_to_32bytearray(y)))
self.had_status = False
self.on_packet_func = {}
self.remote = remote
def get_balance(self, contract, token_address):
tx = contract.functions.balanceOf(
Web3.toChecksumAddress(
encode_hex(token_address))).buildTransaction(self.tx_conf)
result = self.client.call(tx["to"], tx["data"])
balance = bytes_to_int(decode_hex(result))
self.log.debug("address=%s, balance=%s", encode_hex(token_address),
balance)
return balance
def get_balance(self, contract, token_address, nonce):
tx = contract.functions.balanceOf(Web3.toChecksumAddress(encode_hex(token_address))).buildTransaction(self.tx_conf)
tx["value"] = int_to_hex(tx['value'])
tx["hash"] = "0x"+"0"*64
tx["nonce"] = int_to_hex(nonce)
tx["v"] = "0x0"
tx["r"] = "0x0"
tx["s"] = "0x0"
result = self.nodes[0].cfx_call(tx)
balance = bytes_to_int(decode_hex(result))
self.log.debug("address=%s, balance=%s", encode_hex(token_address), balance)
return balance
def run_test(self):
block_number = 2000
# Setup balance for each node
client = RpcClient(self.nodes[0])
for i in self.all_nodes:
pub_key = self.nodes[i].key
addr = self.nodes[i].addr
self.log.info("%d has addr=%s pubkey=%s", i, encode_hex(addr), pub_key)
tx = client.new_tx(value=int(default_config["TOTAL_COIN"]/self.num_nodes) - 21000, receiver=encode_hex(addr), nonce=i)
client.send_tx(tx)
for i in range(1, block_number):
chosen_peer = random.randint(0, self.num_nodes - 1)
self.maybe_restart_node(chosen_peer, self.stop_probability, self.clean_probability)
self.log.debug("%d try to generate", chosen_peer)
block_hash = RpcClient(self.nodes[chosen_peer]).generate_block(random.randint(10, 100))
self.log.info("%d generate block %s", chosen_peer, block_hash)
time.sleep(random.random()/15)
self.log.info("sync blocks")
for i in self.full_nodes:
self.nodes[i].expireblockgc(1000000)
sync_blocks(self.nodes, timeout=120, sync_count=False)
self.log.info("block count:%d", self.nodes[0].getblockcount())
hasha = self.nodes[0].best_block_hash()
block_a = client.block_by_hash(hasha)
self.log.info("Final height = %s", block_a['height'])
self.log.info("Pass")
def run_test(self):
block_number = 10
for i in range(1, block_number):
chosen_peer = random.randint(0, self.num_nodes - 1)
block_hash = self.nodes[chosen_peer].generate(1, 0)
self.log.info("generate block %s", block_hash)
wait_for_block_count(self.nodes[0], block_number, timeout=30)
sync_blocks(self.nodes, timeout=30)
self.log.info("generated blocks received by all")
self.stop_node(0, kill=True)
self.log.info("node 0 stopped")
block_hash = self.nodes[-1].generate(1, 0)
self.log.info("generate block %s", block_hash)
wait_for_block_count(self.nodes[1], block_number + 1)
sync_blocks(self.nodes[1:], timeout=30)
self.log.info("blocks sync success among running nodes")
self.start_node(0)
sync_blocks(self.nodes, timeout=30)
self.log.info("Pass 1")
for i in range(1, self.num_nodes):
self.stop_node(i)
self.nodes[0].add_p2p_connection(P2PInterface())
network_thread_start()
self.nodes[0].p2p.wait_for_status()
gas_price = 1
value = 1
receiver_sk, _ = ec_random_keys()
sender_key = default_config["GENESIS_PRI_KEY"]
tx = create_transaction(pri_key=sender_key, receiver=privtoaddr(receiver_sk), value=value, nonce=0,
gas_price=gas_price)
self.nodes[0].p2p.send_protocol_msg(Transactions(transactions=[tx]))
self.log.debug("New tx %s: %s send value %d to %s", encode_hex(tx.hash), eth_utils.encode_hex(privtoaddr(sender_key))[-4:],
value, eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:])
def check_packed():
client = RpcClient(self.nodes[0])
client.generate_block(1)
return checktx(self.nodes[0], tx.hash_hex())
wait_until(lambda: check_packed())
sender_addr = eth_utils.encode_hex(privtoaddr(sender_key))
receiver_addr = eth_utils.encode_hex(privtoaddr(receiver_sk))
sender_balance = default_config["TOTAL_COIN"] - value - gas_price * 21000
# Generate 2 * CACHE_INDEX_STRIDE to start evicting anticone cache
for _ in range(2000):
self.nodes[0].generate(1, 0)
assert_equal(parse_as_int(self.nodes[0].cfx_getBalance(sender_addr)), sender_balance)
assert_equal(parse_as_int(self.nodes[0].cfx_getBalance(receiver_addr)), value)
time.sleep(1)
self.stop_node(0)
self.start_node(0)
self.log.info("Wait for node 0 to recover from crash")
wait_until(lambda: parse_as_int(self.nodes[0].cfx_getBalance(sender_addr)) == sender_balance)
wait_until(lambda: parse_as_int(self.nodes[0].cfx_getBalance(receiver_addr)) == value)
self.log.info("Pass 2")
def run_test(self):
client = RpcClient(self.nodes[0])
genesis_address = "0x" + encode_hex(
priv_to_addr(default_config['GENESIS_PRI_KEY']))
genesis_balance = default_config["TOTAL_COIN"]
client.generate_empty_blocks(ERA_EPOCH_COUNT * 10)
print(client.epoch_number("latest_checkpoint"))
assert client.epoch_number("latest_checkpoint") > 0
# Just assert we can still get the balance
assert_equal(client.get_balance(genesis_address, client.EPOCH_NUM(1)),
genesis_balance)
import rlp
import sys, os
from eth_utils import decode_hex
sys.path.insert(1, os.path.join(sys.path[0], '..'))
from conflux.utils import ec_random_keys, encode_hex, priv_to_pub
NUM_NODES = 2
for _ in range(NUM_NODES):
pri_key_raw, _ = ec_random_keys()
pri_key = encode_hex(pri_key_raw)
pub_key = encode_hex(priv_to_pub(pri_key_raw))
# print(f""" {host}:
# index: {i}
print(f"""
net_pri_key: \"{pri_key}\"
net_pub_key: \"{pub_key}\"""")
# i += 1
def run_test(self):
genesis_key = default_config["GENESIS_PRI_KEY"]
balance_map = {genesis_key: default_config["TOTAL_COIN"]}
self.log.info("Initial State: (sk:%d, addr:%s, balance:%d)",
bytes_to_int(genesis_key),
eth_utils.encode_hex(priv_to_addr(genesis_key)),
balance_map[genesis_key])
nonce_map = {genesis_key: 0}
# '''Check if transaction from uncommitted new address can be accepted'''
# tx_n = 5
# receiver_sk = genesis_key
gas_price = 1
# for i in range(tx_n):
# sender_key = receiver_sk
# value = int((balance_map[sender_key] - ((tx_n - i) * 21000 * gas_price)) * random.random())
# nonce = nonce_map[sender_key]
# receiver_sk, _ = ec_random_keys()
# nonce_map[receiver_sk] = 0
# balance_map[receiver_sk] = value
# tx = create_transaction(pri_key=sender_key, receiver=privtoaddr(receiver_sk), value=value, nonce=nonce,
# gas_price=gas_price)
# r = random.randint(0, self.num_nodes - 1)
# self.nodes[r].p2p.send_protocol_msg(Transactions(transactions=[tx]))
# nonce_map[sender_key] = nonce + 1
# balance_map[sender_key] -= value + gas_price * 21000
# self.log.debug("New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d", encode_hex(tx.hash), eth_utils.encode_hex(privtoaddr(sender_key))[-4:],
# value, eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:], balance_map[sender_key], balance_map[receiver_sk])
# self.log.debug("Send Transaction %s to node %d", encode_hex(tx.hash), r)
# time.sleep(random.random() / 10 * self.delay_factor)
block_gen_thread = BlockGenThread(self.nodes,
self.log,
interval_base=self.delay_factor)
block_gen_thread.start()
# for k in balance_map:
# self.log.info("Check account sk:%s addr:%s", bytes_to_int(k), eth_utils.encode_hex(privtoaddr(k)))
# wait_until(lambda: self.check_account(k, balance_map), timeout=60*self.delay_factor)
# self.log.info("Pass 1")
# self.register_test("general_1.json")
'''Test Random Transactions'''
all_txs = []
tx_n = 1000
account_n = 10
# Initialize new accounts
new_keys = set()
for _ in range(account_n):
value = int(balance_map[genesis_key] * 0.5)
receiver_sk, _ = ec_random_keys()
new_keys.add(receiver_sk)
tx = create_transaction(pri_key=genesis_key,
receiver=priv_to_addr(receiver_sk),
value=value,
nonce=nonce_map[genesis_key],
gas_price=gas_price)
self.nodes[0].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
balance_map[receiver_sk] = value
nonce_map[genesis_key] += 1
balance_map[genesis_key] -= value + gas_price * 21000
wait_for_account_stable()
for key in new_keys:
nonce_map[key] = wait_for_initial_nonce_for_privkey(
self.nodes[0], key)
self.log.info(
"start to generate %d transactions with about %d seconds", tx_n,
tx_n / 10 / 2 * self.delay_factor)
for i in range(tx_n):
sender_key = random.choice(list(balance_map))
nonce = nonce_map[sender_key]
value = 1
receiver_sk = random.choice(list(balance_map))
balance_map[receiver_sk] += value
# not enough transaction fee (gas_price * gas_limit) should not happen for now
assert balance_map[sender_key] >= value + gas_price * 21000
tx = create_transaction(pri_key=sender_key,
receiver=priv_to_addr(receiver_sk),
value=value,
nonce=nonce,
gas_price=gas_price)
r = random.randint(0, self.num_nodes - 1)
self.nodes[r].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
all_txs.append(tx)
nonce_map[sender_key] = nonce + 1
balance_map[sender_key] -= value + gas_price * 21000
self.log.debug(
"New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d nonce:%d",
encode_hex(tx.hash),
eth_utils.encode_hex(priv_to_addr(sender_key))[-4:], value,
eth_utils.encode_hex(priv_to_addr(receiver_sk))[-4:],
balance_map[sender_key], balance_map[receiver_sk], nonce)
self.log.debug("Send Transaction %s to node %d",
encode_hex(tx.hash), r)
time.sleep(random.random() / 10 * self.delay_factor)
for k in balance_map:
self.log.info("Account %s with balance:%s", bytes_to_int(k),
balance_map[k])
for tx in all_txs:
self.log.debug("Wait for tx to confirm %s", tx.hash_hex())
for i in range(3):
try:
retry = True
while retry:
try:
wait_until(
lambda: checktx(self.nodes[0], tx.hash_hex()),
timeout=60 * self.delay_factor)
retry = False
except CannotSendRequest:
time.sleep(0.01)
break
except AssertionError as _:
self.nodes[0].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
if i == 2:
raise AssertionError(
"Tx {} not confirmed after 30 seconds".format(
tx.hash_hex()))
for k in balance_map:
self.log.info("Check account sk:%s addr:%s", bytes_to_int(k),
eth_utils.encode_hex(priv_to_addr(k)))
wait_until(lambda: self.check_account(k, balance_map),
timeout=60 * self.delay_factor)
block_gen_thread.stop()
block_gen_thread.join()
sync_blocks(self.nodes, timeout=60 * self.delay_factor)
self.log.info("Pass")
self.register_test("general_2.json")
def run_test(self):
sponsor_whitelist_contract_addr = Web3.toChecksumAddress(
"0888000000000000000000000000000000000001")
collateral_per_storage_key = COLLATERAL_UNIT_IN_DRIP * 64
upper_bound = 5 * 10**7
file_dir = os.path.dirname(os.path.realpath(__file__))
control_contract_file_path = os.path.join(
file_dir, "..", "internal_contract", "metadata",
"SponsorWhitelistControl.json")
control_contract_dict = json.loads(
open(control_contract_file_path, "r").read())
control_contract = get_contract_instance(
contract_dict=control_contract_dict)
test_contract = get_contract_instance(
abi_file=os.path.join(
file_dir, "contracts/commission_privilege_test_abi.json"),
bytecode_file=os.path.join(
file_dir, "contracts/commission_privilege_test_bytecode.dat"),
)
start_p2p_connection(self.nodes)
self.log.info("Initializing contract")
genesis_key = self.genesis_priv_key
genesis_addr = encode_hex(self.genesis_addr)
self.log.info("genesis_addr={}".format(genesis_addr))
nonce = 0
gas_price = 1
gas = CONTRACT_DEFAULT_GAS
block_gen_thread = BlockGenThread(self.nodes, self.log)
block_gen_thread.start()
self.tx_conf = {
"from": Web3.toChecksumAddress(genesis_addr),
"nonce": int_to_hex(nonce),
"gas": int_to_hex(gas),
"gasPrice": int_to_hex(gas_price),
"chainId": 0
}
# Setup balance for node 0
node = self.nodes[0]
client = RpcClient(node)
(addr1, priv_key1) = client.rand_account()
self.log.info("addr1={}".format(addr1))
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=10**6,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr1)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr1), 10**6)
# setup contract
transaction = self.call_contract_function(
contract=test_contract,
name="constructor",
args=[],
sender_key=self.genesis_priv_key,
storage_limit=20000)
contract_addr = self.wait_for_tx([transaction],
True)[0]['contractCreated']
self.log.info("contract_addr={}".format(contract_addr))
assert_equal(client.get_balance(contract_addr), 0)
# sponsor the contract succeed
b0 = client.get_balance(genesis_addr)
self.call_contract_function(
contract=control_contract,
name="setSponsorForGas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound],
value=10**18,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18)
assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr)
assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound)
assert_equal(client.get_balance(genesis_addr),
b0 - 10**18 - charged_of_huge_gas(gas))
# set privilege for addr1
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
transaction = self.call_contract_function(
contract=test_contract,
name="add",
args=[Web3.toChecksumAddress(addr1)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True,
storage_limit=64)
assert_equal(
client.get_balance(genesis_addr),
b0 - charged_of_huge_gas(gas) - collateral_per_storage_key)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + collateral_per_storage_key)
assert_equal(
self.wait_for_tx([transaction], True)[0]['gasCoveredBySponsor'],
False)
# addr1 call contract with privilege without enough cfx for gas fee
sb = client.get_sponsor_balance_for_gas(contract_addr)
b1 = client.get_balance(addr1)
transaction = self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_balance(addr1), b1)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sb - charged_of_huge_gas(gas))
assert_equal(
self.wait_for_tx([transaction], True)[0]['gasCoveredBySponsor'],
True)
# sponsor collateral for the contract succeed
b0 = client.get_balance(genesis_addr)
self.call_contract_function(
contract=control_contract,
name="setSponsorForCollateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=10**18, # 1 CFX = 1KB
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
10**18)
assert_equal(client.get_sponsor_for_collateral(contract_addr),
genesis_addr)
assert_equal(client.get_balance(genesis_addr),
b0 - 10**18 - charged_of_huge_gas(gas))
# addr1 call contract with privilege without enough cfx for storage
sb = client.get_sponsor_balance_for_gas(contract_addr)
b1 = client.get_balance(addr1)
transaction = self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True,
storage_limit=1024)
assert_equal(client.get_balance(addr1), b1)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sb - charged_of_huge_gas(gas))
assert_equal(
self.wait_for_tx([transaction],
True)[0]['storageCoveredBySponsor'], True)
# addr1 call with larger storage limit, should not packed
transaction = self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
storage_limit=1025)
for _ in range(10):
client.generate_block()
tx_info = self.nodes[0].txpool_txWithPoolInfo(transaction.hash_hex())
assert_equal(int(tx_info['local_nonce'], 16), 2)
assert_equal(tx_info['local_balance_enough'], False)
assert_equal(tx_info['packed'], False)
# send 1025 * 10 ** 18 // 1024 CFX to addr1
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=1025 * 10**18 // 1024,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr1)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr1), 10**6 + 1025 * 10**18 // 1024)
for _ in range(10):
client.generate_block()
tx_info = self.nodes[0].txpool_txWithPoolInfo(transaction.hash_hex())
# Now addr1 pays for storage collateral by itself.
assert_equal(
self.wait_for_tx([transaction],
True)[0]['storageCoveredBySponsor'], False)
assert_equal(int(tx_info['local_nonce'], 16), 3)
assert_equal(tx_info['packed'], True)
self.log.info("Pass")
def read_ack(self, remote_node_id: bytes):
assert len(remote_node_id) == 64, "invalid node id length {}".format(len(remote_node_id))
self.peer.peer_key = utils.encode_hex(remote_node_id)
self.state = "StartSession"
def on_protocol_packet(self, protocol, payload):
"""Receive message and dispatch message to appropriate callback.
We keep a count of how many of each message type has been received
and the most recent message of each type."""
with mininode_lock:
try:
assert(protocol == self.protocol) # Possible to be false?
packet_type, payload = self.read_protocol_msg(payload)
self.protocol_message_count[packet_type] += 1
msg = None
msg_class = get_msg_class(packet_type)
logger.debug("%s %s", packet_type, rlp.decode(payload))
if msg_class is not None:
msg = rlp.decode(payload, msg_class)
if packet_type == STATUS:
self._log_message("receive", "STATUS, protocol_version:{}, terminal_hashes:{}"
.format(msg.protocol_version,
[utils.encode_hex(i) for i in msg.terminal_block_hashes]))
self.had_status = True
elif packet_type == GET_BLOCK_HEADERS:
self._log_message("receive", "GET_BLOCK_HEADERS of {}".format(msg.hashes))
elif packet_type == GET_BLOCK_HEADER_CHAIN:
self._log_message("receive", "GET_BLOCK_HEADER_CHAIN of {} {}".format(msg.hash, msg.max_blocks))
elif packet_type == GET_BLOCK_BODIES:
hashes = msg.hashes
self._log_message("receive", "GET_BLOCK_BODIES of {} blocks".format(len(hashes)))
elif packet_type == GET_BLOCK_HEADERS_RESPONSE:
self._log_message("receive", "BLOCK_HEADERS of {} headers".format(len(msg.headers)))
elif packet_type == GET_BLOCK_BODIES_RESPONSE:
self._log_message("receive", "BLOCK_BODIES of {} blocks".format(len(msg)))
elif packet_type == NEW_BLOCK:
self._log_message("receive", "NEW_BLOCK, hash:{}".format(msg.block.block_header.hash))
elif packet_type == GET_BLOCK_HASHES:
self._log_message("receive", "GET_BLOCK_HASHES, hash:{}, max_blocks:{}"
.format(msg.hash, msg.max_blocks))
elif packet_type == GET_BLOCK_HASHES_RESPONSE:
self._log_message("receive", "BLOCK_HASHES, {} hashes".format(len(msg.hashes)))
elif packet_type == GET_TERMINAL_BLOCK_HASHES:
self._log_message("receive", "GET_TERMINAL_BLOCK_HASHES")
elif packet_type == TRANSACTIONS:
self._log_message("receive", "TRANSACTIONS, {} transactions".format(len(msg.transactions)))
elif packet_type == GET_TERMINAL_BLOCK_HASHES_RESPONSE:
self._log_message("receive", "TERMINAL_BLOCK_HASHES, {} hashes".format(len(msg.hashes)))
elif packet_type == NEW_BLOCK_HASHES:
self._log_message("receive", "NEW_BLOCK_HASHES, {} hashes".format(len(msg.block_hashes)))
elif packet_type == GET_BLOCKS_RESPONSE:
self._log_message("receive", "BLOCKS, {} blocks".format(len(msg.blocks)))
elif packet_type == GET_CMPCT_BLOCKS_RESPONSE:
self._log_message("receive", "GET_CMPCT_BLOCKS_RESPONSE, {} blocks".format(len(msg.blocks)))
elif packet_type == GET_BLOCK_TXN_RESPONSE:
self._log_message("receive", "GET_BLOCK_TXN_RESPONSE, block:{}".format(len(msg.block_hash)))
elif packet_type == GET_BLOCKS:
self._log_message("receive", "GET_BLOCKS, {} hashes".format(len(msg.hashes)))
self.on_get_blocks(msg)
elif packet_type == GET_CMPCT_BLOCKS:
self._log_message("receive", "GET_CMPCT_BLOCKS, {} hashes".format(len(msg.hashes)))
self.on_get_compact_blocks(msg)
elif packet_type == GET_BLOCK_TXN:
self._log_message("receive", "GET_BLOCK_TXN, hash={}".format(len(msg.block_hash)))
self.on_get_blocktxn(msg)
elif packet_type == GET_BLOCK_HASHES_BY_EPOCH:
self._log_message("receive", "GET_BLOCK_HASHES_BY_EPOCH, epochs: {}".format(msg.epochs))
self.on_get_block_hashes_by_epoch(msg)
else:
self._log_message("receive", "Unknown packet {}".format(packet_type))
return
if packet_type in self.on_packet_func and msg is not None:
self.on_packet_func[packet_type](self, msg)
except:
raise
def on_block_headers(node, msg):
self.log.info("Received %d headers", len(msg.headers))
for header in msg.headers:
self.log.info("Block header: %s", encode_hex(header.hash))
def run_test(self):
# Prevent easysolc from configuring the root logger to print to stderr
self.log.propagate = False
solc = Solc()
file_dir = os.path.dirname(os.path.realpath(__file__))
staking_contract = solc.get_contract_instance(
abi_file=os.path.join(
file_dir, "contracts/storage_interest_staking_abi.json"),
bytecode_file=os.path.join(
file_dir, "contracts/storage_interest_staking_bytecode.dat"),
)
commission_privilege_contract = solc.get_contract_instance(
abi_file=os.path.join(
file_dir, "contracts/commission_privilege_control_abi.json"),
bytecode_file=os.path.join(
file_dir,
"contracts/commission_privilege_control_bytecode.dat"),
)
start_p2p_connection(self.nodes)
self.log.info("Initializing contract")
genesis_key = self.genesis_priv_key
genesis_addr = self.genesis_addr
self.log.info("genesis_addr={}".format(encode_hex_0x(genesis_addr)))
nonce = 0
gas_price = 1
gas = 50000000
block_gen_thread = BlockGenThread(self.nodes, self.log)
block_gen_thread.start()
self.tx_conf = {
"from": Web3.toChecksumAddress(encode_hex_0x(genesis_addr)),
"nonce": int_to_hex(nonce),
"gas": int_to_hex(gas),
"gasPrice": int_to_hex(gas_price),
"chainId": 0
}
# Setup balance for node 0
node = self.nodes[0]
client = RpcClient(node)
(addr, priv_key) = client.rand_account()
self.log.info("addr=%s priv_key=%s", addr, priv_key)
tx = client.new_tx(value=5 * 10**18,
receiver=addr,
nonce=self.get_nonce(genesis_addr))
client.send_tx(tx, True)
assert_equal(node.cfx_getBalance(addr), hex(5000000000000000000))
assert_equal(node.cfx_getBankBalance(addr), hex(0))
self.tx_conf["to"] = Web3.toChecksumAddress(
"443c409373ffd5c0bec1dddb7bec830856757b65")
# deposit 2 * 10**18 / 16
tx_data = decode_hex(
staking_contract.functions.deposit(
2 * 10**18 // 16).buildTransaction(self.tx_conf)["data"])
tx = client.new_tx(value=0,
receiver=self.tx_conf["to"],
nonce=self.get_nonce(genesis_addr),
gas=gas,
data=tx_data)
client.send_tx(tx, True)
assert_equal(node.cfx_getBankBalance(encode_hex(genesis_addr)),
hex(2 * 10**18 // 16))
# setup contract
transaction = self.call_contract_function(
contract=commission_privilege_contract,
name="constructor",
args=[],
sender_key=self.genesis_priv_key)
contract_addr = self.wait_for_tx([transaction],
True)[0]['contractCreated']
self.log.info("contract_addr={}".format(contract_addr))
assert_equal(node.cfx_getBalance(contract_addr), hex(0))
# setup balance
transaction = self.call_contract_function(
contract=commission_privilege_contract,
name="set",
args=[],
sender_key=genesis_key,
contract_addr=contract_addr,
value=10**18,
wait=True,
check_status=True)
assert_equal(node.cfx_getBalance(contract_addr), hex(10**18))
# call contract with privilege
geneis_balance = node.cfx_getBalance(encode_hex(genesis_addr))
transaction = self.call_contract_function(
contract=commission_privilege_contract,
name="foo",
args=[],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(node.cfx_getBalance(contract_addr), hex(10**18 - gas))
assert_equal(node.cfx_getBalance(encode_hex(genesis_addr)),
geneis_balance)
# call contract without privilege and remove privilege of genesis
transaction = self.call_contract_function(
contract=commission_privilege_contract,
name="remove",
args=[],
sender_key=priv_key,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(node.cfx_getBalance(contract_addr), hex(10**18 - gas))
assert_equal(node.cfx_getBalance(addr), hex(5 * 10**18 - gas))
# call contract after removing privilege
geneis_balance = int(node.cfx_getBalance(encode_hex(genesis_addr)), 16)
transaction = self.call_contract_function(
contract=commission_privilege_contract,
name="foo",
args=[],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(node.cfx_getBalance(contract_addr), hex(10**18 - gas))
self.log.info("Pass")
def run_test(self):
# Start mininode connection
self.node = self.nodes[0]
start_p2p_connection([self.node])
block_gen_thread = BlockGenThread([self.node],
self.log,
num_txs=100,
interval_fixed=0.2)
block_gen_thread.start()
tx_n = 100000
generate = False
if generate:
f = open("encoded_tx", "wb")
'''Test Random Transactions'''
genesis_key = default_config["GENESIS_PRI_KEY"]
balance_map = {genesis_key: default_config["TOTAL_COIN"]}
nonce_map = {genesis_key: 0}
all_txs = []
gas_price = 1
self.log.info("start to generate %d transactions", tx_n)
for i in range(tx_n):
if i % 1000 == 0:
self.log.debug("generated %d tx", i)
sender_key = random.choice(list(balance_map))
nonce = nonce_map[sender_key]
if random.random(
) < 0.1 and balance_map[sender_key] > 21000 * 4 * tx_n:
value = int(balance_map[sender_key] * 0.5)
receiver_sk, _ = ec_random_keys()
nonce_map[receiver_sk] = 0
balance_map[receiver_sk] = value
else:
value = 1
receiver_sk = random.choice(list(balance_map))
balance_map[receiver_sk] += value
# not enough transaction fee (gas_price * gas_limit) should not happen for now
assert balance_map[sender_key] >= value + gas_price * 21000
tx = create_transaction(pri_key=sender_key,
receiver=privtoaddr(receiver_sk),
value=value,
nonce=nonce,
gas_price=gas_price)
self.log.debug(
"%s send %d to %s nonce=%d balance: sender=%s, receiver=%s",
encode_hex(privtoaddr(sender_key)), value,
encode_hex(privtoaddr(receiver_sk)), nonce,
balance_map[sender_key], balance_map[receiver_sk])
all_txs.append(tx)
nonce_map[sender_key] = nonce + 1
balance_map[sender_key] -= value + gas_price * 21000
encoded_txs = []
batch_tx = []
i = 0
for tx in all_txs:
batch_tx.append(tx)
i += 1
if i % 1000 == 0:
encoded = rlp.encode(Transactions(transactions=batch_tx))
encoded_txs.append(encoded)
batch_tx = []
pickle.dump(encoded_txs, f)
pickle.dump(balance_map, f)
else:
f = open("encoded_tx", "rb")
encoded_txs = pickle.load(f)
balance_map = pickle.load(f)
f.close()
start_time = datetime.datetime.now()
for encoded in encoded_txs:
self.node.p2p.send_protocol_packet(
int_to_bytes(TRANSACTIONS) + encoded)
for k in balance_map:
wait_until(lambda: self.check_account(k, balance_map))
end_time = datetime.datetime.now()
time_used = (end_time - start_time).total_seconds()
block_gen_thread.stop()
block_gen_thread.join()
self.log.info("Time used: %f seconds", time_used)
self.log.info("Tx per second: %f", tx_n / time_used)
def run_test(self):
sponsor_whitelist_contract_addr = Web3.toChecksumAddress(
"8ad036480160591706c831f0da19d1a424e39469")
bytes_per_key = 64
collateral_per_storage_key = 10**18 // 16
upper_bound = 5 * 10**7
file_dir = os.path.dirname(os.path.realpath(__file__))
control_contract_file_path = os.path.dirname(
os.path.realpath(__file__)).split("/")
control_contract_file_path.pop(-1)
control_contract_file_path.extend(
["internal_contract", "metadata", "SponsorWhitelistControl.json"])
control_contract_file_path = "/".join(control_contract_file_path)
control_contract_dict = json.loads(
open(os.path.join(control_contract_file_path), "r").read())
control_contract = get_contract_instance(
contract_dict=control_contract_dict)
test_contract = get_contract_instance(
abi_file=os.path.join(
file_dir, "contracts/commission_privilege_test_abi.json"),
bytecode_file=os.path.join(
file_dir, "contracts/commission_privilege_test_bytecode.dat"),
)
start_p2p_connection(self.nodes)
self.log.info("Initializing contract")
genesis_key = self.genesis_priv_key
genesis_addr = encode_hex(self.genesis_addr)
self.log.info("genesis_addr={}".format(genesis_addr))
nonce = 0
gas_price = 1
gas = 50000000
block_gen_thread = BlockGenThread(self.nodes, self.log)
block_gen_thread.start()
self.tx_conf = {
"from": Web3.toChecksumAddress(genesis_addr),
"nonce": int_to_hex(nonce),
"gas": int_to_hex(gas),
"gasPrice": int_to_hex(gas_price),
"chainId": 0
}
# Setup balance for node 0
node = self.nodes[0]
client = RpcClient(node)
(addr1, priv_key1) = client.rand_account()
(addr2, priv_key2) = client.rand_account()
(addr3, priv_key3) = client.rand_account()
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=10**18,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr1)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr1), 10**18)
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=10**18,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr2)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr2), 10**18)
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=3 * 10**18,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr3)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr3), 3 * 10**18)
# setup contract
transaction = self.call_contract_function(
contract=test_contract,
name="constructor",
args=[],
sender_key=self.genesis_priv_key)
contract_addr = self.wait_for_tx([transaction],
True)[0]['contractCreated']
self.log.info("contract_addr={}".format(contract_addr))
assert_equal(client.get_balance(contract_addr), 0)
# sponsor the contract failed due to sponsor_balance < 1000 * upper_bound
b0 = client.get_balance(genesis_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound],
value=upper_bound * 1000 - 1,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 0)
assert_equal(client.get_sponsor_for_gas(contract_addr),
"0x0000000000000000000000000000000000000000")
assert_equal(client.get_sponsor_gas_bound(contract_addr), 0)
assert_equal(client.get_balance(genesis_addr), b0 - gas)
# sponsor the contract succeed
b0 = client.get_balance(genesis_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound],
value=10**18,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18)
assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr)
assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound)
assert_equal(client.get_balance(genesis_addr),
b0 - 10**18 - gas + 12500000)
# set privilege for addr1
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="add",
args=[Web3.toChecksumAddress(addr1)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_balance(genesis_addr),
b0 - gas + 12500000 - collateral_per_storage_key)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + collateral_per_storage_key)
# addr1 call contract with privilege
sb = client.get_sponsor_balance_for_gas(contract_addr)
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_balance(addr1), b1)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sb - gas + 12500000)
# addr1 call contract with privilege and large tx fee
b1 = client.get_balance(addr1)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True,
gas=upper_bound + 1)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_balance(addr1),
b1 - upper_bound + upper_bound // 4 - 1)
# addr2 call contract without privilege
b2 = client.get_balance(addr2)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_balance(addr2), b2 - gas + 12500000)
# set privilege for addr2
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="add",
args=[Web3.toChecksumAddress(addr2)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_balance(genesis_addr),
b0 - gas + 12500000 - collateral_per_storage_key)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + collateral_per_storage_key)
# now, addr2 call contract with privilege
sb = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sb - gas + 12500000)
assert_equal(client.get_balance(addr2), b2)
# remove privilege for addr1
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="remove",
args=[Web3.toChecksumAddress(addr1)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 - collateral_per_storage_key)
assert_equal(client.get_balance(genesis_addr),
b0 - gas + 12500000 + collateral_per_storage_key)
# addr1 call contract without privilege
sb = client.get_sponsor_balance_for_gas(contract_addr)
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_balance(addr1), b1 - gas + 12500000)
# new sponsor failed due to small sponsor_balance
b3 = client.get_balance(addr3)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound + 1],
value=5 * 10**17,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr)
assert_equal(client.get_balance(addr3), b3 - gas)
# new sponsor failed due to small upper bound
b3 = client.get_balance(addr3)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound],
value=10**18,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr)
assert_equal(client.get_balance(addr3), b3 - gas)
# new sponsor succeed
b0 = client.get_balance(genesis_addr)
b3 = client.get_balance(addr3)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound + 1],
value=10**18,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18)
assert_equal(client.get_sponsor_gas_bound(contract_addr),
upper_bound + 1)
assert_equal(client.get_sponsor_for_gas(contract_addr), addr3)
assert_equal(client.get_balance(addr3), b3 - 10**18 - gas + 12500000)
assert_equal(client.get_balance(genesis_addr), b0 + sb)
# sponsor the contract for collateral failed due to zero sponsor balance
b3 = client.get_balance(addr3)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=0,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
0)
assert_equal(client.get_sponsor_for_collateral(contract_addr),
"0x0000000000000000000000000000000000000000")
assert_equal(client.get_balance(addr3), b3 - gas)
# sponsor the contract for collateral succeed
b3 = client.get_balance(addr3)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=10**18 - 1,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
10**18 - 1)
assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3)
assert_equal(client.get_balance(addr3),
b3 - gas + 12500000 - 10**18 + 1)
# addr1 create 2 keys without privilege, and storage limit is 1, should failed
b1 = client.get_balance(addr1)
assert_equal(client.get_collateral_for_storage(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(addr1), 0)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[0, 2],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key)
assert_equal(client.get_collateral_for_storage(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(addr1), 0)
assert_equal(client.get_balance(addr1), b1 - gas)
# addr1 create 2 keys without privilege, and storage limit is 2, should succeed
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[0, 2],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 2)
assert_equal(client.get_collateral_for_storage(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(addr1),
collateral_per_storage_key * 2)
assert_equal(client.get_balance(addr1),
b1 - gas + 12500000 - collateral_per_storage_key * 2)
# remove 1 key create by addr1
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="par_del",
args=[0, 1],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 2)
assert_equal(client.get_collateral_for_storage(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(addr1),
collateral_per_storage_key)
assert_equal(client.get_balance(addr1),
b1 - gas + 12500000 + collateral_per_storage_key)
# addr2 create 2 keys with privilege, and storage limit is 1, should succeed
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[2, 4],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 2)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc - collateral_per_storage_key * 2)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - gas + 12500000)
assert_equal(client.get_collateral_for_storage(addr2), 0)
assert_equal(client.get_balance(addr2), b2)
# addr2 create 13 keys with privilege, and storage limit is 0, should succeed
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[4, 17],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=0)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 15)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc - collateral_per_storage_key * 13)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - gas + 12500000)
assert_equal(client.get_collateral_for_storage(addr2), 0)
assert_equal(client.get_balance(addr2), b2)
# now sponsor_balance is unable to pay collateral for storage
# the balance of addr2 is able to pay 15 collateral for storage, but not 16
assert_greater_than(
collateral_per_storage_key,
client.get_sponsor_balance_for_collateral(contract_addr))
assert_greater_than(collateral_per_storage_key * 16,
client.get_balance(addr2))
assert_greater_than(client.get_balance(addr2),
collateral_per_storage_key * 15)
# addr2 create 1 keys with privilege, and storage limit is 0, should failed
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[17, 18],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=0)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 15)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - gas)
assert_equal(client.get_collateral_for_storage(addr2), 0)
assert_equal(client.get_balance(addr2), b2)
# addr2 create 1 keys with privilege, and storage limit is 2, should succeed
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[17, 18],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 2)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 15)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - gas + 12500000)
assert_equal(client.get_collateral_for_storage(addr2),
collateral_per_storage_key)
assert_equal(client.get_balance(addr2),
b2 - collateral_per_storage_key)
# addr2 del 10 keys with privilege
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_del",
args=[2, 12],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 5)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc + collateral_per_storage_key * 10)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - gas + 12500000)
assert_equal(client.get_collateral_for_storage(addr2),
collateral_per_storage_key)
assert_equal(client.get_balance(addr2), b2)
# addr3 sponsor more, treat as transfer
b3 = client.get_balance(addr3)
sb = client.get_sponsor_balance_for_collateral(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=sb,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sb * 2)
assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3)
assert_equal(client.get_balance(addr3), b3 - gas + 12500000 - sb)
# genesis sponsor with sponsor balance, should failed
b0 = client.get_balance(genesis_addr)
sb = client.get_sponsor_balance_for_collateral(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=sb + 1,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sb)
assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3)
assert_equal(client.get_balance(genesis_addr), b0 - gas)
# genesis sponsor with sponsor balance and collateral_for_storage, should succeed
b0 = client.get_balance(genesis_addr)
b3 = client.get_balance(addr3)
cfs = client.get_collateral_for_storage(contract_addr)
sb = client.get_sponsor_balance_for_collateral(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=sb + cfs + 1,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_collateral_for_storage(contract_addr), cfs)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sb + cfs + 1)
assert_equal(client.get_sponsor_for_collateral(contract_addr),
genesis_addr)
assert_equal(client.get_balance(genesis_addr),
b0 - gas + 12500000 - sb - cfs - 1)
assert_equal(client.get_balance(addr3), b3 + sb + cfs)
self.log.info("Pass")
def run_test(self):
start_p2p_connection(self.nodes)
block_gen_thread = BlockGenThread(self.nodes,
self.log,
interval_base=0.2)
block_gen_thread.start()
genesis_key = default_config["GENESIS_PRI_KEY"]
tx_n = 100
gas_price = 1
shard_balance = []
for s in range(self.n_shard):
''' Send random transactions to this shard s '''
shard_nodes = self.nodes[s * self.shard_size:(s + 1) *
self.shard_size]
# We can not use genesis accounts in two shards, because they may generate transactions
# that are valid in another shard and breaks our assertion about the final shard state.
start_sk, _ = ec_random_keys()
value = default_config["TOTAL_COIN"] - 21000
tx = create_transaction(pri_key=genesis_key,
receiver=priv_to_addr(start_sk),
value=value,
nonce=0,
gas_price=gas_price)
shard_nodes[0].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
balance_map = {start_sk: value}
nonce_map = {
start_sk:
wait_for_initial_nonce_for_privkey(shard_nodes[0], start_sk)
}
account_n = 10
# Initialize new accounts
new_keys = set()
for _ in range(account_n):
value = max(int(balance_map[start_sk] * random.random()),
21000 * tx_n)
receiver_sk, _ = ec_random_keys()
new_keys.add(receiver_sk)
tx = create_transaction(pri_key=start_sk,
receiver=priv_to_addr(receiver_sk),
value=value,
nonce=nonce_map[start_sk],
gas_price=gas_price)
shard_nodes[0].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
balance_map[receiver_sk] = value
nonce_map[start_sk] += 1
balance_map[start_sk] -= value + gas_price * 21000
wait_for_account_stable()
for key in new_keys:
nonce_map[key] = wait_for_initial_nonce_for_privkey(
shard_nodes[0], key)
for i in range(tx_n):
sender_key = random.choice(list(balance_map))
nonce = nonce_map[sender_key]
value = 0
receiver_sk = random.choice(list(balance_map))
balance_map[receiver_sk] += value
tx = create_transaction(pri_key=sender_key,
receiver=priv_to_addr(receiver_sk),
value=value,
nonce=nonce,
gas_price=gas_price)
r = random.randint(0, self.shard_size - 1)
shard_nodes[r].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
nonce_map[sender_key] = nonce + 1
balance_map[sender_key] -= value + gas_price * 21000
self.log.info(
"New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d",
encode_hex(tx.hash),
eth_utils.encode_hex(priv_to_addr(sender_key))[-4:], value,
eth_utils.encode_hex(priv_to_addr(receiver_sk))[-4:],
balance_map[sender_key], balance_map[receiver_sk])
self.log.debug("Send Transaction %s to node %d",
encode_hex(tx.hash), r)
time.sleep(random.random() / 10)
for k in balance_map:
self.log.info("Check account sk:%s addr:%s", bytes_to_int(k),
eth_utils.encode_hex(priv_to_addr(k)))
wait_until(
lambda: self.check_account(k, balance_map, shard_nodes[0]))
shard_balance.append(balance_map)
def epochCheck(node):
r = node.cfx_epochNumber()
return int(r, 0) > 110
wait_until(lambda: epochCheck(self.nodes[0]))
wait_until(
lambda: epochCheck(self.nodes[int(self.num_nodes / self.n_shard)]))
for s in range(self.n_shard):
for idx in range(self.shard_size):
connect_nodes(self.nodes, s * self.shard_size - 1 + idx,
s * self.shard_size + idx)
block_gen_thread.stop()
block_gen_thread.join()
sync_blocks(self.nodes)
''' Check if the balance state of every node matches '''
success_shard = -1
# use the state of node 0 to find the winning shard
for s in range(self.n_shard):
balance_map = shard_balance[s]
unmatch = False
for k in balance_map:
if not self.check_account(k, balance_map, self.nodes[0]):
unmatch = True
self.log.info(
"Final balance does not match shard %s, check next", s)
break
if unmatch:
continue
success_shard = s
break
assert success_shard != -1, "The final state of node 0 matches no shard state"
self.log.info("Shard %s succeeds", success_shard)
for i in range(1, self.num_nodes):
balance_map = shard_balance[success_shard]
for k in balance_map:
if not self.check_account(k, balance_map, self.nodes[i]):
raise AssertionError(
"Final balance of node {} does not match node 0, sender={}"
.format(i, k))
self.log.info("Pass")
def run_test(self):
sponsor_whitelist_contract_addr = Web3.toChecksumAddress(
"0888000000000000000000000000000000000001")
bytes_per_key = 64
collateral_per_byte = 10**18 // 1024
collateral_per_storage_key = 10**18 // 16
# block gas limit (GENESIS_GAS_LIMIT); -1 because below gas is set to upper_bound + 1
upper_bound = default_config["GENESIS_GAS_LIMIT"] - 1
file_dir = os.path.dirname(os.path.realpath(__file__))
control_contract_file_path = os.path.dirname(
os.path.realpath(__file__)).split("/")
control_contract_file_path.pop(-1)
control_contract_file_path.extend(
["internal_contract", "metadata", "SponsorWhitelistControl.json"])
control_contract_file_path = "/".join(control_contract_file_path)
control_contract_dict = json.loads(
open(os.path.join(control_contract_file_path), "r").read())
control_contract = get_contract_instance(
contract_dict=control_contract_dict)
test_contract = get_contract_instance(
abi_file=os.path.join(
file_dir, "contracts/commission_privilege_test_abi.json"),
bytecode_file=os.path.join(
file_dir, "contracts/commission_privilege_test_bytecode.dat"),
)
start_p2p_connection(self.nodes)
self.log.info("Initializing contract")
genesis_key = self.genesis_priv_key
genesis_addr = encode_hex(self.genesis_addr)
self.log.info("genesis_addr={}".format(genesis_addr))
nonce = 0
gas_price = 1
gas = CONTRACT_DEFAULT_GAS
block_gen_thread = BlockGenThread(self.nodes, self.log)
block_gen_thread.start()
self.tx_conf = {
"from": Web3.toChecksumAddress(genesis_addr),
"nonce": int_to_hex(nonce),
"gas": int_to_hex(gas),
"gasPrice": int_to_hex(gas_price),
"chainId": 0
}
# Setup balance for node 0
node = self.nodes[0]
client = RpcClient(node)
(addr1, priv_key1) = client.rand_account()
(addr2, priv_key2) = client.rand_account()
(addr3, priv_key3) = client.rand_account()
(addr4, priv_key4) = client.rand_account()
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=10**18,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr1)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr1), 10**18)
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=10**18,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr2)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr2), 10**18)
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=3 * 10**18,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr3)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr3), 3 * 10**18)
# setup contract
transaction = self.call_contract_function(
contract=test_contract,
name="constructor",
args=[],
sender_key=self.genesis_priv_key,
storage_limit=2723)
contract_addr = self.wait_for_tx([transaction],
True)[0]['contractCreated']
self.log.info("contract_addr={}".format(contract_addr))
assert_equal(client.get_balance(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(genesis_addr),
2723 * collateral_per_byte)
# sponsor the contract failed due to sponsor_balance < 1000 * upper_bound
b0 = client.get_balance(genesis_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound],
value=upper_bound * 1000 - 1,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 0)
assert_equal(client.get_sponsor_for_gas(contract_addr),
"0x0000000000000000000000000000000000000000")
assert_equal(client.get_sponsor_gas_bound(contract_addr), 0)
assert_equal(client.get_balance(genesis_addr), b0 - gas)
# sponsor the contract succeed
b0 = client.get_balance(genesis_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound],
value=10**18,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18)
assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr)
assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound)
assert_equal(client.get_balance(genesis_addr),
b0 - 10**18 - charged_of_huge_gas(gas))
check_info = client.check_balance_against_transaction(addr1,
contract_addr,
gas,
gas_price,
storage_limit=0)
assert_equal(check_info['willPayTxFee'], True)
assert_equal(check_info['willPayCollateral'], True)
assert_equal(check_info['isBalanceEnough'], True)
check_info = client.check_balance_against_transaction(addr4,
contract_addr,
gas,
gas_price,
storage_limit=0)
assert_equal(check_info['willPayTxFee'], True)
assert_equal(check_info['willPayCollateral'], True)
assert_equal(check_info['isBalanceEnough'], False)
# set privilege for addr4
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="add",
args=[Web3.toChecksumAddress(addr4)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True,
storage_limit=64)
assert_equal(
client.get_balance(genesis_addr),
b0 - charged_of_huge_gas(gas) - collateral_per_storage_key)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + collateral_per_storage_key)
check_info = client.check_balance_against_transaction(addr4,
contract_addr,
gas,
gas_price,
storage_limit=0)
assert_equal(check_info['willPayTxFee'], False)
assert_equal(check_info['willPayCollateral'], True)
assert_equal(check_info['isBalanceEnough'], True)
# remove privilege for addr4
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="remove",
args=[Web3.toChecksumAddress(addr4)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 - collateral_per_storage_key)
assert_equal(
client.get_balance(genesis_addr),
b0 - charged_of_huge_gas(gas) + collateral_per_storage_key)
# set privilege for addr1
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="add",
args=[Web3.toChecksumAddress(addr1)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True,
storage_limit=64)
assert_equal(
client.get_balance(genesis_addr),
b0 - charged_of_huge_gas(gas) - collateral_per_storage_key)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + collateral_per_storage_key)
# addr1 call contract with privilege
sb = client.get_sponsor_balance_for_gas(contract_addr)
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_balance(addr1), b1)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sb - charged_of_huge_gas(gas))
# addr1 call contract with privilege and large tx fee
b1 = client.get_balance(addr1)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True,
gas=upper_bound + 1)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_balance(addr1),
b1 - charged_of_huge_gas(upper_bound + 1))
# addr2 call contract without privilege
b2 = client.get_balance(addr2)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_balance(addr2), b2 - charged_of_huge_gas(gas))
# set privilege for addr2
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="add",
args=[Web3.toChecksumAddress(addr2)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True,
storage_limit=64)
assert_equal(
client.get_balance(genesis_addr),
b0 - charged_of_huge_gas(gas) - collateral_per_storage_key)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + collateral_per_storage_key)
# now, addr2 call contract with privilege
sb = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sb - charged_of_huge_gas(gas))
assert_equal(client.get_balance(addr2), b2)
# remove privilege for addr1
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="remove",
args=[Web3.toChecksumAddress(addr1)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 - collateral_per_storage_key)
assert_equal(
client.get_balance(genesis_addr),
b0 - charged_of_huge_gas(gas) + collateral_per_storage_key)
# addr1 call contract without privilege
sb = client.get_sponsor_balance_for_gas(contract_addr)
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_balance(addr1), b1 - charged_of_huge_gas(gas))
# new sponsor failed due to small sponsor_balance
b3 = client.get_balance(addr3)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound + 1],
value=5 * 10**17,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr)
assert_equal(client.get_balance(addr3), b3 - gas)
# new sponsor failed due to small upper bound
b3 = client.get_balance(addr3)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound],
value=10**18,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb)
assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr)
assert_equal(client.get_balance(addr3), b3 - gas)
# new sponsor succeed
b0 = client.get_balance(genesis_addr)
b3 = client.get_balance(addr3)
sb = client.get_sponsor_balance_for_gas(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound + 1],
value=10**18,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18)
assert_equal(client.get_sponsor_gas_bound(contract_addr),
upper_bound + 1)
assert_equal(client.get_sponsor_for_gas(contract_addr), addr3)
assert_equal(client.get_balance(addr3),
b3 - 10**18 - charged_of_huge_gas(gas))
assert_equal(client.get_balance(genesis_addr), b0 + sb)
# sponsor the contract for collateral failed due to zero sponsor balance
b3 = client.get_balance(addr3)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=0,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
0)
assert_equal(client.get_sponsor_for_collateral(contract_addr),
"0x0000000000000000000000000000000000000000")
assert_equal(client.get_balance(addr3), b3 - gas)
# sponsor the contract for collateral succeed
b3 = client.get_balance(addr3)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=10**18 - 1,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
10**18 - 1)
assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3)
assert_equal(client.get_balance(addr3),
b3 - charged_of_huge_gas(gas) - 10**18 + 1)
check_info = client.check_balance_against_transaction(addr1,
contract_addr,
gas,
gas_price,
storage_limit=0)
assert_equal(check_info['willPayTxFee'], True)
assert_equal(check_info['willPayCollateral'], True)
assert_equal(check_info['isBalanceEnough'], True)
# addr1 create 2 keys without privilege, and storage limit is 1, should failed
b1 = client.get_balance(addr1)
assert_equal(client.get_collateral_for_storage(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(addr1), 0)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[0, 2],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key)
assert_equal(client.get_collateral_for_storage(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(addr1), 0)
assert_equal(client.get_balance(addr1), b1 - gas)
# addr1 create 2 keys without privilege, and storage limit is 2, should succeed
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[0, 2],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 2)
assert_equal(client.get_collateral_for_storage(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(addr1),
collateral_per_storage_key * 2)
assert_equal(
client.get_balance(addr1),
b1 - charged_of_huge_gas(gas) - collateral_per_storage_key * 2)
# remove 1 key create by addr1
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="par_del",
args=[0, 1],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 2)
assert_equal(client.get_collateral_for_storage(contract_addr), 0)
assert_equal(client.get_collateral_for_storage(addr1),
collateral_per_storage_key)
assert_equal(
client.get_balance(addr1),
b1 - charged_of_huge_gas(gas) + collateral_per_storage_key)
check_info = client.check_balance_against_transaction(
addr2, contract_addr, gas, gas_price, storage_limit=bytes_per_key)
assert_equal(check_info['willPayTxFee'], False)
assert_equal(check_info['willPayCollateral'], False)
assert_equal(check_info['isBalanceEnough'], True)
check_info = client.check_balance_against_transaction(
addr2, contract_addr, gas, gas_price, storage_limit=10**18)
assert_equal(check_info['willPayTxFee'], False)
assert_equal(check_info['willPayCollateral'], True)
assert_equal(check_info['isBalanceEnough'], True)
# addr2 create 2 keys with privilege, and storage limit is 1, should succeed
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[2, 4],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 2)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc - collateral_per_storage_key * 2)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - charged_of_huge_gas(gas))
assert_equal(client.get_collateral_for_storage(addr2), 0)
assert_equal(client.get_balance(addr2), b2)
# addr2 create 13 keys with privilege, and storage limit is 0, should succeed
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[4, 17],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=0)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 15)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc - collateral_per_storage_key * 13)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - charged_of_huge_gas(gas))
assert_equal(client.get_collateral_for_storage(addr2), 0)
assert_equal(client.get_balance(addr2), b2)
# now sponsor_balance is unable to pay collateral for storage
# the balance of addr2 is able to pay 15 collateral for storage, but not 16
assert_greater_than(
collateral_per_storage_key,
client.get_sponsor_balance_for_collateral(contract_addr))
assert_greater_than(collateral_per_storage_key * 16,
client.get_balance(addr2))
assert_greater_than(client.get_balance(addr2),
collateral_per_storage_key * 15)
# addr2 create 1 keys with privilege, and storage limit is 0, should failed
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[17, 18],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=0)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 15)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - gas)
assert_equal(client.get_collateral_for_storage(addr2), 0)
assert_equal(client.get_balance(addr2), b2)
# addr2 create 1 keys with privilege, and storage limit is 2, should succeed
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_add",
args=[17, 18],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 2)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 15)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - charged_of_huge_gas(gas))
assert_equal(client.get_collateral_for_storage(addr2),
collateral_per_storage_key)
assert_equal(client.get_balance(addr2),
b2 - collateral_per_storage_key)
# addr2 del 10 keys with privilege
sbc = client.get_sponsor_balance_for_collateral(contract_addr)
sbg = client.get_sponsor_balance_for_gas(contract_addr)
b2 = client.get_balance(addr2)
self.call_contract_function(contract=test_contract,
name="par_del",
args=[2, 12],
sender_key=priv_key2,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key)
assert_equal(client.get_collateral_for_storage(contract_addr),
collateral_per_storage_key * 5)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sbc + collateral_per_storage_key * 10)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sbg - charged_of_huge_gas(gas))
assert_equal(client.get_collateral_for_storage(addr2),
collateral_per_storage_key)
assert_equal(client.get_balance(addr2), b2)
# addr3 sponsor more, treat as transfer
b3 = client.get_balance(addr3)
sb = client.get_sponsor_balance_for_collateral(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=sb,
sender_key=priv_key3,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sb * 2)
assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3)
assert_equal(client.get_balance(addr3),
b3 - charged_of_huge_gas(gas) - sb)
# genesis sponsor with sponsor balance, should failed
b0 = client.get_balance(genesis_addr)
sb = client.get_sponsor_balance_for_collateral(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=sb + 1,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sb)
assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3)
assert_equal(client.get_balance(genesis_addr), b0 - gas)
# genesis sponsor with sponsor balance and collateral_for_storage, should succeed
b0 = client.get_balance(genesis_addr)
b3 = client.get_balance(addr3)
cfs = client.get_collateral_for_storage(contract_addr)
sb = client.get_sponsor_balance_for_collateral(contract_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_collateral",
args=[Web3.toChecksumAddress(contract_addr)],
value=sb + cfs + 1,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_collateral_for_storage(contract_addr), cfs)
assert_equal(client.get_sponsor_balance_for_collateral(contract_addr),
sb + 1)
assert_equal(client.get_sponsor_for_collateral(contract_addr),
genesis_addr)
assert_equal(client.get_balance(genesis_addr),
b0 - charged_of_huge_gas(gas) - sb - cfs - 1)
assert_equal(client.get_balance(addr3), b3 + sb + cfs)
# storage change test
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="par",
args=[10, 20, 30, 41],
sender_key=self.genesis_priv_key,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 30)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + 11 * collateral_per_storage_key)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="par_add_del",
args=[110, 120, 110, 120],
sender_key=self.genesis_priv_key,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 30)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + 10 * collateral_per_storage_key)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="par_add_del",
args=[210, 220, 215, 220],
sender_key=self.genesis_priv_key,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 30)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + 5 * collateral_per_storage_key)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="par_add_del",
args=[310, 320, 320, 330],
sender_key=self.genesis_priv_key,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 30)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + 10 * collateral_per_storage_key)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="par_add_del",
args=[410, 420, 409, 430],
sender_key=self.genesis_priv_key,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 300)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + 21 * collateral_per_storage_key)
# test recurrence
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="rec",
args=[510, 520, 3],
sender_key=self.genesis_priv_key,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 30)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + 4 * collateral_per_storage_key)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="par_del",
args=[510, 520],
sender_key=self.genesis_priv_key,
contract_addr=contract_addr,
wait=True,
storage_limit=bytes_per_key * 30)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 - 4 * collateral_per_storage_key)
self.log.info("Pass")
def run_test(self):
num_nodes = len(self.nodes)
if self.tx_propagation_enabled:
# Setup balance for each node
client = RpcClient(self.nodes[0])
for i in range(num_nodes):
pub_key = self.nodes[i].key
addr = self.nodes[i].addr
self.log.info("%d has addr=%s pubkey=%s", i, encode_hex(addr),
pub_key)
tx = client.new_tx(value=int(default_config["TOTAL_COIN"] /
(num_nodes + 1)) - 21000,
receiver=encode_hex(addr),
nonce=i)
client.send_tx(tx)
# setup monitor to report the current block count periodically
cur_block_count = self.nodes[0].getblockcount()
# The monitor will check the block_count of nodes[0]
monitor_thread = threading.Thread(target=self.monitor,
args=(cur_block_count, 100),
daemon=True)
monitor_thread.start()
# generate blocks
threads = {}
rpc_times = []
for i in range(1, self.options.num_blocks + 1):
wait_sec = random.expovariate(1000 /
self.options.generation_period_ms)
start = time.time()
# find an idle node to generate block
p = random.randint(0, num_nodes - 1)
retry = 0
while retry < 10:
pre_thread = threads.get(p)
if pre_thread is not None and pre_thread.is_alive():
p = random.randint(0, num_nodes - 1)
retry += 1
else:
break
if retry >= 10:
self.log.warn(
"too many nodes are busy to generate block, stop to analyze logs."
)
break
if self.tx_propagation_enabled:
# Generate a block with the transactions in the node's local tx pool
thread = SimpleGenerateThread(
self.nodes, p, self.options.txs_per_block,
self.options.generate_tx_data_len, self.log, rpc_times)
else:
# Generate a fixed-size block with fake tx
thread = GenerateThread(self.nodes, p,
self.options.txs_per_block,
self.options.generate_tx_data_len,
self.log, rpc_times)
thread.start()
threads[p] = thread
if i % self.options.block_sync_step == 0:
self.log.info("[PROGRESS] %d blocks generated async", i)
elapsed = time.time() - start
if elapsed < wait_sec:
self.log.debug("%d generating block %.2f", p, elapsed)
time.sleep(wait_sec - elapsed)
else:
self.log.warn("%d generating block slowly %.2f", p, elapsed)
monitor_thread.join()
self.sync_blocks()
self.log.info("generateoneblock RPC latency: {}".format(
Statistics(rpc_times, 3).__dict__))
self.log.info("Best block: {}".format(
RpcClient(self.nodes[0]).best_block_hash()))
logs = client.get_logs(filter=Filter(from_block=hex(start), to_block=hex(end), address=["0x0888000000000000000000000000000000000005"], networkid=1))
print("logs=", logs)
for log in logs:
pos_identifier = log["topics"][1]
if log["topics"][0] == REGISTER_TOPIC:
bls_pub_key, vrf_pub_key = eth_abi.decode_abi(["bytes", "bytes"], decode_hex(log["data"]))
pub_keys_map[pos_identifier] = (encode_hex_0x(bls_pub_key), encode_hex_0x(vrf_pub_key))
print(pub_keys_map[pos_identifier])
elif log["topics"][0] == INCREASE_STAKE_TOPIC:
assert pos_identifier in pub_keys_map
voting_power_map[pos_identifier] += parse_as_int(log["data"])
with open(os.path.join(cwd, "public_keys"), "w") as f:
for pos_identifier in pub_keys_map.keys():
f.write(",".join([pub_keys_map[pos_identifier][0][2:], pub_keys_map[pos_identifier][1][2:], str(voting_power_map[pos_identifier])]) + "\n")
cfx_block_hash = client.block_by_block_number(hex(end_block_number))["hash"]
initial_seed = encode_hex(keccak(hexstr=cfx_block_hash[2:]+bitcoin_block_hash))
tg_config_gen = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../target/release/pos-genesis-tool")
check_output([tg_config_gen, "frompub", "--initial-seed={}".format(initial_seed),"public_keys"], cwd=cwd)
waypoint = open(os.path.join(cwd, "waypoint_config"), "r").readlines()[0]
conf_file = open(os.path.join(cwd, "pos_config.yaml"), "w")
conf_file.write(f"""
base:
#data_dir: ./pos_db
role: validator
waypoint:
from_config: {waypoint}
consensus:
round_initial_timeout_ms: 60000
safety_rules:
service:
type: local
def run_test(self):
start_p2p_connection(self.nodes)
block_gen_thread = BlockGenThread(self.nodes, self.log, interval_base=0.2)
block_gen_thread.start()
genesis_key = default_config["GENESIS_PRI_KEY"]
tx_n = 100
gas_price = 1
shard_size = int(self.num_nodes / self.n_shard)
shard_balance = []
for s in range(self.n_shard):
''' Send random transactions to this shard s '''
shard_nodes = self.nodes[s * shard_size: (s + 1) * shard_size]
receiver_sk, _ = ec_random_keys()
value = default_config["TOTAL_COIN"] - 21000
balance_map = {receiver_sk: value}
nonce_map = {receiver_sk: 0}
tx = create_transaction(pri_key=genesis_key, receiver=privtoaddr(receiver_sk), value=value, nonce=0,
gas_price=gas_price)
shard_nodes[0].p2p.send_protocol_msg(Transactions(transactions=[tx]))
for i in range(tx_n):
sender_key = random.choice(list(balance_map))
nonce = nonce_map[sender_key]
if random.random() < 0.2 and balance_map[sender_key] > 21000 * 4 * tx_n:
value = int(balance_map[sender_key] * 0.5)
receiver_sk, _ = ec_random_keys()
nonce_map[receiver_sk] = 0
balance_map[receiver_sk] = value
else:
value = 1
receiver_sk = random.choice(list(balance_map))
balance_map[receiver_sk] += value
tx = create_transaction(pri_key=sender_key, receiver=privtoaddr(receiver_sk), value=value, nonce=nonce,
gas_price=gas_price)
r = random.randint(0, shard_size - 1)
shard_nodes[r].p2p.send_protocol_msg(Transactions(transactions=[tx]))
nonce_map[sender_key] = nonce + 1
balance_map[sender_key] -= value + gas_price * 21000
self.log.info("New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d", encode_hex(tx.hash), eth_utils.encode_hex(privtoaddr(sender_key))[-4:],
value, eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:], balance_map[sender_key], balance_map[receiver_sk])
self.log.debug("Send Transaction %s to node %d", encode_hex(tx.hash), r)
time.sleep(random.random() / 10)
for k in balance_map:
self.log.info("Check account sk:%s addr:%s", bytes_to_int(k), eth_utils.encode_hex(privtoaddr(k)))
wait_until(lambda: self.check_account(k, balance_map, shard_nodes[0]))
shard_balance.append(balance_map)
def epochCheck(node):
r = node.cfx_epochNumber()
return int(r, 0) > 110
wait_until(lambda: epochCheck(self.nodes[0]))
wait_until(lambda: epochCheck(self.nodes[int(self.num_nodes / self.n_shard)]))
for s in range(self.n_shard):
connect_nodes(self.nodes, s * shard_size - 1, s * shard_size)
block_gen_thread.stop()
block_gen_thread.join()
sync_blocks(self.nodes)
''' Check if the balance state of every node matches '''
success_shard = -1
# use the state of node 0 to find the winning shard
for s in range(self.n_shard):
balance_map = shard_balance[s]
unmatch = False
for k in balance_map:
if not self.check_account(k, balance_map, self.nodes[0]):
unmatch = True
self.log.info("Final balance does not match shard %s, check next", s)
break
if unmatch:
continue
success_shard = s
break
assert success_shard != -1, "The final state of node 0 matches no shard state"
self.log.info("Shard %s succeeds", success_shard)
for i in range(1, self.num_nodes):
balance_map = shard_balance[success_shard]
for k in balance_map:
if not self.check_account(k, balance_map, self.nodes[i]):
raise AssertionError("Final balance of node {} does not match node 0, sender={}".format(i, k))
self.log.info("Pass")
def run_test(self):
# Prevent easysolc from configuring the root logger to print to stderr
self.log.propagate = False
solc = Solc()
erc20_contract = solc.get_contract_instance(source=os.path.dirname(os.path.realpath(__file__)) + "/erc20.sol", contract_name="FixedSupplyToken")
start_p2p_connection(self.nodes)
self.log.info("Initializing contract")
genesis_key = default_config["GENESIS_PRI_KEY"]
genesis_addr = privtoaddr(genesis_key)
nonce = 0
gas_price = 1
gas = 50000000
block_gen_thread = BlockGenThread(self.nodes, self.log)
block_gen_thread.start()
self.tx_conf = {"from":Web3.toChecksumAddress(encode_hex_0x(genesis_addr)), "nonce":int_to_hex(nonce), "gas":int_to_hex(gas), "gasPrice":int_to_hex(gas_price)}
raw_create = erc20_contract.constructor().buildTransaction(self.tx_conf)
tx_data = decode_hex(raw_create["data"])
tx_create = create_transaction(pri_key=genesis_key, receiver=b'', nonce=nonce, gas_price=gas_price, data=tx_data, gas=gas, value=0)
self.nodes[0].p2p.send_protocol_msg(Transactions(transactions=[tx_create]))
self.wait_for_tx([tx_create])
self.log.info("Contract created, start transfering tokens")
tx_n = 10
self.tx_conf["to"] = Web3.toChecksumAddress(encode_hex_0x(sha3_256(rlp.encode([genesis_addr, nonce]))[-20:]))
nonce += 1
balance_map = {genesis_key: 1000000 * 10**18}
sender_key = genesis_key
all_txs = []
for i in range(tx_n):
value = int((balance_map[sender_key] - ((tx_n - i) * 21000 * gas_price)) * random.random())
receiver_sk, _ = ec_random_keys()
balance_map[receiver_sk] = value
tx_data = decode_hex(erc20_contract.functions.transfer(Web3.toChecksumAddress(encode_hex(privtoaddr(receiver_sk))), value).buildTransaction(self.tx_conf)["data"])
tx = create_transaction(pri_key=sender_key, receiver=decode_hex(self.tx_conf["to"]), value=0, nonce=nonce, gas=gas,
gas_price=gas_price, data=tx_data)
r = random.randint(0, self.num_nodes - 1)
self.nodes[r].p2p.send_protocol_msg(Transactions(transactions=[tx]))
nonce += 1
balance_map[sender_key] -= value
all_txs.append(tx)
self.log.info("Wait for transactions to be executed")
self.wait_for_tx(all_txs)
self.log.info("Check final token balance")
for sk in balance_map:
addr = privtoaddr(sk)
assert_equal(self.get_balance(erc20_contract, addr, nonce), balance_map[sk])
block_gen_thread.stop()
block_gen_thread.join()
sync_blocks(self.nodes)
self.log.info("Pass")
def run_test(self):
file_dir = os.path.dirname(os.path.realpath(__file__))
erc20_contract = get_contract_instance(
abi_file=os.path.join(file_dir, "contracts/erc20_abi.json"),
bytecode_file=os.path.join(file_dir,
"contracts/erc20_bytecode.dat"),
)
gas_price = 1
gas = CONTRACT_DEFAULT_GAS
start_p2p_connection(self.nodes)
self.log.info("Initializing contract")
genesis_key = default_config["GENESIS_PRI_KEY"]
genesis_addr = encode_hex_0x(priv_to_addr(genesis_key))
nonce = 0
block_gen_thread = BlockGenThread(self.nodes, self.log)
block_gen_thread.start()
self.tx_conf = {
"from": Web3.toChecksumAddress(genesis_addr),
"nonce": int_to_hex(nonce),
"gas": int_to_hex(gas),
"gasPrice": int_to_hex(gas_price),
"chainId": 0
}
raw_create = erc20_contract.constructor().buildTransaction(
self.tx_conf)
tx_data = decode_hex(raw_create["data"])
tx_create = create_transaction(pri_key=genesis_key,
receiver=b'',
nonce=nonce,
gas_price=gas_price,
data=tx_data,
gas=gas,
value=0,
storage_limit=1920)
client = RpcClient(self.nodes[0])
c0 = client.get_collateral_for_storage(genesis_addr)
client.send_tx(tx_create, True)
receipt = client.get_transaction_receipt(tx_create.hash_hex())
c1 = client.get_collateral_for_storage(genesis_addr)
assert_equal(c1 - c0, 1920 * 10**18 / 1024)
contract_addr = receipt['contractCreated']
self.log.info("Contract " + str(contract_addr) +
" created, start transferring tokens")
tx_n = 10
self.tx_conf["to"] = contract_addr
nonce += 1
balance_map = {genesis_key: 1000000 * 10**18}
sender_key = genesis_key
all_txs = []
for i in range(tx_n):
value = int((balance_map[sender_key] -
((tx_n - i) * 21000 * gas_price)) * random.random())
receiver_sk, _ = ec_random_keys()
balance_map[receiver_sk] = value
tx_data = decode_hex(
erc20_contract.functions.transfer(
Web3.toChecksumAddress(
encode_hex(priv_to_addr(receiver_sk))),
value).buildTransaction(self.tx_conf)["data"])
tx = create_transaction(pri_key=sender_key,
receiver=decode_hex(self.tx_conf["to"]),
value=0,
nonce=nonce,
gas=gas,
gas_price=gas_price,
data=tx_data,
storage_limit=64)
r = random.randint(0, self.num_nodes - 1)
self.nodes[r].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
nonce += 1
balance_map[sender_key] -= value
all_txs.append(tx)
self.log.info("Wait for transactions to be executed")
self.wait_for_tx(all_txs)
self.log.info("Check final token balance")
for sk in balance_map:
addr = priv_to_addr(sk)
assert_equal(self.get_balance(erc20_contract, addr, nonce),
balance_map[sk])
c2 = client.get_collateral_for_storage(genesis_addr)
assert_equal(c2 - c1, 64 * tx_n * 10**18 / 1024)
block_gen_thread.stop()
block_gen_thread.join()
sync_blocks(self.nodes)
self.log.info("Pass")
def run_test(self):
sponsor_whitelist_contract_addr = Web3.toChecksumAddress(
"0888000000000000000000000000000000000001")
collateral_per_storage_key = 10**18 // 16
upper_bound = 5 * 10**7
file_dir = os.path.dirname(os.path.realpath(__file__))
control_contract_file_path = os.path.dirname(
os.path.realpath(__file__)).split("/")
control_contract_file_path.pop(-1)
control_contract_file_path.extend(
["internal_contract", "metadata", "SponsorWhitelistControl.json"])
control_contract_file_path = "/".join(control_contract_file_path)
control_contract_dict = json.loads(
open(os.path.join(control_contract_file_path), "r").read())
control_contract = get_contract_instance(
contract_dict=control_contract_dict)
test_contract = get_contract_instance(
abi_file=os.path.join(
file_dir, "contracts/commission_privilege_test_abi.json"),
bytecode_file=os.path.join(
file_dir, "contracts/commission_privilege_test_bytecode.dat"),
)
start_p2p_connection(self.nodes)
self.log.info("Initializing contract")
genesis_key = self.genesis_priv_key
genesis_addr = encode_hex(self.genesis_addr)
self.log.info("genesis_addr={}".format(genesis_addr))
nonce = 0
gas_price = 1
gas = CONTRACT_DEFAULT_GAS
block_gen_thread = BlockGenThread(self.nodes, self.log)
block_gen_thread.start()
self.tx_conf = {
"from": Web3.toChecksumAddress(genesis_addr),
"nonce": int_to_hex(nonce),
"gas": int_to_hex(gas),
"gasPrice": int_to_hex(gas_price),
"chainId": 0
}
# Setup balance for node 0
node = self.nodes[0]
client = RpcClient(node)
(addr1, priv_key1) = client.rand_account()
self.log.info("addr1={}".format(addr1))
tx = client.new_tx(sender=genesis_addr,
priv_key=genesis_key,
value=10**6,
nonce=self.get_nonce(self.genesis_addr),
receiver=addr1)
client.send_tx(tx, True)
assert_equal(client.get_balance(addr1), 10**6)
# setup contract
transaction = self.call_contract_function(
contract=test_contract,
name="constructor",
args=[],
sender_key=self.genesis_priv_key,
storage_limit=20000)
contract_addr = self.wait_for_tx([transaction],
True)[0]['contractCreated']
self.log.info("contract_addr={}".format(contract_addr))
assert_equal(client.get_balance(contract_addr), 0)
# sponsor the contract succeed
b0 = client.get_balance(genesis_addr)
self.call_contract_function(
contract=control_contract,
name="set_sponsor_for_gas",
args=[Web3.toChecksumAddress(contract_addr), upper_bound],
value=10**18,
sender_key=self.genesis_priv_key,
contract_addr=sponsor_whitelist_contract_addr,
wait=True)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18)
assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr)
assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound)
assert_equal(client.get_balance(genesis_addr),
b0 - 10**18 - charged_of_huge_gas(gas))
# set privilege for addr1
b0 = client.get_balance(genesis_addr)
c0 = client.get_collateral_for_storage(genesis_addr)
self.call_contract_function(contract=test_contract,
name="add",
args=[Web3.toChecksumAddress(addr1)],
sender_key=genesis_key,
contract_addr=contract_addr,
wait=True,
check_status=True,
storage_limit=64)
assert_equal(
client.get_balance(genesis_addr),
b0 - charged_of_huge_gas(gas) - collateral_per_storage_key)
assert_equal(client.get_collateral_for_storage(genesis_addr),
c0 + collateral_per_storage_key)
# addr1 call contract with privilege without enough cfx for gas fee
sb = client.get_sponsor_balance_for_gas(contract_addr)
b1 = client.get_balance(addr1)
self.call_contract_function(contract=test_contract,
name="foo",
args=[],
sender_key=priv_key1,
contract_addr=contract_addr,
wait=True,
check_status=True)
assert_equal(client.get_balance(addr1), 10**6)
assert_equal(client.get_sponsor_balance_for_gas(contract_addr),
sb - charged_of_huge_gas(gas))
self.log.info("Pass")
def run_test(self):
genesis_key = default_config["GENESIS_PRI_KEY"]
balance_map = {genesis_key: default_config["TOTAL_COIN"]}
self.log.info("Initial State: (sk:%d, addr:%s, balance:%d)",
bytes_to_int(genesis_key),
eth_utils.encode_hex(privtoaddr(genesis_key)),
balance_map[genesis_key])
nonce_map = {genesis_key: 0}
'''Check if transaction from uncommitted new address can be accepted'''
tx_n = 5
receiver_sk = genesis_key
gas_price = 1
for i in range(tx_n):
sender_key = receiver_sk
value = int((balance_map[sender_key] -
((tx_n - i) * 21000 * gas_price)) * random.random())
nonce = nonce_map[sender_key]
receiver_sk, _ = ec_random_keys()
nonce_map[receiver_sk] = 0
balance_map[receiver_sk] = value
tx = create_transaction(pri_key=sender_key,
receiver=privtoaddr(receiver_sk),
value=value,
nonce=nonce,
gas_price=gas_price)
r = random.randint(0, self.num_nodes - 1)
self.nodes[r].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
nonce_map[sender_key] = nonce + 1
balance_map[sender_key] -= value + gas_price * 21000
self.log.debug(
"New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d",
encode_hex(tx.hash),
eth_utils.encode_hex(privtoaddr(sender_key))[-4:], value,
eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:],
balance_map[sender_key], balance_map[receiver_sk])
self.log.debug("Send Transaction %s to node %d",
encode_hex(tx.hash), r)
time.sleep(random.random() / 100)
block_gen_thread = BlockGenThread(self.nodes,
self.log,
interval_base=0.2)
block_gen_thread.start()
for k in balance_map:
self.log.info("Check account sk:%s addr:%s", bytes_to_int(k),
eth_utils.encode_hex(privtoaddr(k)))
wait_until(lambda: self.check_account(k, balance_map))
self.log.info("Pass 1")
'''Test Random Transactions'''
all_txs = []
tx_n = 1000
self.log.info(
"start to generate %d transactions with about %d seconds", tx_n,
tx_n / 100 / 2)
for i in range(tx_n):
sender_key = random.choice(list(balance_map))
nonce = nonce_map[sender_key]
data = b''
rand_n = random.random()
gas = 21000
if rand_n < 0.1 and balance_map[sender_key] > 21000 * 4 * tx_n:
value = int(balance_map[sender_key] * 0.5)
receiver_sk, _ = ec_random_keys()
receiver = privtoaddr(receiver_sk)
nonce_map[receiver_sk] = 0
balance_map[receiver_sk] = value
elif rand_n > 0.9 and balance_map[sender_key] > 21000 * 4 * tx_n:
value = 0
receiver = b''
data = bytes([
96, 128, 96, 64, 82, 52, 128, 21, 97, 0, 16, 87, 96, 0,
128, 253, 91, 80, 96, 5, 96, 0, 129, 144, 85, 80, 96, 230,
128, 97, 0, 39, 96, 0, 57, 96, 0, 243, 254, 96, 128, 96,
64, 82, 96, 4, 54, 16, 96, 67, 87, 96, 0, 53, 124, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 144, 4, 128, 99, 96, 254, 71, 177, 20,
96, 72, 87, 128, 99, 109, 76, 230, 60, 20, 96, 127, 87, 91,
96, 0, 128, 253, 91, 52, 128, 21, 96, 83, 87, 96, 0, 128,
253, 91, 80, 96, 125, 96, 4, 128, 54, 3, 96, 32, 129, 16,
21, 96, 104, 87, 96, 0, 128, 253, 91, 129, 1, 144, 128,
128, 53, 144, 96, 32, 1, 144, 146, 145, 144, 80, 80, 80,
96, 167, 86, 91, 0, 91, 52, 128, 21, 96, 138, 87, 96, 0,
128, 253, 91, 80, 96, 145, 96, 177, 86, 91, 96, 64, 81,
128, 130, 129, 82, 96, 32, 1, 145, 80, 80, 96, 64, 81, 128,
145, 3, 144, 243, 91, 128, 96, 0, 129, 144, 85, 80, 80, 86,
91, 96, 0, 128, 84, 144, 80, 144, 86, 254, 161, 101, 98,
122, 122, 114, 48, 88, 32, 181, 24, 13, 149, 253, 195, 129,
48, 40, 237, 71, 246, 44, 124, 223, 112, 139, 118, 192,
219, 9, 64, 67, 245, 51, 180, 42, 67, 13, 49, 62, 21, 0, 41
])
gas = 10000000
else:
value = 1
receiver_sk = random.choice(list(balance_map))
receiver = privtoaddr(receiver_sk)
balance_map[receiver_sk] += value
# not enough transaction fee (gas_price * gas_limit) should not happen for now
assert balance_map[sender_key] >= value + gas_price * 21000
tx = create_transaction(pri_key=sender_key,
receiver=receiver,
value=value,
nonce=nonce,
gas_price=gas_price,
data=data,
gas=gas)
r = random.randint(0, self.num_nodes - 1)
self.nodes[r].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
all_txs.append(tx)
nonce_map[sender_key] = nonce + 1
balance_map[sender_key] -= value + gas_price * gas
self.log.debug(
"New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d nonce:%d",
encode_hex(tx.hash),
eth_utils.encode_hex(privtoaddr(sender_key))[-4:], value,
eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:],
balance_map[sender_key], balance_map[receiver_sk], nonce)
self.log.debug("Send Transaction %s to node %d",
encode_hex(tx.hash), r)
time.sleep(random.random() / 100)
for k in balance_map:
self.log.info("Account %s with balance:%s", bytes_to_int(k),
balance_map[k])
for tx in all_txs:
self.log.debug("Wait for tx to confirm %s", tx.hash_hex())
for i in range(3):
try:
retry = True
while retry:
try:
wait_until(
lambda: checktx(self.nodes[0], tx.hash_hex()),
timeout=120)
retry = False
except CannotSendRequest:
time.sleep(0.01)
break
except AssertionError as _:
self.nodes[0].p2p.send_protocol_msg(
Transactions(transactions=[tx]))
if i == 2:
raise AssertionError(
"Tx {} not confirmed after 30 seconds".format(
tx.hash_hex()))
for k in balance_map:
self.log.info("Check account sk:%s addr:%s", bytes_to_int(k),
eth_utils.encode_hex(privtoaddr(k)))
wait_until(lambda: self.check_account(k, balance_map))
block_gen_thread.stop()
block_gen_thread.join()
sync_blocks(self.nodes)
self.log.info("Pass")
