tree_manager_set_child_value_i64(result, "height", height);
tree_manager_set_child_value_i32(result, "size", size);
tree_manager_set_child_value_hash(result, "hash", block_hash);
tree_manager_set_child_value_i32(result, "confirmations", nblks-height);
tree_manager_set_child_value_i32(result, "time", time);
tree_manager_set_child_value_i32(result, "version", version);
tree_manager_set_child_value_i32(result, "bits", bits);
tree_manager_set_child_value_i32(result, "nonce", nonce);


for (qv = 0; req->query_vars[qv].value.len > 0; qv++)
{
	if (!tree_node_keval_i64(result, &req->query_vars[qv]))
	{
		release_zone_ref(&block);
		return 0;
	}
}

if (testing>0)
	{
		hash_t		lh;
		int			new_len,cur_len;
		
		if (!tree_manager_get_child_value_hash(node, NODE_HASH("last_header_hash"), lh))
			node_get_hash_idx(testing-1, lh);

		tree_manager_create_node			("log", NODE_LOG_PARAMS, &log);
		tree_manager_set_child_value_hash	(&log, "ph", prevHash);
		tree_manager_set_child_value_hash	(&log, "lh", lh);
		log_message							(" testing block '%ph%' -- '%lh%'", &log);
		release_zone_ref					(&log);

		if (memcmp_c(prevHash, lh, sizeof(hash_t)))
		{
			release_zone_ref(&header);
			return 0;
		}

		new_len	=	node_add_block_header(node, &header);
		cur_len	=	get_last_block_height();

		tree_manager_create_node("log", NODE_LOG_PARAMS, &log);
		tree_manager_set_child_value_i32(&log, "new_len", new_len);
		tree_manager_set_child_value_i32(&log, "cur_len", cur_len);
		log_message("testing chain at height : %new_len% - %cur_len%", &log);
		release_zone_ref(&log);

		if (new_len > cur_len)
		{
			mem_zone_ref	last_blk = { PTR_NULL };
			int				n;
			uint64_t		lost_reward;
			
			lost_reward = 0;
			n			= cur_len;
			while ((n--) > testing)
			{
				char		chash[65];
				hash_t		h;
				uint64_t	reward;

				if (!node_get_hash_idx(n, h))continue;

				n = 0; 
				while (n<32)
				{
					chash[n * 2 + 0] = hex_chars[h[n] >> 4];
					chash[n * 2 + 1] = hex_chars[h[n] & 0x0F];
					n++;
				}
				chash[64] = 0;
				
				if (is_pow_block(chash))
					reward=get_blockreward(n);
				else
					get_stake_reward(n, &reward);

				lost_reward += reward;
			}
			
			tree_manager_create_node("log", NODE_LOG_PARAMS, &log);
			tree_manager_set_child_value_i32(&log, "testing", testing);
			log_message("truncate chain to height : %testing%", &log);
			release_zone_ref(&log);

			if(node_truncate_chain(testing))
			{ 
				if (tree_manager_find_child_node(&self_node, NODE_HASH("last pos block"), NODE_BITCORE_BLK_HDR, &last_blk))
				{
					unsigned int		pBits;
					if (compute_last_pos_diff(&last_blk, &pBits))
						tree_manager_set_child_value_i32(&self_node, "current pos diff", pBits);
					else
						tree_manager_set_child_value_i32(&self_node, "current pos diff", 0x1FFFFFFF);

					release_zone_ref(&last_blk);
				}

				sub_moneysupply					(lost_reward);

				log_output						("switching to new chain \n");
				tree_manager_set_child_value_i32(node, "testing_chain", 0);
			}
		}
		release_zone_ref(&header);
		return 0;
	}

	if (!tree_manager_find_child_node(payload, NODE_HASH("txs"), NODE_BITCORE_TX_LIST, &tx_list)){ release_zone_ref(&header); return 1; }
	if (!tree_manager_find_child_node(payload, NODE_HASH("signature"), NODE_BITCORE_ECDSA_SIG, &sig)){ release_zone_ref(&tx_list); release_zone_ref(&header); return 1; }
	tree_manager_get_node_istr(&sig, 0, &signature, 0);
	release_zone_ref(&sig);
	
	ret = node_is_next_block	(&header, &lastBlk);
	if (!ret)
	{
		ret = check_node_chain(node, &header, &keep_block);
		if (!ret)
		{
			free_string(&signature);
			release_zone_ref(&header);
			release_zone_ref(&tx_list);
			return (keep_block==1)?0:1;
		}
	}

launcher rebuildtxs

launcher rebuildsupply