private static async Task <bool> Run(int blockchainID, string webSocketsUrl, string rpcUrl, BlockchainType blockchainType,
BlockchainNetwork blockchainNetwork)
{
bool hasFailed = false;
using (var client = new StreamingWebSocketClient(webSocketsUrl))
{
EthLogsObservableSubscription logsSubscription = new EthLogsObservableSubscription(client);
Web3 cl = new Web3(rpcUrl);
RequestInterceptor r = new RPCInterceptor(blockchainType);
cl.Client.OverridingRequestInterceptor = r;
EthApiService eth = new EthApiService(cl.Client);
logsSubscription.GetSubscriptionDataResponsesAsObservable().Subscribe(async filterLog =>
{
FilterLog transaction = filterLog;
if (transaction.Removed)
{
return;
}
if (SmartContractManager.TryGetAddress(blockchainID, filterLog.Address, out ContractTypeEnum type))
{
await ProcessSmartContractEvent(blockchainID, blockchainType, blockchainNetwork, type, eth, filterLog,
transaction, cl);
}
});
_dictionary[blockchainID] = new Subscription(client, logsSubscription);
await client.StartAsync();
client.Error += Client_Error;
while (!client.IsStarted)
{
await Task.Delay(1000);
}
await logsSubscription.SubscribeAsync();
while (!hasFailed)
{
try
{
var handler = new EthBlockNumberObservableHandler(client);
handler.GetResponseAsObservable().Subscribe(integer => { });
await handler.SendRequestAsync();
SystemStatus status = new SystemStatus(TaskNames.WebSockets, blockchainID);
await using (var connection = new MySqlConnection(OTHubSettings.Instance.MariaDB.ConnectionString))
{
await status.InsertOrUpdate(connection, true, null, false, "Blockchain Sync");
}
}
catch (Exception ex) when(errorCounter <= 100)
{
hasFailed = true;
_dictionary.Remove(blockchainID, out _);
client.Dispose();
//try
//{
// await client.StopAsync();
// await client.StartAsync();
//}
//catch (Exception)
//{
// Logger.WriteLine(Source.BlockchainSync, ex.ToString());
//}
}
await Task.Delay(120000);
}
}
return(!hasFailed);
}
public static EventLog <TEventDTO> DecodeEvent <TEventDTO>(this EventABI eventABI, FilterLog log) where TEventDTO : new()
{
if (!IsLogForEvent(eventABI, log))
{
return(null);
}
var eventDecoder = new EventTopicDecoder(eventABI.IsAnonymous);
var eventObject = eventDecoder.DecodeTopics <TEventDTO>(log.Topics, log.Data);
return(new EventLog <TEventDTO>(eventObject, log));
}
public static TEventDTO DecodeEvent <TEventDTO>(this TEventDTO eventDTO, FilterLog log) where TEventDTO : IEventDTO
{
var eventABI = ABITypedRegistry.GetEvent <TEventDTO>();
return(DecodeEvent <TEventDTO>(eventDTO, eventABI, log));
}
public EventLog(T eventObject, FilterLog log)
{
Event = eventObject;
Log = log;
}
public static bool IsLogForEvent <TEventDTO>(this FilterLog log)
{
var eventABI = ABITypedRegistry.GetEvent <TEventDTO>();
return(eventABI.IsLogForEvent(log));
}
public bool IsLogForEvent(FilterLog log)
{
return(EventABI.IsLogForEvent(log));
}
public static bool IsLogForEvent(this EventABI eventABI, FilterLog log)
{
return(IsLogForEvent(log, eventABI.Sha3Signature));
}
protected override Task ExecuteInternalAsync(FilterLog value)
{
var eventLog = value.DecodeEvent <TEvent>();
return(_eventAction(eventLog));
}
public bool IsStandardDataChangeLog(FilterLog log)
{
var dataChangeEvent = GetStandardDataChangedEvent();
return(dataChangeEvent.IsLogForEvent(log));
}
public static GenericSearchDocument ToAzureDocument(
this FilterLog log,
SearchField[] searchFields)
{
return(CreateFieldWithValueDictionary(log, searchFields, (field) => field.GetFilterLogValue(log)));
}
protected virtual async Task CrawlFilterLog(CrawlerStepCompleted <TransactionReceiptVO> completedStep, FilterLog filterLog)
{
var currentStepCompleted = await FilterLogCrawlerStep.ExecuteStepAsync(
new FilterLogVO(completedStep.StepData.Transaction, completedStep.StepData.TransactionReceipt, filterLog), completedStep.ExecutedStepsCollection);
}
public LogWithReceiptAndTransaction(Transaction transaction, TransactionReceipt receipt, FilterLog log)
{
Transaction = transaction;
Receipt = receipt;
Log = log;
}
private EthereumEventData ExtractEventData(List <ParameterOutput> eventParams, FilterLog log)
{
Dictionary <string, string> values = eventParams.ToDictionary(eventParam => eventParam.Parameter.Name, eventParam => eventParam.Result.ToString());
return(new EthereumEventData
{
Values = values,
BlockNumber = log.BlockNumber
});
}
public static GenericSearchDocument Map(FilterLog filterLog)
{
return(filterLog.ToAzureDocument(PresetSearchFields.LogFields));
}
public virtual bool IsLogForEvent(FilterLog log) => log.IsLogForEvent <TEventDto>();
public static JObject ConvertToJObject(this FilterLog filterLog)
{
return(JObject.FromObject(filterLog));
}
public bool IsLogForEvent(FilterLog log)
{
return(log.IsLogForEvent <TEvent>());
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus Save(FilterId filterId, Filter filter)
{
// Initialize
questStatus status = null;
Mgr mgr = new Mgr(this.UserSession);
DbMgrTransaction trans = null;
FiltersMgr filtersMgr = new FiltersMgr(this.UserSession);
ColumnsMgr columnMgr = new ColumnsMgr(this.UserSession);
try
{
// Validate filter
status = Verify(filterId, filter);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// BEGIN TRANSACTION
status = mgr.BeginTransaction("SaveFilter" + Guid.NewGuid().ToString(), out trans);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Save the filter
status = Save(trans, filterId, filter);
if (!questStatusDef.IsSuccess(status))
{
mgr.RollbackTransaction(trans);
if (bLogging)
{
Filter _filter = null;
status = filtersMgr.Read(filterId, out _filter);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
FilterLog filterLog = new FilterLog();
filterLog.Database = "";
filterLog.Tableset = "Tableset.Id=" + filter.TablesetId.ToString();
filterLog.Name = _filter.Name;
filterLog.Event = "SAVE";
filterLog.Data = status.ToString();
FilterLogId filterLogId = null;
_dbFilterLogsMgr.Create(filterLog, out filterLogId);
}
return(status);
}
// COMMIT TRANSACTION
status = mgr.CommitTransaction(trans);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Logging
if (bLogging)
{
Filter _filter = null;
status = filtersMgr.Read(filterId, out _filter);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
FilterLog filterLog = new FilterLog();
filterLog.Database = "";
filterLog.Tableset = "Tableset.Id=" + filter.TablesetId.ToString();
filterLog.Name = _filter.Name;
filterLog.Event = "SAVE";
filterLog.Data = status.ToString();
FilterLogId filterLogId = null;
_dbFilterLogsMgr.Create(filterLog, out filterLogId);
}
// TODO: REFACTOR TO GET ALL-IN-ONE TRANSACTION
// Generate filter SQL
Filter filterWithSQL = null;
DbFilterMgr dbFilterMgr = new DbFilterMgr(this.UserSession);
status = dbFilterMgr.GenerateFilterSQL(filterId, out filterWithSQL);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Update filter
status = filtersMgr.Update(filterWithSQL);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
catch (System.Exception ex)
{
if (trans != null)
{
mgr.RollbackTransaction(trans);
}
return(new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
ex.InnerException != null ? ex.InnerException.Message : ex.Message)));
}
return(new questStatus(Severity.Success));
}
public MessageToQueue(FilterLog log)
{
BlockNumber = log.BlockNumber.Value.ToString();
TransactionHash = log.TransactionHash;
LogIndex = log.LogIndex.ToString();
}
public static bool HasSameNumberOfIndexes <TEventDTO>(FilterLog log) where TEventDTO : IEventDTO
{
var eventABI = ABITypedRegistry.GetEvent <TEventDTO>();
return(eventABI.HasSameNumberOfIndexes(log));
}
public static bool IsLogForEvent <TEventDTO>(this TEventDTO eventDTO, FilterLog log) where TEventDTO : IEventDTO
{
return(IsLogForEvent <TEventDTO>(log));
}
public static bool HasSameNumberOfIndexes <TEventDTO>(this TEventDTO eventDTO, FilterLog log) where TEventDTO : IEventDTO
{
return(eventDTO.GetEventABI().HasSameNumberOfIndexes(log));
}
public bool IsLogForEvent(FilterLog log)
{
return(EventBuilder.IsLogForEvent(log));
}
public static bool HasSameNumberOfIndexes(this EventABI eventAbi, FilterLog log)
{
return(eventAbi.NumberOfIndexes == (log.Topics?.Length - 1));
}
public static EventLog <List <ParameterOutput> > DecodeEventDefaultTopics(this EventABI eventABI, FilterLog log)
{
if (!IsLogForEvent(eventABI, log))
{
return(null);
}
var eventDecoder = new EventTopicDecoder();
var eventObject = eventDecoder.DecodeDefaultTopics(eventABI, log.Topics, log.Data);
return(new EventLog <List <ParameterOutput> >(eventObject, log));
}
public static string EventSignature(this FilterLog log) => log.GetTopic(0);
public static EventLog <TEventDTO> DecodeEvent <TEventDTO>(this FilterLog log) where TEventDTO : new()
{
var eventABI = ABITypedRegistry.GetEvent <TEventDTO>();
return(eventABI.DecodeEvent <TEventDTO>(log));
}
public static string IndexedVal3(this FilterLog log) => log.GetTopic(3);
public static TEventDTO DecodeEvent <TEventDTO>(this TEventDTO eventDTO, EventABI eventABI, FilterLog log) where TEventDTO : IEventDTO
{
if (!IsLogForEvent(eventABI, log))
{
return(default(TEventDTO));
}
var eventDecoder = new EventTopicDecoder();
return(eventDecoder.DecodeTopics(eventDTO, log.Topics, log.Data));
}
private static async Task ProcessHoldingSmartContractEvent(int blockchainID, BlockchainType blockchainType,
BlockchainNetwork blockchainNetwork, EthApiService eth, FilterLog filterLog, FilterLog transaction, Web3 cl)
{
var contract = new Contract(eth,
AbiHelper.GetContractAbi(ContractTypeEnum.Holding, blockchainType, blockchainNetwork), filterLog.Address);
var offerCreatedEvent = contract.GetEvent("OfferCreated");
var offerFinalizedEvent = contract.GetEvent("OfferFinalized");
var offerTaskEvent = contract.GetEvent("OfferTask");
var paidOutEvent = contract.GetEvent("PaidOut");
await using (var connection =
new MySqlConnection(OTHubSettings.Instance.MariaDB.ConnectionString))
{
try
{
if (offerCreatedEvent.IsLogForEvent(transaction))
{
var events =
offerCreatedEvent.DecodeAllEventsForEvent <Models.Program.OfferCreated>(
new[] { filterLog });
foreach (EventLog <Models.Program.OfferCreated> eventLog in events)
{
await SyncHoldingContractTask.ProcessOfferCreated(connection, blockchainID, cl,
filterLog.Address, eventLog);
}
await ProcessJobsTask.Execute(connection, blockchainID, blockchainType, blockchainNetwork);
}
if (offerFinalizedEvent.IsLogForEvent(transaction))
{
var events =
offerFinalizedEvent.DecodeAllEventsDefaultForEvent(new[] { filterLog });
foreach (EventLog <List <ParameterOutput> > eventLog in events)
{
await SyncHoldingContractTask.ProcessOfferFinalised(connection, blockchainID, cl,
filterLog.Address,
eventLog);
}
await ProcessJobsTask.Execute(connection, blockchainID, blockchainType, blockchainNetwork);
}
if (paidOutEvent.IsLogForEvent(transaction))
{
var events =
paidOutEvent.DecodeAllEventsDefaultForEvent(new[] { filterLog });
foreach (EventLog <List <ParameterOutput> > eventLog in events)
{
await SyncHoldingContractTask.ProcessPayout(connection, blockchainID, cl,
filterLog.Address, eventLog);
}
}
}
catch (Exception ex)
{
Logger.WriteLine(Source.BlockchainSync, ex.ToString());
}
}
}
