void DispatchBlock()
{
try
{
_Hasher.Pause("dispatching block");
MinerTrace.Information($"dispatching block with {_ValidatedTxs.Count()} txs");
var txs = FSharpList <Types.Transaction> .Cons(_Coinbase, ListModule.OfSeq(_ValidatedTxs.Select(TransactionValidation.unpoint)));
var block = new Types.Block(_Header, txs);
var result = new HandleBlockAction(block).Publish().Result.BkResultEnum;
if (result == BlockVerificationHelper.BkResultEnum.Accepted)
{
if (OnMined != null)
{
OnMined(block);
}
}
else
{
Reset();
}
MinerTrace.Information($" block {block.header.blockNumber} is " + result);
} catch (Exception e)
{
MinerTrace.Error("Dispatch block exception", e);
}
}
void HandleTx(TransactionValidation.PointedTransaction ptx)
{
//TODO: try simplify using hash from message
var txHash = Merkle.transactionHasher.Invoke(TransactionValidation.unpoint(ptx));
var activationSacrifice = 0UL;
for (var i = 0; i < ptx.outputs.Length; i++)
{
var output = ptx.outputs[i];
if ([email protected])
{
if (!output.spend.asset.SequenceEqual(Tests.zhash))
{
continue; // not Zen
}
var contractSacrificeLock = (Types.OutputLock.ContractSacrificeLock)output.@lock;
if (contractSacrificeLock.IsHighVLock)
{
continue; // not current version
}
if (contractSacrificeLock.Item.lockData.Length == 0)
{
activationSacrifice += output.spend.amount;
}
}
//todo: fix to exclude CSLocks&FLocks, instead of including by locktype
if ([email protected] || [email protected])
{
var outpoint = new Types.Outpoint(txHash, (uint)i);
_UtxoSet.Add(new Tuple <Types.Outpoint, Types.Output>(outpoint, output));
}
}
if (FSharpOption <Types.ExtendedContract> .get_IsSome(ptx.contract) && !ptx.contract.Value.IsHighVContract)
{
var codeBytes = ((Types.ExtendedContract.Contract)ptx.contract.Value).Item.code;
var contractHash = Merkle.innerHash(codeBytes);
var contractCode = System.Text.Encoding.ASCII.GetString(codeBytes);
if (!_ActiveContracts.Contains(contractHash))
{
if (activationSacrifice > ActiveContractSet.KalapasPerBlock(contractCode))
{
try
{
var compiledCodeOpt = ContractExamples.FStarExecution.compile(contractCode);
if (FSharpOption <byte[]> .get_IsSome(compiledCodeOpt))
{
_ActiveContracts.Add(contractHash);
}
}
catch (Exception e)
{
MinerTrace.Error("Could not compile contract " + Convert.ToBase64String(contractHash), e);
}
}
}
}
}
bool IsTransactionValid(TransactionValidation.PointedTransaction ptx)
{
if (!HasUtxos(ptx))
{
MinerTrace.Information("could not validate tx - utxo missing");
return(false);
}
var utxoLookup = UtxoLookup.FromConverter(outpoint =>
{
var outputs = _UtxoSet.Where(t => t.Item1.Equals(outpoint)).Select(t => t.Item2);
return(!outputs.Any() ? FSharpOption <Types.Output> .None : new FSharpOption <Types.Output>(outputs.First()));
});
var contractLookup = FSharpFunc <byte[], FSharpOption <ContractFunction> > .FromConverter(contractHash =>
{
if (!_ActiveContracts.Contains(contractHash))
{
return(FSharpOption <ContractFunction> .None);
}
try
{
var code = new GetContractCodeAction(contractHash).Publish().Result;
//TODO: module name
var extration = ContractExamples.FStarExecution.extract(System.Text.Encoding.ASCII.GetString(code));
if (FSharpOption <string> .get_IsNone(extration))
{
MinerTrace.Information("Could not extract contract");
return(null);
}
var compilation = ContractExamples.FStarExecution.compile(extration.Value);
if (FSharpOption <byte[]> .get_IsNone(compilation))
{
MinerTrace.Information("Could not complie contract");
return(null);
}
return(ContractExamples.FStarExecution.deserialize(compilation.Value).Value.Item1);
}
catch (Exception e)
{
MinerTrace.Error("Could not compile contract " + Convert.ToBase64String(contractHash), e);
return(null);
}
});
if (!TransactionValidation.validateNonCoinbaseTx(
ptx,
utxoLookup,
contractLookup
))
{
MinerTrace.Information("could not validate tx");
return(false);
}
MinerTrace.Information("validated tx");
//TODO: memory management issues. trying to explicitly collect DynamicMethods
GC.Collect();
GC.WaitForPendingFinalizers();
return(true);
}