public TxMessage(byte[] txHash, TransactionValidation.PointedTransaction ptx, TxStateEnum state)
{
BlockChainTrace.Information("To wallet: " + state, txHash);
TxHash = txHash;
Ptx = ptx;
State = state;
}
public TxDelta(TxStateEnum txState, byte[] txHash, Types.Transaction transaction, AssetDeltas assetDeltas, DateTime time)
{
TxState = txState;
TxHash = txHash;
Transaction = transaction;
AssetDeltas = assetDeltas;
Time = time;
}
protected void RegisterTxEvent(Types.Transaction tx, TxStateEnum txState)
{
_TxStateEvents[Merkle.transactionHasher.Invoke(tx)] =
new Tuple <ManualResetEvent, TxStateEnum>(
new ManualResetEvent(false),
txState
);
}
public TransactionItem(long Amount, DirectionEnum Direction, byte[] Asset, DateTime Date, String To, String Id, Decimal Fee, TxStateEnum txState)
{
this.Amount = Amount;
this.Direction = Direction;
this.Asset = Asset;
this.Date = Date;
this.To = To;
this.Id = Id;
this.Fee = Fee;
this.TxState = txState;
}
void AddTx(byte[] txHash, Consensus.Types.Transaction tx, TxStateEnum txState)
{
Add(txHash, new GraphNode(GraphNodeTypeEnum.Tx, txState.ToString(), txHash));
uint i = 0;
foreach (var output in tx.outputs)
{
var outputHash = Consensus.Merkle.outputHasher.Invoke(output);
string text = [email protected] ? "C" : "P";
text += " " + Convert.ToBase64String(output.spend.asset);
text += " " + output.spend.amount;
if (output.spend.asset.SequenceEqual(Consensus.Tests.zhash))
{
text += " Kalapas";
}
if (output.@lock is Consensus.Types.OutputLock.ContractLock)
{
var data = ((Consensus.Types.OutputLock.ContractLock)output.@lock).data;
if (data != null)
{
text += " " + Convert.ToBase64String(data);
}
}
var outputGraphNode = new GraphNode(GraphNodeTypeEnum.Output, text);
Add(outputHash, outputGraphNode, txHash);
var outpointHash = Consensus.Merkle.outpointHasher.Invoke(new Consensus.Types.Outpoint(txHash, i));
_Nodes[outpointHash] = outputHash;
i++;
}
foreach (var outpoint in tx.inputs)
{
var outpointHash = Consensus.Merkle.outpointHasher.Invoke(outpoint);
Add(outpointHash, new GraphNode(GraphNodeTypeEnum.Outpoint), txHash);
}
if (txState == TxStateEnum.Unconfirmed)
{
Link(txHash, memPool);
}
_Txs.Add(txHash, tx);
}
void HandleTx(TransactionContext dbTx, byte[] txHash, TransactionValidation.PointedTransaction ptx, List <TxDelta> deltas, TxStateEnum txState)
{
var isValid = txState != TxStateEnum.Invalid;
var _deltas = new AssetDeltas();
if (!isValid)
{
foreach (var item in _TxStore.All(dbTx).Where(t => t.Item2.TxHash.SequenceEqual(txHash)))
{
item.Item2.TxState = txState;
//TODO: handle ui consistency
_TxStore.Put(dbTx, item.Item1, item.Item2);
}
return;
}
ptx.outputs.Where(IsMatch).ToList().ForEach(o =>
{
AddOutput(_deltas, o, !isValid);
});
ptx.pInputs.ToList().ForEach(pInput =>
{
var key = GetKey(pInput.Item2);
if (key != null)
{
AddOutput(_deltas, pInput.Item2, isValid);
_KeyStore.Used(dbTx, key, true);
}
});
if (_deltas.Count > 0)
{
var tx = TransactionValidation.unpoint(ptx);
_TxStore.Put(dbTx, txHash, tx, _deltas, txState);
deltas.Add(new TxDelta(txState, txHash, tx, _deltas));
}
}
internal void Put(TransactionContext dbTx, byte[] txHash, Types.Transaction tx, AssetDeltas assetDeltas, TxStateEnum txState)
{
var txHashRecord = dbTx.Transaction.Select <byte[], ulong>(TX_HASHES_TO_IDENTITY, txHash);
var identity = txHashRecord.Exists ? txHashRecord.Value : dbTx.Transaction.Count(TX_HASHES_TO_IDENTITY);
if (!txHashRecord.Exists)
{
dbTx.Transaction.Insert <byte[], ulong>(TX_HASHES_TO_IDENTITY, txHash, identity);
}
Put(dbTx, identity, new TxData()
{
DateTime = DateTime.Now.ToUniversalTime(),
TxState = txState,
Tx = tx,
AssetDeltas = assetDeltas,
TxHash = txHash,
});
}
public TxDelta(TxStateEnum txState, byte[] txHash, Types.Transaction transaction, AssetDeltas assetDeltas) : this(txState, txHash, transaction, assetDeltas, DateTime.Now.ToUniversalTime())
{
}
