private void OnCdmPoolGraphAdded(object sender, CdmPoolEventArgs args)
{
// Note: it is possible to filter to just showing graphs that WE requested from the cdmpool. To do this, examine args.CdmRequest to see
// what the request was. For now this is not needed and not done.
CdmGraphBtc gb = args.CdmGraph as CdmGraphBtc;
if (gb == null)
{
Msg.LogError("FrontEndController.OnCdmPoolGraphAdded heard event but graph fragment is null or not correct type");
return;
}
else
{
Msg.Log("FrontEndController.OnCdmPoolGraphAdded heard event that graph fragment" + gb.GraphId + " is to be added to pool");
}
// Create nodes and edges
Vector3 location = args.CdmRequest.WorldLocation;
foreach (CdmNode n in gb.GetAllNodes())
{
CdmNodeBtc nb = n as CdmNodeBtc;
GraphFactory.CreateOrUpdateNode(nb, location);
}
foreach (CdmEdge e in gb.GetAllEdges())
{
CdmEdgeBtc eb = e as CdmEdgeBtc;
GraphFactory.CreateOrUpdateEdge(eb);
}
// An audio-visual feast
if (AudioManager.Instance != null)
{
AudioManager.Instance.PlayPop();
}
}
private bool PayloadGetTx(CdmRequest r, JSONNode n)
{
CdmGraph g = new CdmGraphBtc()
{
GraphId = "Graph for " + r.NodeType + " " + r.NodeId
};
// Extract JSON
var N = n;
// Tx can contain multiple inputs or outputs from the SAME source address (basically each UTXO from the source address)
// we have to aggregate across these unspent txoutputs
AdaptorHelpers.CompressTxInputs(N);
AdaptorHelpers.CompressTxOutputs(N);
// these var are all JSONNodes
var txHash = N["hash"];
var inputs = N["inputs"];
var outputs = N["out"];
var unixTime = N["time"];
var blockHeight = N["block_height"];
var relayedBy = N["relayed_by"];
var vinSize = N["vin_sz"];
var voutSize = N["vout_sz"];
int totalInputsOutputs = 0;
try
{
totalInputsOutputs = (int)vinSize + (int)voutSize;
}
catch
{
totalInputsOutputs = 0;
}
double unixTimeD = 0;
DateTime unixTimeDT = DateTime.Now;
try
{
unixTimeD = (double)unixTime;
unixTimeDT = AdaptorHelpers.UnixTimeStampToDateTime(unixTimeD);
}
catch
{
unixTimeDT = DateTime.Now;
}
// The tx itself
g.AddNode(new CdmNodeBtc()
{
NodeId = txHash,
NodeType = NodeType.Tx,
NodeEdgeCountTotal = totalInputsOutputs,
CreateDate = unixTimeDT,
CreateDateStr = unixTimeDT.ToLongDateString(),
BlockHeight = blockHeight,
RelayedBy = relayedBy,
VoutSize = voutSize,
VinSize = vinSize
});
int edgeCounter = r.EdgeCountFrom;
//------------------------------------------------------------------------------------------------
// inputs (create "from addresses" and links from there to the tx)
//------------------------------------------------------------------------------------------------
// from: inputs[i].prev_out.addr
// to txHash (which already exists)
// value inputs[i].prev_out.value
for (int i = 0; i < inputs.Count; i++)
{
var inputAddr = inputs[i]["prev_out"]["addr"];
var inputValue = inputs[i]["prev_out"]["value"];
float inputValF = (float)inputValue / 100000f; // mBTC
// Address at end of the edge
g.AddNode(new CdmNodeBtc()
{
NodeId = inputAddr,
NodeType = NodeType.Addr,
NodeEdgeCountTotal = 0, // not known
FinalBalance = 0, // none of this stuff known yet
TotalReceived = 0,
TotalSent = 0
});
// Edge tx -<--- address
g.AddEdge(new CdmEdgeBtc()
{
EdgeId = AdaptorHelpers.FormatEdgeId(txHash, inputAddr, EdgeType.Input),
EdgeIdFriendly = AdaptorHelpers.FormatEdgeIdFriendly(txHash, inputAddr),
NodeSourceId = txHash,
NodeTargetId = inputAddr,
EdgeNumberInSource = edgeCounter,
EdgeNumberInTarget = 0, // not known yet
ValueInSource = inputValF,
EdgeType = EdgeType.Input
});
edgeCounter++;
}
//------------------------------------------------------------------------------------------------
// outputs (create "to addresses" and links from tx to there
//------------------------------------------------------------------------------------------------
// from: txHash (which already exists)
// to output[i].addr
// value output[i].value
for (int i = 0; i < outputs.Count; i++)
{
var outputAddr = outputs[i]["addr"];
var outputValue = outputs[i]["value"];
float outputValF = (float)outputValue / 100000f; // mBTC
// Address at end of the edge
g.AddNode(new CdmNodeBtc()
{
NodeId = outputAddr,
NodeType = NodeType.Addr,
NodeEdgeCountTotal = 0, // not known
FinalBalance = 0, // none of this stuff known yet
TotalReceived = 0,
TotalSent = 0
});
// Edge tx --->- address
g.AddEdge(new CdmEdgeBtc()
{
EdgeId = AdaptorHelpers.FormatEdgeId(txHash, outputAddr, EdgeType.Output),
EdgeIdFriendly = AdaptorHelpers.FormatEdgeIdFriendly(txHash, outputAddr),
NodeSourceId = txHash,
NodeTargetId = outputAddr,
EdgeNumberInSource = edgeCounter,
EdgeNumberInTarget = 0, // not known yet
ValueInTarget = outputValF,
EdgeType = EdgeType.Output
});
edgeCounter++;
}
CdmCore.IngestCdmGraphFragment(r, g);
return(true);
}
private bool PayloadGetAddr(CdmRequest r, JSONNode n)
{
CdmGraph g = new CdmGraphBtc()
{
GraphId = "Graph for " + r.NodeType + " " + r.NodeId
};
var N = n;
string addr = N["address"]; //.ToString(); adds a doublequote "
var finBal = N["final_balance"]; // address current balance
float finBalF = (float)finBal / 100000f; // (float)Convert.ToDouble(finBal) / 100000f; // mBTC
var addrTxsRaw = N["n_tx"]; // address total tx
int addrTxs = (int)addrTxsRaw; // int addrTxs = (int)Convert.ToInt32(addrTxsRaw);
//------------------------------------------------------------------------------------------------
// The address itself
//------------------------------------------------------------------------------------------------
g.AddNode(new CdmNodeBtc()
{
NodeId = addr,
NodeType = NodeType.Addr,
NodeEdgeCountTotal = addrTxs,
FinalBalance = finBalF,
TotalReceived = 0,
TotalSent = 0
});
//------------------------------------------------------------------------------------------------
// Now create transactions
//------------------------------------------------------------------------------------------------
// address tx in this batch received
var txs = N["txs"];
Msg.Log("AdaptorBtcOfflineFiles.PayloadGetAddr has found:" + txs.Count + " transactions attached to the address " + addr);
int edgeCounter = r.EdgeCountFrom;
for (int i = 0; i < txs.Count; i++)
{
var txBody = txs[i];
// Tx can contain multiple inputs (and outputs?) from the SAME source address (basically each UTXO from the source address)
// we have to aggregate across these unspent tx outputs
AdaptorHelpers.CompressTxInputs(txBody);
AdaptorHelpers.CompressTxOutputs(txBody);
var txId = txs[i]["hash"];
var inputs = txs[i]["inputs"];
var outputs = txs[i]["out"];
var unixTime = txs[i]["time"];
var blockHeight = txs[i]["block_height"];
var relayedBy = txs[i]["relayed_by"];
var vinSize = txs[i]["vin_sz"];
var voutSize = txs[i]["vout_sz"];
int totalInputsOutputs = 0;
// defensively calc total inputs plus outputs
try
{
totalInputsOutputs = (int)vinSize + (int)voutSize;
}
catch
{
totalInputsOutputs = 0;
}
// defensively get date
double unixTimeD = 0;
DateTime unixTimeDT = DateTime.Now;
try
{
unixTimeD = (double)unixTime;
unixTimeDT = AdaptorHelpers.UnixTimeStampToDateTime(unixTimeD);
}
catch
{
unixTimeDT = DateTime.Now;
}
// Create tx
g.AddNode(new CdmNodeBtc()
{
NodeId = txId,
NodeType = NodeType.Tx,
NodeEdgeCountTotal = totalInputsOutputs,
CreateDate = unixTimeDT,
CreateDateStr = unixTimeDT.ToLongDateString(),
BlockHeight = blockHeight,
RelayedBy = relayedBy,
VoutSize = voutSize,
VinSize = vinSize
});
//------------------------------------------------------------------------------------------------
// Edges of all sorts:
// Edge tx -<--- address == type input
// Edge tx --->- address == type output
// Edge tx -<->- address == type mixed
//------------------------------------------------------------------------------------------------
// Inside either the inputs or outputs, we'll find the addrObj -> get the value from it
float linkValInp = AdaptorHelpers.GetLinkValueForAddressFromInputs(addr, inputs);
float linkValOut = AdaptorHelpers.GetLinkValueForAddressFromOutputs(addr, outputs);
// Edge type
EdgeType edgeType = EdgeType.Unknown;
if (linkValInp > 0f && linkValOut > 0f)
{
// Mixed edge from address to tx
edgeType = EdgeType.Mixed;
}
else if (linkValOut > 0f)
{
// Output
edgeType = EdgeType.Output;
}
else if (linkValInp > 0f)
{
// Input
edgeType = EdgeType.Input;
}
else
{
// In paged cases may not have any knowledge of value - yet (or ever, until all pages retrieved) because
// the remainder of the address information will come in a later page.
edgeType = EdgeType.Unknown;
}
// Edge
g.AddEdge(new CdmEdgeBtc()
{
EdgeId = AdaptorHelpers.FormatEdgeId(txId, addr, edgeType),
EdgeIdFriendly = AdaptorHelpers.FormatEdgeIdFriendly(txId, addr),
NodeSourceId = txId,
NodeTargetId = addr,
EdgeNumberInSource = 0,
EdgeNumberInTarget = edgeCounter,
ValueInSource = linkValInp,
ValueInTarget = linkValOut,
EdgeType = edgeType,
});
edgeCounter++;
}
CdmCore.IngestCdmGraphFragment(r, g);
return(true);
}