def METHOD_NAME(self):
    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]
        rpc_clients = list(map(lambda node: RpcClient(node, log=self.log), shard_nodes))
        # 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)
        rpc_clients[0].send_tx(tx, wait_for_receipt=True)
        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)
            rpc_clients[0].send_tx(tx, wait_for_receipt=True)
            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)
        # make sure all nodes have sync all accounts and latest state
        sync_blocks(shard_nodes)
        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)
            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)
            rpc_clients[r].send_tx(tx, wait_for_receipt=True)
            nonce_map[sender_key] = nonce + 1
            balance_map[sender_key] -= value + gas_price * 21000
            time.sleep(random.random() / 10)
        sync_blocks(shard_nodes)
        rpc_clients[0].generate_blocks_to_state()
        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)
    # generate new blocks to trigger block sync.
    self.nodes[0].generate_empty_blocks(100)
    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")