def METHOD_NAME(seq=[]):
    global nodes, all_stakes, sequence
    sequence = seq
    config = None
    nodes = start_cluster(
        2, 1, 1, config, [["epoch_length", EPOCH_LENGTH],
                          ["block_producer_kickout_threshold", 40],
                          ["chunk_producer_kickout_threshold", 40]], {
                              0: {
                                  "view_client_throttle_period": {
                                      "secs": 0,
                                      "nanos": 0
                                  },
                                  "consensus": {
                                      "state_sync_timeout": {
                                          "secs": 2,
                                          "nanos": 0
                                      }
                                  }
                              },
                              1: {
                                  "view_client_throttle_period": {
                                      "secs": 0,
                                      "nanos": 0
                                  },
                                  "consensus": {
                                      "state_sync_timeout": {
                                          "secs": 2,
                                          "nanos": 0
                                      }
                                  }
                              },
                              2: {
                                  "tracked_shards": [0],
                                  "view_client_throttle_period": {
                                      "secs": 0,
                                      "nanos": 0
                                  },
                                  "consensus": {
                                      "state_sync_timeout": {
                                          "secs": 2,
                                          "nanos": 0
                                      }
                                  },
                                  "store.state_snapshot_enabled": True,
                              }
                          })
    started = time.time()
    last_iter = started
    height, hash_ = nodes[2].get_latest_block()
    for i in range(3):
        nodes[i].stop_checking_store()
    logger.info("Initial stakes: %s" % get_stakes())
    all_stakes.append(get_stakes())
    do_moar_stakes(hash_, True)
    last_fake_stakes_height = FAKE_OFFSET
    last_staked_height = REAL_OFFSET
    while True:
        if time.time() - started >= TIMEOUT:
            break
        assert time.time() - last_iter < TIMEOUT_PER_ITER
        height, hash_ = nodes[0].get_latest_block()
        logging.info(
            f"Node 0 at height {height}; time since last staking iteration: {time.time() - last_iter} seconds"
        )
        send_fakes = send_reals = False
        if (height + EPOCH_LENGTH - FAKE_OFFSET) // EPOCH_LENGTH > (
                last_fake_stakes_height + EPOCH_LENGTH -
                FAKE_OFFSET) // EPOCH_LENGTH:
            last_iter = time.time()
            send_fakes = True
        if (height + EPOCH_LENGTH - REAL_OFFSET) // EPOCH_LENGTH > (
                last_staked_height + EPOCH_LENGTH -
                REAL_OFFSET) // EPOCH_LENGTH:
            send_reals = True
        if send_fakes or send_reals:
            cur_stakes = get_stakes()
            logger.info("Current stakes: %s" % cur_stakes)
            if len(all_stakes) > 1:
                expected_stakes = get_expected_stakes()
                logger.info("Expect  stakes: %s" % expected_stakes)
                for (cur, expected) in zip(cur_stakes, expected_stakes):
                    if cur % 1000000 == 0:
                        assert cur == expected
                    else:
                        assert expected <= cur <= expected * 1.1
            do_moar_stakes(hash_, update_expected=send_reals)
        if send_fakes:
            last_fake_stakes_height += EPOCH_LENGTH
        elif send_reals:
            last_staked_height += EPOCH_LENGTH
        time.sleep(1)