public bool AddBlock(Block blk)
{
if (blk != null && GetBlock(blk.hash) == null)
{
if (!Entity.Root.GetComponent <Consensus>().Check(blk))
{
return(false);
}
using (DbSnapshot snapshot = levelDBStore.GetSnapshot())
{
List <string> list = snapshot.Heights.Get(blk.height.ToString());
if (list == null)
{
list = new List <string>();
}
list.Remove(blk.hash);
list.Add(blk.hash);
snapshot.Heights.Add(blk.height.ToString(), list);
snapshot.Blocks.Add(blk.hash, blk);
snapshot.Commit();
}
}
return(true);
}
public void MinerSave()
{
if (httpPool != null)
{
Dictionary <string, MinerTask> miners = httpPool.GetMinerRewardMin(out long miningHeight);
if (miners != null && miningHeight + 3 < httpPool.height)
{
using (DbSnapshot snapshot = PoolDBStore.GetSnapshot(0, true))
{
string json = snapshot.Get("Pool_H_Miner");
long height_miner = -1;
if (!string.IsNullOrEmpty(json))
{
long.TryParse(json, out height_miner);
}
if (height_miner == -1 || height_miner < miningHeight)
{
snapshot.Add("Pool_H_Miner", miningHeight.ToString());
snapshot.Add("Pool_H2_" + miningHeight, JsonHelper.ToJson(miners));
snapshot.Commit();
httpPool.DelMiner(miningHeight);
}
}
}
}
}
public void DelBlockWithWeight(Consensus consensus, string prehash, long perheight)
{
using (DbSnapshot snapshot = levelDBStore.GetSnapshot())
{
List <Block> blks = GetBlock(perheight + 1);
blks = BlockChainHelper.GetRuleBlk(consensus, blks, prehash);
List <string> list = snapshot.Heights.Get((perheight + 1).ToString());
if (list != null)
{
for (int ii = list.Count - 1; ii >= 0; ii--)
{
if (blks.Find(x => x.hash == list[ii]) == null)
{
snapshot.Blocks.Delete(list[ii]);
cacheDict.Remove(list[ii]);
cacheList.Remove(list[ii]);
list.RemoveAt(ii);
}
}
snapshot.Heights.Add((perheight + 1).ToString(), list);
snapshot.Commit();
}
}
}
public bool ApplyGenesis(Block mcblk)
{
Log.Debug("ApplyGenesis");
using (DbSnapshot dbSnapshot = levelDBStore.GetSnapshotUndo(1))
{
Block linkblk = mcblk;
for (int jj = 0; jj < linkblk.linkstran.Count; jj++)
{
if (!ApplyTransfer(dbSnapshot, linkblk.linkstran[jj], linkblk.height))
{
return(false);
}
if (!ApplyContract(dbSnapshot, linkblk.linkstran[jj], linkblk.height))
{
return(false);
}
}
new BlockChain()
{
hash = mcblk.hash, height = mcblk.height
}.Apply(dbSnapshot);
dbSnapshot.Commit();
}
return(true);
}
public bool AddBlock(Block blk, bool replace = false)
{
if (blk != null && (replace || GetBlock(blk.hash) == null))
{
if (!Entity.Root.GetComponent <Consensus>().Check(blk))
{
Log.Warning($"Block Check Error: {blk.ToStringEx()}");
return(false);
}
using (DbSnapshot snapshot = levelDBStore.GetSnapshot(0, true))
{
List <string> list = snapshot.Heights.Get(blk.height.ToString());
if (list == null)
{
list = new List <string>();
}
list.Remove(blk.hash);
list.Add(blk.hash);
snapshot.Heights.Add(blk.height.ToString(), list);
snapshot.Blocks.Add(blk.hash, blk);
snapshot.Commit();
}
}
return(true);
}
public Dictionary <string, RuleInfo> GetRules(string address, long height, bool bCommit = false)
{
Dictionary <string, RuleInfo> rules = new Dictionary <string, RuleInfo>();
try
{
LuaEnv luaenv = GetLuaEnv(address);
LuaVMCall luaVMCall = new LuaVMCall();
LuaVMScript luaVMScript = null;
LuaVMContext LuaVMContext = null;
using (DbSnapshot dbSnapshot = Entity.Root.GetComponent <LevelDBStore>().GetSnapshot())
{
s_dbSnapshot = dbSnapshot;
LuaVMContext Storages = dbSnapshot?.Storages.Get(address);
// rapidjson待优化，改为直接在C#层调用
luaenv.DoString(initScript);
luaVMScript = dbSnapshot.Contracts.Get(address);
LuaVMContext = dbSnapshot.Storages.Get(address);
luaenv.DoString(luaVMScript.script);
luaenv.DoString($"Storages = rapidjson.decode('{LuaVMContext.jsonData.ToStr()}')\n");
luaVMCall.fnName = "Update";
luaVMCall.args = new FieldParam[0];
object[] args = luaVMCall.args.Select(a => a.GetValue()).ToArray();
LuaFunction luaFun = luaenv.Global.Get <LuaFunction>(luaVMCall.fnName);
luaenv.DoString($"curHeight = {height}\n");
luaFun.Call(args);
// 待优化，改为直接在C#层调用
luaenv.DoString("StoragesJson = rapidjson.encode(Storages)\n");
LuaVMContext.jsonData = luaenv.Global.Get <string>("StoragesJson").ToByteArray();
if (bCommit)
{
dbSnapshot.Storages.Add(address, LuaVMContext);
dbSnapshot.Commit();
}
JToken jdStorages = JToken.Parse(LuaVMContext.jsonData.ToStr());
JToken[] jdRule = jdStorages["Rules"].ToArray();
for (int ii = 0; ii < jdRule.Length; ii++)
{
RuleInfo rule = new RuleInfo();
rule.Address = jdRule[ii]["Address"].ToString();
rule.Start = long.Parse(jdRule[ii]["Start"].ToString());
rule.End = long.Parse(jdRule[ii]["End"].ToString());
rules.Remove(rule.Address);
rules.Add(rule.Address, rule);
}
}
}
catch (Exception e)
{
Log.Debug(e.ToString());
Log.Info("GetRules Error!");
}
return(rules);
}
public void SaveTransferToDB()
{
using (DbSnapshot snapshot = Entity.Root.GetComponent <Pool>().PoolDBStore.GetSnapshot())
{
snapshot.Add($"TransferProcess", JsonHelper.ToJson(transfers));
snapshot.Commit();
}
}
public Block GetMcBlock(long ___height)
{
if (___height <= 1)
{
return(null);
}
try
{
PoolBlock poolBlock = null;
using (DbSnapshot snapshot = pool.PoolDBStore.GetSnapshot())
{
var str = snapshot.Get($"PoolBlock_{___height}");
if (!string.IsNullOrEmpty(str))
{
poolBlock = JsonHelper.FromJson <PoolBlock>(str);
if (poolBlock != null && Wallet.CheckAddress(poolBlock.Address))
{
return(new Block()
{
hash = poolBlock.hash, Address = poolBlock.Address, random = poolBlock.random
});
}
}
}
HttpMessage quest = new HttpMessage();
quest.map = new Dictionary <string, string>();
quest.map.Add("cmd", "GetMcBlock");
quest.map.Add("version", version);
quest.map.Add("height", ___height.ToString());
var result = ComponentNetworkHttp.QueryStringSync($"http://{poolUrl}", quest, 5);
if (string.IsNullOrEmpty(result))
{
return(null);
}
poolBlock = JsonHelper.FromJson <PoolBlock>(result);
if (poolBlock != null && Wallet.CheckAddress(poolBlock.Address))
{
using (DbSnapshot snapshot = pool.PoolDBStore.GetSnapshot())
{
snapshot.Add($"PoolBlock_{___height}", JsonHelper.ToJson(poolBlock));
snapshot.Commit();
}
return(new Block()
{
hash = poolBlock.hash, Address = poolBlock.Address, random = poolBlock.random
});
}
}
catch (Exception)
{
}
return(null);
}
public void ClearOutTimeDB()
{
using (DbSnapshot snapshot = PoolDBStore.GetSnapshot(0, true))
{
string str_Counted = snapshot.Get("Pool_Counted");
long counted = 0;
long.TryParse(str_Counted, out counted);
string str_MR = snapshot.Get($"Pool_MR_{counted-1}");
MinerRewardDB minerRewardLast = null;
if (!string.IsNullOrEmpty(str_MR))
{
minerRewardLast = JsonHelper.FromJson <MinerRewardDB>(str_MR);
}
if (minerRewardLast != null)
{
bool bCommit = false;
int delCount = 5760 * 3;
for (long ii = counted - 2; ii > counted - delCount; ii--)
{
string key = $"Pool_MR_{ii}";
if (!string.IsNullOrEmpty(snapshot.Get(key)))
{
bCommit = true;
snapshot.Delete(key);
}
else
{
break;
}
}
// Miner
for (long ii = minerRewardLast.minHeight; ii > minerRewardLast.minHeight - delCount; ii--)
{
string key = $"Pool_H2_{ii}";
if (!string.IsNullOrEmpty(snapshot.Get(key)))
{
bCommit = true;
snapshot.Delete(key);
}
else
{
break;
}
}
if (bCommit)
{
snapshot.Commit();
}
}
}
}
public static bool Test(string[] args)
{
//
//DBTests tests = new DBTests();
//tests.SetUp();
//tests.Snapshot();
var tempPath = System.IO.Directory.GetCurrentDirectory();
var randName = "LevelDB";
var DatabasePath = System.IO.Path.Combine(tempPath, randName);
LevelDBStore dbstore = new LevelDBStore().Init(DatabasePath);
using (DbSnapshot snapshot = dbstore.GetSnapshot(1))
{
snapshot.Blocks.Add("11", new Block()
{
Address = "11"
});
snapshot.Blocks.Add("22", new Block()
{
Address = "22"
});
var value1 = dbstore.Blocks.Get("11");
var value2 = dbstore.Blocks.Get("22");
snapshot.Commit();
var result1 = dbstore.Blocks.Get("11");
var result2 = dbstore.Blocks.Get("22");
}
using (DbSnapshot snapshot = dbstore.GetSnapshot(1))
{
snapshot.Blocks.Add("11", new Block()
{
Address = "11"
});
snapshot.Blocks.Add("22", new Block()
{
Address = "22"
});
var value1 = dbstore.Blocks.Get("11");
var value2 = dbstore.Blocks.Get("22");
snapshot.Commit();
var result1 = dbstore.Blocks.Get("11");
var result2 = dbstore.Blocks.Get("22");
}
return(true);
}
public void DelBlock(long height)
{
using (DbSnapshot snapshot = levelDBStore.GetSnapshot(0, true))
{
List <string> list = snapshot.Heights.Get(height.ToString());
if (list != null)
{
for (int ii = 0; ii < list.Count; ii++)
{
snapshot.Blocks.Delete(list[ii]);
blockCache.Remove(list[ii]);
}
snapshot.Heights.Delete(height.ToString());
}
snapshot.Commit();
}
}
public void DelBlock(string hash)
{
using (DbSnapshot snapshot = levelDBStore.GetSnapshot(0, true))
{
Block blk = snapshot.Blocks.Get(hash);
if (blk != null)
{
List <string> list = snapshot.Heights.Get(blk.height.ToString());
if (list != null)
{
list.Remove(blk.hash);
snapshot.Heights.Add(blk.height.ToString(), list);
}
}
snapshot.Blocks.Delete(hash);
snapshot.Commit();
}
}
public void ClearOutTimeDB()
{
using (DbSnapshot snapshot = PoolDBStore.GetSnapshot())
{
// Miner
string json = snapshot.Get("Pool_H_Miner");
long height_miner = -1;
if (!string.IsNullOrEmpty(json))
{
long.TryParse(json, out height_miner);
}
for (long ii = OutTimeDBMiner; ii < OutTimeDBMiner * 3; ii++)
{
string key = "Pool_H_" + (height_miner - ii);
if (!string.IsNullOrEmpty(snapshot.Get(key)))
{
snapshot.Delete("Pool_H_" + (height_miner - ii));
}
else
{
break;
}
}
long counted = 0;
string str_Counted = snapshot.Get("Pool_Counted");
long.TryParse(str_Counted, out counted);
for (long ii = OutTimeDBCounted; ii < OutTimeDBCounted * 3; ii++)
{
long index = counted - ii;
if (!string.IsNullOrEmpty(snapshot.Get($"Pool_MR_{index}")))
{
snapshot.Delete($"Pool_MR_{index}");
snapshot.Delete($"Pool_MT_{index}");
}
else
{
break;
}
}
snapshot.Commit();
}
}
public override void Start()
{
rule = Entity.Root.GetComponent <Rule>();
ComponentNetMsg componentNetMsg = Entity.Root.GetComponent <ComponentNetMsg>();
componentNetMsg.registerMsg(NetOpcode.P2P_NewBlock, P2P_NewBlock_Handle);
string genesisText = File.ReadAllText("./Data/genesisBlock.dat");
Block blk = JsonHelper.FromJson <Block>(genesisText);
superAddress = blk.Address;
long.TryParse(Entity.Root.GetComponent <LevelDBStore>().Get("UndoHeight"), out long UndoHeight);
if (UndoHeight == 0)
{
if (true)
{
blockMgr.AddBlock(blk);
ApplyGenesis(blk);
}
}
string consData = Base58.Encode(FileHelper.GetFileData("./Data/Contract/RuleContract_v1.0.lua").ToByteArray());
consAddress = Wallet.ToAddress(CryptoHelper.Sha256(Encoding.UTF8.GetBytes(consData)));
using (DbSnapshot snapshot = levelDBStore.GetSnapshot())
{
LuaVMScript luaVMScript = new LuaVMScript()
{
script = FileHelper.GetFileData("./Data/Contract/RuleContract_curr.lua").ToByteArray()
};
snapshot.Contracts.Add(consAddress, luaVMScript);
snapshot.Commit();
}
ruleInfos = luaVMEnv.GetRules(consAddress, UndoHeight);
if (bRun)
{
Run();
}
}
public static void test_delete(string[] args)
{
var tempPath = System.IO.Directory.GetCurrentDirectory();
var randName = "LevelDB";
var DatabasePath = System.IO.Path.Combine(tempPath, randName);
LevelDBStore dbstore = new LevelDBStore().Init(DatabasePath);
using (DbSnapshot snapshot = dbstore.GetSnapshot(1))
{
snapshot.Blocks.Add("11", new Block()
{
Address = "11"
});
snapshot.Blocks.Add("22", new Block()
{
Address = "22"
});
var value1 = dbstore.Blocks.Get("11");
var value2 = dbstore.Blocks.Get("22");
System.Console.WriteLine($"dbstore.test_delete value1: {value1}");
snapshot.Commit();
var result1 = dbstore.Blocks.Get("11");
var result2 = dbstore.Blocks.Get("22");
System.Console.WriteLine($"dbstore.test_delete value1: {result1}");
}
using (DbSnapshot snapshot = dbstore.GetSnapshot(1))
{
snapshot.Blocks.Delete("11");
snapshot.Blocks.Delete("22");
snapshot.Commit();
var result1 = dbstore.Blocks.Get("11");
var result2 = dbstore.Blocks.Get("22");
System.Console.WriteLine($"dbstore.test_delete value1: {result1}");
}
}
public bool ApplyHeight(BlockChain blockChain)
{
if (blockChain == null)
{
return(false);
}
// 应用高度不是下一高度
long.TryParse(levelDBStore.Get("UndoHeight"), out transferHeight);
if (blockChain.height - 1 != transferHeight)
{
return(false);
}
Block mcblk = blockChain.GetMcBlock();
if (mcblk == null)
{
return(false);
}
Block preblk = BlockChainHelper.GetMcBlock(transferHeight);
if (mcblk.prehash != preblk.hash)
{
return(false);
}
LuaVMEnv luaVMEnv = Entity.Root.GetComponent <LuaVMEnv>();
ruleInfos = luaVMEnv.GetRules(consAddress, transferHeight);
// --------------------------------------------------
calculatePower.Insert(mcblk);
//Log.Debug($"ApplyHeight={blockChain.height}, {calculatePower.GetPower()}, {mcblk.GetDiff()}");
using (DbSnapshot dbSnapshot = levelDBStore.GetSnapshotUndo(blockChain.height))
{
blockChain.Apply(dbSnapshot);
ApplyReward(dbSnapshot, mcblk);
if (GetRuleCount(mcblk.height - 1, 2) >= 2 && BlockChainHelper.IsIrreversible(this, mcblk))
{
dbSnapshot.Add("2F1Height", mcblk.height.ToString());
}
// 连接块交易
for (int ii = 0; ii < mcblk.linksblk.Count; ii++)
{
Block linkblk = blockMgr.GetBlock(mcblk.linksblk[ii]);
if (linkblk == null)
{
return(false);
}
if (linkblk.height != 1)
{
for (int jj = 0; jj < linkblk.linkstran.Count; jj++)
{
if (!ApplyTransfer(dbSnapshot, linkblk.linkstran[jj], linkblk.height))
{
return(false);
}
if (!ApplyContract(dbSnapshot, linkblk.linkstran[jj], linkblk.height))
{
return(false);
}
}
}
}
dbSnapshot.Commit();
}
ruleInfos = luaVMEnv.GetRules(consAddress, mcblk.height, true);
return(true);
}
public Dictionary <string, BlockSub> MinerReward_PPLNS(bool saveDB = true)
{
var today = DateTime.UtcNow.ToString("yyyy-MM-dd");
long counted = 0;
long minHeight = -1;
long maxHeight = -1;
using (DbSnapshot snapshot = PoolDBStore.GetSnapshot())
{
string str_Counted = snapshot.Get("Pool_Counted");
long.TryParse(str_Counted, out counted);
string str_MR = snapshot.Get($"Pool_MR_{str_Counted}");
MinerRewardDB minerRewardLast = null;
if (!string.IsNullOrEmpty(str_MR))
{
minerRewardLast = JsonHelper.FromJson <MinerRewardDB>(str_MR);
}
if (minerRewardLast == null)
{
snapshot.Add("Pool_Counted", "0");
var minerRewardNew = new MinerRewardDB();
minerRewardNew.counted = 0;
minerRewardNew.minHeight = httpPool.height;
minerRewardNew.maxHeight = httpPool.height;
minerRewardNew.time = TimeHelper.time.ToString();
snapshot.Add($"Pool_MR_{0}", JsonHelper.ToJson(minerRewardNew));
snapshot.Commit();
return(null);
}
minHeight = minerRewardLast.maxHeight;
string json = snapshot.Get("Pool_H_Miner");
if (!string.IsNullOrEmpty(json))
{
long.TryParse(json, out maxHeight);
}
}
if (maxHeight - minHeight < RewardInterval && saveDB)
{
return(null);
}
var minerTransfer = MinerReward_PPLNS(today, minHeight, maxHeight);
if (saveDB)
{
using (DbSnapshot snapshot = PoolDBStore.GetSnapshot())
{
foreach (var it in minerTransfer)
{
transferProcess.AddTransferHandle(it.Value.addressIn, it.Value.addressOut, it.Value.amount, it.Value.data);
}
counted += 1;
snapshot.Add("Pool_Counted", counted.ToString());
var minerRewardNew = new MinerRewardDB();
minerRewardNew.counted = counted;
minerRewardNew.minHeight = minHeight;
minerRewardNew.maxHeight = maxHeight;
minerRewardNew.time = DateTime.UtcNow.Ticks.ToString();
snapshot.Add($"Pool_MR_{counted}", JsonHelper.ToJson(minerRewardNew));
// Pool_MT
var depend = new DateTime(DateTime.UtcNow.Ticks, DateTimeKind.Utc).ToString("yyyy-MM-dd HH:mm:ss");
foreach (var it in minerTransfer)
{
it.Value.depend = depend;
snapshot.Queue.Push($"Pool_MT_{it.Value.addressOut}", JsonHelper.ToJson(it.Value));
}
snapshot.Commit();
}
transferProcess.SaveTransferToDB();
}
return(minerTransfer);
}
public void ThreadRun(object data)
{
System.Threading.Thread.Sleep(1000);
// check url
rulerRpc = rulerRpc ?? Entity.Root.Find("SmartxRpc")?.GetComponent <SmartxRpc>()?.GetIPEndPoint();
if (httpPoolRelay != null && GetHeight(rulerRpc, 5) == 0)
{
Log.Error($"rulerRpc: {rulerRpc} can't connect");
System.Diagnostics.Process.GetCurrentProcess().Kill();
return;
}
LoadTransferFromDB();
List <TransferHandle> transfersDel = new List <TransferHandle>();
Dictionary <string, Account> accounts = new Dictionary <string, Account>();
var timePassInfo = new TimePass(15 * 6);
while (true)
{
System.Threading.Thread.Sleep(1000);
// Query success
try
{
lock (this)
{
if (runAction != null)
{
runAction?.Invoke();
runAction = null;
SaveTransferToDB();
}
}
if (!timePassInfo.IsPassSet())
{
continue;
}
transfersDel.Clear();
for (int ii = 0; ii < transfers.Count; ii++)
{
if (transfers[ii].sendCount <= 5)
{
if (string.IsNullOrEmpty(transfers[ii].unique))
{
transfersDel.Add(transfers[ii]);
continue;
}
var transfer = GetUniqueTransfer(rulerRpc, transfers[ii].unique);
if (transfer != null)
{
if (transfer.data == transfers[ii].unique && transfer.height != 0)
{
transfers[ii].hash = transfer.hash;
transfersDel.Add(transfers[ii]);
}
}
}
else
{
File.AppendAllText("./TransferBad.csv", JsonHelper.ToJson(transfers[ii]) + "\n", Encoding.UTF8);
transfersDel.Add(transfers[ii]);
}
}
using (DbSnapshot snapshot = Entity.Root.GetComponent <Pool>().PoolDBStore.GetSnapshot())
{
bool remove = transfersDel.Count != 0;
// Successfully deleted from table
foreach (var it in transfersDel)
{
if (!string.IsNullOrEmpty(it.unique) && !string.IsNullOrEmpty(it.hash))
{
snapshot.Add($"unique_{it.unique}", it.hash); // Add to transaction cross reference table
}
transfers.Remove(it);
}
if (remove)
{
snapshot.Commit();
}
}
accounts.Clear();
long curHeight = GetHeight(rulerRpc);
if (curHeight == 0)
{
Log.Warning($"rulerRpc: {rulerRpc} can't connect");
continue;
}
// Start a new deal
bool bSaveDb = false;
for (int ii = transfers.Count - 1; ii >= 0; ii--)
{
if (transfers[ii].lastHeight < curHeight - 18 && transfers[ii].sendCount <= 5)
{
transfers[ii].lastHeight = curHeight;
transfers[ii].sendCount++;
if (BigHelper.Less(transfers[ii].amount, "0", true))
{
transfers.RemoveAt(ii);
continue;
}
Account account = null;
if (!accounts.TryGetValue(transfers[ii].addressIn, out account))
{
account = GetAccount(rulerRpc, transfers[ii].addressIn);
if (account == null)
{
continue;
}
accounts.Add(transfers[ii].addressIn, account);
}
BlockSub transfer = new BlockSub();
transfer.addressIn = transfers[ii].addressIn;
transfer.addressOut = transfers[ii].addressOut;
transfer.amount = transfers[ii].amount;
transfer.type = "transfer";
transfer.nonce = ++account.nonce;
transfer.timestamp = TimeHelper.Now();
transfer.data = transfers[ii].unique;
transfer.extend = new List <string>();
//transfer.extend.Add($"deadline:{curHeight + 16}");
transfer.extend.Add($"unique");
transfer.hash = transfer.ToHash();
transfer.sign = transfer.ToSign(Wallet.GetWallet().GetCurWallet());
//int rel = Entity.Root.GetComponent<Rule>().AddTransfer(transfer, false);
int rel = SendTransfer(rulerRpc, transfer);
if (rel == -1)
{
transfers[ii].sendCount--;
continue;
}
if (rel != 1)
{
File.AppendAllText("./TransferBad.csv", JsonHelper.ToJson(transfers[ii]) + "\n", Encoding.UTF8);
Log.Error($"TransferProcess: aAddTransfer Error! {rel}");
transfers.RemoveAt(ii);
}
bSaveDb = true;
}
}
if (bSaveDb)
{
SaveTransferToDB();
}
}
catch (Exception)
{
Log.Warning($"TransferProcess throw Exception: {rulerRpc}");
}
}
}
static public void MakeSnapshot(Dictionary <string, string> param)
{
Console.WriteLine($"levelDB.Init {param["db"]}");
LevelDBStore levelDB = new LevelDBStore();
levelDB.Init(param["db"]);
if (param.ContainsKey("height") && long.TryParse(param["height"], out long height))
{
levelDB.UndoTransfers(height);
}
long.TryParse(levelDB.Get("UndoHeight"), out long transferHeight);
Console.WriteLine($"transferHeight: {transferHeight}");
var DatabasePath = $"./Data/LevelDB_Snapshot_{transferHeight}";
if (Directory.Exists(DatabasePath))
{
Console.WriteLine($"Directory LevelDB_Snapshot Exists");
return;
}
LevelDBStore snapshotDB = new LevelDBStore();
snapshotDB.Init(DatabasePath);
int count = 0;
using (var it = levelDB.db.CreateIterator())
{
for (it.SeekToFirst(); it.IsValid(); it.Next(), count++)
{
//Log.Info($"Value as string: {it.KeyAsString()}");
if (it.KeyAsString().IndexOf("_undo_") == -1 &&
it.KeyAsString().IndexOf("Blocks") != 0 &&
it.KeyAsString().IndexOf("BlockChain") != 0 &&
it.KeyAsString().IndexOf("Queue") != 0 &&
it.KeyAsString().IndexOf("List") != 0 &&
it.KeyAsString().IndexOf("Heights") != 0 &&
it.KeyAsString().IndexOf("Undos___") != 0)
{
if (it.KeyAsString().IndexOf("Trans___") == 0)
{
var slice = JsonHelper.FromJson <DbCache <BlockSub> .Slice>(it.ValueAsString());
if (slice != null && slice.obj.height != 0)
{
snapshotDB.Put(it.KeyAsString(), $"{{\"obj\":{{\"height\":{slice.obj.height}}}}}");
Console.WriteLine($"Processed tran: {it.KeyAsString()}");
}
}
else
if (it.KeyAsString().IndexOf("Snap___") == 0)
{
if (it.KeyAsString().IndexOf("Snap___Rule_") == 0)
{
var key = it.KeyAsString();
var pos1 = "Snap___Rule_".Length;
var pos2 = key.Length;
var hegihtTemp1 = key.Substring(pos1, pos2 - pos1);
var hegihtTemp2 = long.Parse(hegihtTemp1);
if (hegihtTemp2 > transferHeight - 5 && hegihtTemp2 < transferHeight + 5)
{
snapshotDB.Put(it.KeyAsString(), it.ValueAsString());
Console.WriteLine($"Processed key: {it.KeyAsString()}");
}
}
else
if (it.KeyAsString().IndexOf("_Reward") != -1)
{
var key = it.KeyAsString();
var pos1 = "Snap___".Length;
var pos2 = key.IndexOf("_Reward");
var hegihtTemp1 = key.Substring(pos1, pos2 - pos1);
var hegihtTemp2 = long.Parse(hegihtTemp1);
if (hegihtTemp2 > transferHeight - 5 && hegihtTemp2 < transferHeight + 5)
{
snapshotDB.Put(it.KeyAsString(), it.ValueAsString());
Console.WriteLine($"Processed key: {it.KeyAsString()}");
}
}
else
{
snapshotDB.Put(it.KeyAsString(), it.ValueAsString());
Console.WriteLine($"Processed key: {it.KeyAsString()}");
}
}
else
{
snapshotDB.Put(it.KeyAsString(), it.ValueAsString());
Console.WriteLine($"Processed key: {it.KeyAsString()}");
}
}
if (count % 1000000 == 0)
{
Console.WriteLine($"Processed Count:{count}");
}
}
}
using (DbSnapshot dbNew = snapshotDB.GetSnapshot(0, true))
using (DbSnapshot dbOld = levelDB.GetSnapshot())
{
for (long ii = transferHeight - 3; ii <= transferHeight + 2; ii++)
{
Console.WriteLine($"Processed height: {ii}");
var heights = dbOld.Heights.Get(ii.ToString());
for (int jj = 0; jj < heights.Count; jj++)
{
dbNew.Blocks.Add(heights[jj], dbOld.Blocks.Get(heights[jj]));
}
dbNew.Heights.Add(ii.ToString(), heights);
dbNew.BlockChains.Add(ii.ToString(), dbOld.BlockChains.Get(ii.ToString()));
}
dbNew.Commit();
}
Console.WriteLine($"MakeSnapshot Complete");
while (true)
{
System.Threading.Thread.Sleep(1000);
}
}
public void DelBlockWithHeight(Consensus consensus, long start)
{
//Log.Info($"DelBlockWithHeight {start} {start + 4}");
using (DbSnapshot snapshot = levelDBStore.GetSnapshot(0, true))
{
bool bCommit = false;
for (long height = start; height <= start + 4; height++)
{
List <string> list = snapshot.Heights.Get(height.ToString());
if (list == null || list.Count <= 100)
{
continue;
}
var blks = GetBlock(height);
var blksMap = new Dictionary <string, Block>();
var ruleBlks = consensus.GetRule(height);
foreach (var ruleinfo in ruleBlks.Values)
{
for (int ii = 0; ii < blks.Count; ii++)
{
if (blksMap.TryGetValue(blks[ii].Address, out Block blkr))
{
if (blkr.timestamp > blks[ii].timestamp)
{
blksMap.Remove(blks[ii].Address);
blksMap.Add(blks[ii].Address, blks[ii]);
}
else if (blkr.timestamp == blks[ii].timestamp && blkr.hash.CompareTo(blks[ii].hash) < 0)
{
blksMap.Remove(blks[ii].Address);
blksMap.Add(blks[ii].Address, blks[ii]);
}
}
else
{
blksMap.Add(blks[ii].Address, blks[ii]);
}
}
}
var blkRules = blksMap.Values.ToList();
if (list != null)
{
for (int ii = blks.Count - 1; ii >= 0; ii--)
{
bool syncFlag = false;
if (blks[ii].temp != null)
{
syncFlag = blks[ii].temp.Find(x => x == "SyncFlag") != null;
}
if (blks.Find(x => x.hash == list[ii]) == null && !syncFlag)
{
list.RemoveAt(ii);
bCommit = true;
}
}
snapshot.Heights.Add(height.ToString(), list);
}
}
if (bCommit)
{
snapshot.Commit();
}
}
}
public Dictionary <string, BlockSub> MinerReward(bool saveDB = true)
{
long counted = 0;
long minHeight = -1;
long maxHeight = -1;
using (DbSnapshot snapshot = PoolDBStore.GetSnapshot(0, true))
{
string str_Counted = snapshot.Get("Pool_Counted");
long.TryParse(str_Counted, out counted);
string str_MR = snapshot.Get($"Pool_MR_{str_Counted}");
MinerRewardDB minerRewardLast = null;
if (!string.IsNullOrEmpty(str_MR))
{
minerRewardLast = JsonHelper.FromJson <MinerRewardDB>(str_MR);
}
if (minerRewardLast == null)
{
if (httpPool.height <= 2) // 还没有获取到最新高度
{
return(null);
}
snapshot.Add("Pool_Counted", "0");
var minerRewardNew = new MinerRewardDB();
minerRewardNew.counted = 0;
minerRewardNew.minHeight = httpPool.height;
minerRewardNew.maxHeight = httpPool.height;
minerRewardNew.time = TimeHelper.time.ToString();
snapshot.Add($"Pool_MR_{0}", JsonHelper.ToJson(minerRewardNew));
snapshot.Commit();
return(null);
}
minHeight = minerRewardLast.maxHeight;
string json = snapshot.Get("Pool_H_Miner");
if (!string.IsNullOrEmpty(json))
{
long.TryParse(json, out maxHeight);
}
}
// 超过一天的数据忽略
if (maxHeight - minHeight > 5760)
{
Log.Warning($"MinerReward maxHeight - minHeight > 5760, {maxHeight} - {minHeight} = {maxHeight - minHeight}");
}
// 设置步长
if (maxHeight - minHeight >= RewardInterval)
{
maxHeight = minHeight + RewardInterval;
runSleep = saveDB ? 10 : runSleep; // 加快处理速度
}
// 缓存===========================================================================
Dictionary <string, BlockSub> minerTransferCache = null;
if (MinerReward_TimePass.IsPassSet())
{
minerTransferCache = MinerReward(false);
if (minerTransferCache != null)
{
using (DbSnapshot snapshot = PoolDBStore.GetSnapshot(0, true))
{
snapshot.Add($"Pool_Cache_MinerReward", JsonHelper.ToJson(minerTransferCache));
snapshot.Commit();
}
}
}
// ===============================================================================
if (maxHeight - minHeight < RewardInterval && saveDB)
{
runSleep = 7500;
return(null);
}
Dictionary <string, BlockSub> minerTransfer = null;
if (style == "PPLNS")
{
minerTransfer = minerTransferCache ?? GetMinerReward_PPLNS(minHeight, maxHeight);
}
if (style == "SOLO")
{
minerTransfer = minerTransferCache ?? GetMinerReward_SOLO(minHeight, maxHeight);
}
if (saveDB)
{
foreach (var it in minerTransfer)
{
transferProcess.AddTransferHandle(it.Value.addressIn, it.Value.addressOut, it.Value.amount, it.Value.data);
}
using (DbSnapshot snapshot = PoolDBStore.GetSnapshot(0, true))
{
counted += 1;
snapshot.Add("Pool_Counted", counted.ToString());
var minerRewardNew = new MinerRewardDB();
minerRewardNew.counted = counted;
minerRewardNew.minHeight = minHeight;
minerRewardNew.maxHeight = maxHeight;
minerRewardNew.time = DateTime.Now.Ticks.ToString();
snapshot.Add($"Pool_MR_{counted}", JsonHelper.ToJson(minerRewardNew));
// Pool_MT
var depend = new DateTime(DateTime.Now.Ticks).ToString("yyyy-MM-dd HH:mm:ss");
foreach (var it in minerTransfer)
{
it.Value.depend = depend;
snapshot.Queue.Push($"Pool_MT_{it.Value.addressOut}", JsonHelper.ToJson(it.Value));
}
snapshot.Commit();
}
}
return(minerTransfer);
}
public static void test_undo(string[] args)
{
System.Console.WriteLine($"test_undo ...");
//
//DBTests tests = new DBTests();
//tests.SetUp();
//tests.Snapshot();
var tempPath = System.IO.Directory.GetCurrentDirectory();
var randName = "LevelDB";
var DatabasePath = System.IO.Path.Combine(tempPath, randName);
LevelDBStore dbstore = new LevelDBStore().Init(DatabasePath);
for (int rr = 1; rr <= 30; rr++)
{
long.TryParse(dbstore.Get("UndoHeight"), out long UndoHeight);
int random1 = 1000 + RandomHelper.Random() % 1000;
if (UndoHeight < random1)
{
for (long i = UndoHeight + 1; i <= random1; i++)
{
using (DbSnapshot snapshot = dbstore.GetSnapshot(i))
{
snapshot.Transfers.Add("undos_test", new BlockSub()
{
hash = $"Address_{i}"
});
snapshot.Commit();
}
}
}
{
using (DbSnapshot snapshot = dbstore.GetSnapshot(0))
{
var result1 = snapshot.Transfers.Get("undos_test");
long.TryParse(dbstore.Get("UndoHeight"), out long UndoHeight2);
if (result1.hash != $"Address_{UndoHeight2.ToString()}")
{
System.Console.WriteLine($"dbstore.Undo {random1} error1: {result1.hash}");
}
//System.Console.WriteLine($"dbstore.Undo {random1} error1: {result1.txid}");
}
}
if (UndoHeight > random1)
{
dbstore.UndoTransfers(random1);
}
using (DbSnapshot snapshot = dbstore.GetSnapshot(0))
{
var result2 = snapshot.Transfers.Get("undos_test");
long.TryParse(dbstore.Get("UndoHeight"), out long UndoHeight2);
if (result2.hash != $"Address_{UndoHeight2.ToString()}")
{
System.Console.WriteLine($"dbstore.Undo {random1} error2: {result2.hash}");
}
//System.Console.WriteLine($"dbstore.Undo {random1} error2: {result2.txid}");
}
}
}
public async void Run()
{
await Task.Delay(1000);
LoadTransferFromDB();
List <TransferHandle> transfersDel = new List <TransferHandle>();
var rule = Entity.Root.GetComponent <Rule>();
while (true)
{
await Task.Delay(15000 * 6);
// Query success
using (var dbSnapshot = Entity.Root.GetComponent <LevelDBStore>().GetSnapshot(0))
{
transfersDel.Clear();
for (int ii = 0; ii < transfers.Count; ii++)
{
if (transfers[ii].sendCount <= 5)
{
string hasht = dbSnapshot.Get($"unique_{transfers[ii].unique}");
if (!string.IsNullOrEmpty(hasht))
{
var transfer = dbSnapshot.Transfers.Get(hasht);
if (transfer != null)
{
if (transfer.data == transfers[ii].unique)
{
transfers[ii].hash = hasht;
transfersDel.Add(transfers[ii]);
}
}
}
}
else
{
transfersDel.Add(transfers[ii]);
}
}
using (DbSnapshot snapshot = Entity.Root.GetComponent <Pool>().PoolDBStore.GetSnapshot())
{
bool remove = transfersDel.Count != 0;
// Successfully deleted from table
foreach (var it in transfersDel)
{
if (!string.IsNullOrEmpty(it.unique) && !string.IsNullOrEmpty(it.hash))
{
snapshot.Add($"unique_{it.unique}", it.hash); // Add to transaction cross reference table
}
transfers.Remove(it);
}
if (remove)
{
snapshot.Commit();
}
}
// Start a new deal
for (int ii = transfers.Count - 1; ii >= 0; ii--)
{
if (transfers[ii].lastHeight < rule.height + 6 && transfers[ii].sendCount <= 5)
{
transfers[ii].lastHeight = rule.height;
transfers[ii].sendCount++;
var account = dbSnapshot.Accounts.Get(transfers[ii].addressIn);
BlockSub transfer = new BlockSub();
transfer.addressIn = transfers[ii].addressIn;
transfer.addressOut = transfers[ii].addressOut;
transfer.amount = transfers[ii].amount;
transfer.type = "transfer";
transfer.nonce = ++account.nonce;
transfer.timestamp = TimeHelper.Now();
transfer.data = transfers[ii].unique;
transfer.hash = transfer.ToHash();
transfer.sign = transfer.ToSign(Wallet.GetWallet().GetCurWallet());
dbSnapshot.Accounts.Add(transfers[ii].addressIn, account); // account.nonce Count accumulation
int rel = Entity.Root.GetComponent <Rule>().AddTransfer(transfer);
if (rel != 1)
{
Log.Error($"TransferProcess: aAddTransfer Error! {transfers[ii]}");
transfers.RemoveAt(ii);
}
}
}
}
}
}