public TxDelta(TxStateEnum txState, byte[] txHash, Types.Transaction transaction, AssetDeltas assetDeltas, DateTime time)
{
TxState = txState;
TxHash = txHash;
Transaction = transaction;
AssetDeltas = assetDeltas;
Time = time;
}
private void AddOutput(AssetDeltas balances, Types.Output output, bool isSpending = false)
{
if (!balances.ContainsKey(output.spend.asset))
{
balances[output.spend.asset] = 0;
}
balances[output.spend.asset] += isSpending ? -1 * (long)output.spend.amount : (long)output.spend.amount;
}
/// <summary>
/// Imports wallet file
/// </summary>
public void Import(Key key)
{
_BlockChainListener.Pause();
using (var context = _DBContext.GetTransactionContext())
{
_KeyStore.AddKey(context, System.Convert.ToBase64String(key.Private));
context.Commit();
}
//TODO: store the key in DB?
_Keys.Add(key);
HashDictionary <List <Types.Output> > txOutputs;
HashDictionary <Types.Transaction> txs;
var result = new GetUTXOSetAction()
{
Predicate = IsMatch
}.Publish().Result;
txOutputs = result.Item1;
txs = result.Item2;
TxDeltaList.Clear();
using (var dbTx = _DBContext.GetTransactionContext())
{
//dbTx.Transaction.SynchronizeTables(TxBalancesStore.INDEXES);
_TxStore.Reset(dbTx);
foreach (var item in txOutputs)
{
var assetDeltas = new AssetDeltas();
foreach (var output in item.Value)
{
AddOutput(assetDeltas, output);
}
_TxStore.Put(dbTx, item.Key, txs[item.Key], assetDeltas, TxStateEnum.Confirmed);
TxDeltaList.Add(new TxDelta(TxStateEnum.Confirmed, item.Key, txs[item.Key], assetDeltas));
}
_BlockChain.memPool.TxPool.ToList().ForEach(t => HandleTx(dbTx, t.Key, t.Value, TxDeltaList, TxStateEnum.Unconfirmed));
dbTx.Commit();
}
if (OnItems != null)
{
OnItems(TxDeltaList);
}
_BlockChainListener.Continue();
}
public AssetDeltas GetAssetTotals()
{
var assetDeltas = new AssetDeltas();
TxDeltaList.ForEach(t =>
{
foreach (var item in t.AssetDeltas)
{
if (!assetDeltas.ContainsKey(item.Key))
{
assetDeltas[item.Key] = 0;
}
assetDeltas[item.Key] += item.Value;
}
});
return(assetDeltas);
}
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())
{
}
