private async Task Sync(Source source, Event replacementCompletedEvent, OTContract contract,
MySqlConnection connection, Web3 cl, int blockchainID, EthApiService eth, ulong currentStart, ulong currentEnd)
{
var toBlock = new BlockParameter(currentEnd);
var replacementCompletedEvents = await replacementCompletedEvent.GetAllChangesDefault(
replacementCompletedEvent.CreateFilterInput(new BlockParameter(currentStart),
toBlock));
if (replacementCompletedEvents.Any())
{
Logger.WriteLine(source, "Found " + replacementCompletedEvents.Count + " replacement completed events");
}
foreach (EventLog <List <ParameterOutput> > eventLog in replacementCompletedEvents)
{
var block = await BlockHelper.GetBlock(connection, eventLog.Log.BlockHash, eventLog.Log.BlockNumber,
cl, blockchainID);
var offerId =
HexHelper.ByteArrayToString((byte[])eventLog.Event
.First(e => e.Parameter.Name == "offerId").Result);
var challengerIdentity = (string)eventLog.Event
.First(e => e.Parameter.Name == "challengerIdentity").Result;
var chosenHolder = (string)eventLog.Event
.First(e => e.Parameter.Name == "chosenHolder").Result;
var transaction = await eth.Transactions.GetTransactionByHash.SendRequestAsync(eventLog.Log.TransactionHash);
var receipt = await eth.Transactions.GetTransactionReceipt.SendRequestAsync(eventLog.Log.TransactionHash);
var row = new OTContract_Replacement_ReplacementCompleted
{
TransactionHash = eventLog.Log.TransactionHash,
BlockNumber = (UInt64)eventLog.Log.BlockNumber.Value,
Timestamp = block.Timestamp,
OfferId = offerId,
ChosenHolder = chosenHolder,
ChallengerIdentity = challengerIdentity,
GasPrice = (UInt64)transaction.GasPrice.Value,
GasUsed = (UInt64)receipt.GasUsed.Value,
BlockchainID = blockchainID
};
await OTContract_Replacement_ReplacementCompleted.InsertIfNotExist(connection, row);
await OTOfferHolder.Insert(connection, offerId, chosenHolder, false, blockchainID);
await OTOfferHolder.UpdateLitigationStatusesForOffer(connection, offerId, blockchainID);
}
contract.LastSyncedTimestamp = DateTime.Now;
contract.SyncBlockNumber = (ulong)toBlock.BlockNumber.Value;
await OTContract.Update(connection, contract, false, false);
}
public override async Task <bool> Execute(Source source, BlockchainType blockchain, BlockchainNetwork network)
{
ClientBase.ConnectionTimeout = new TimeSpan(0, 0, 5, 0);
await using (var connection =
new MySqlConnection(OTHubSettings.Instance.MariaDB.ConnectionString))
{
int blockchainID = await GetBlockchainID(connection, blockchain, network);
var cl = await GetWeb3(connection, blockchainID, blockchain);
var eth = new EthApiService(cl.Client);
foreach (var contract in await OTContract.GetByTypeAndBlockchain(connection,
(int)ContractTypeEnum.Litigation, blockchainID))
{
if (contract.IsArchived && contract.LastSyncedTimestamp.HasValue &&
(DateTime.Now - contract.LastSyncedTimestamp.Value).TotalDays <= 5)
{
#if DEBUG
Logger.WriteLine(source, " Skipping contract: " + contract.Address);
#endif
continue;
}
Logger.WriteLine(source, " Using contract: " + contract.Address);
var holdingContract = new Contract(eth,
AbiHelper.GetContractAbi(ContractTypeEnum.Litigation, blockchain, network), contract.Address);
var litigationInitiatedEvent = holdingContract.GetEvent("LitigationInitiated");
var litigationAnsweredEvent = holdingContract.GetEvent("LitigationAnswered");
var litigationTimedOutEvent = holdingContract.GetEvent("LitigationTimedOut");
var litigationCompletedEvent = holdingContract.GetEvent("LitigationCompleted");
var replacementStartedEvent = holdingContract.GetEvent("ReplacementStarted");
ulong size = (ulong)10000;
BlockBatcher batcher = BlockBatcher.Start(contract.SyncBlockNumber, (ulong)LatestBlockNumber.Value, size,
async delegate(ulong start, ulong end)
{
await Sync(connection, litigationInitiatedEvent, litigationAnsweredEvent,
litigationTimedOutEvent,
litigationCompletedEvent,
replacementStartedEvent,
contract, source, start,
end, blockchainID, cl);
});
await batcher.Execute();
}
}
return(true);
}
private async Task SyncContractsChanged(Event contractsChangedEvent, ulong fromBlockNumber, ulong toBlockNumber,
Contract hubContract, Web3 web3, MySqlConnection connection, int blockchainID)
{
var eventsOfChange = await contractsChangedEvent.GetAllChangesDefault(
contractsChangedEvent.CreateFilterInput(new BlockParameter(fromBlockNumber),
new BlockParameter(toBlockNumber)));
foreach (var eventLog in eventsOfChange)
{
Function setContractAddressFunction = hubContract.GetFunction("setContractAddress");
var transaction = await web3.Eth.Transactions.GetTransactionByHash.SendRequestAsync(eventLog.Log.TransactionHash);
var data = setContractAddressFunction.DecodeInput(transaction.Input);
if (data == null)
{
continue;
}
var contractName = (string)data.First(d => d.Parameter.Name == "contractName").Result;
var newContractAddress = (string)data.First(d => d.Parameter.Name == "newContractAddress").Result;
if (Enum.TryParse(typeof(ContractTypeEnum), contractName, true, out var result))
{
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = newContractAddress,
IsLatest = false,
Type = (int)result,
BlockchainID = blockchainID
}, true);
}
}
await HubAddress.UpdateSyncBlockNumber(connection, blockchainID, hubContract.Address, toBlockNumber);
}
public override async Task <bool> Execute(Source source, BlockchainType blockchain, BlockchainNetwork network)
{
ClientBase.ConnectionTimeout = new TimeSpan(0, 0, 5, 0);
await using (var connection =
new MySqlConnection(OTHubSettings.Instance.MariaDB.ConnectionString))
{
int blockchainID = await GetBlockchainID(connection, blockchain, network);
var cl = await GetWeb3(connection, blockchainID, blockchain);
var profileStorageContractAddress = (await OTContract
.GetByTypeAndBlockchain(connection, (int)ContractTypeEnum.ProfileStorage, blockchainID)).SingleOrDefault(a => a.IsLatest);
if (profileStorageContractAddress == null)
{
return(false);
}
var profileStorageContract =
new Contract(new EthApiService(cl.Client),
AbiHelper.GetContractAbi(ContractTypeEnum.ProfileStorage, blockchain, network),
profileStorageContractAddress.Address);
var profileFunction = profileStorageContract.GetFunction("profile");
var currentIdentities = await OTIdentity.GetAll(connection, blockchainID);
Dictionary <string, decimal> paidOutBalances = (await connection
.QueryAsync <PayoutGroupHolder>(
@"SELECT Holder, SUM(Amount) Amount FROM OTContract_Holding_Paidout WHERE BlockchainID = @blockchainID GROUP BY Holder",
new
{
blockchainID = blockchainID
}))
.ToDictionary(k => k.Holder, k => k.Amount);
Dictionary <string, OfferGroupHolder> offerTotals = (await connection.QueryAsync <OfferGroupHolder>(
@"select i.Identity, COUNT(o.OfferID) as OffersTotal,
(SELECT count(so.OfferID) FROM otoffer_holders sh join otoffer so on so.OfferID = sh.OfferID AND so.BlockchainID = sh.BlockchainID
WHERE sh.blockchainid = @blockchainID and sh.Holder = i.Identity AND so.CreatedTimestamp >= Date_Add(NOW(), INTERVAL -7 DAY)) as OffersLast7Days
from otidentity i
join otoffer_holders h on h.Holder = i.Identity AND h.BlockchainID = i.BlockchainID
join otoffer o on o.OfferID = h.OfferID AND o.BlockchainID = h.BlockchainID
WHERE i.blockchainid = @blockchainID
GROUP BY i.Identity", new
{
blockchainID
})).ToDictionary(k => k.Identity, k => k);
// NodeManagementWallet[] managementWallets = (await connection.QueryAsync<NodeManagementWallet>(
// @"SELECT I.Identity, PC.ManagementWallet as CreateWallet, IT.ManagementWallet TransferWallet FROM OTIdentity I
//LEFT JOIN OTContract_Profile_ProfileCreated PC ON PC.Profile = I.Identity AND PC.BlockchainID = I.BlockchainID
//LEFT JOIN OTContract_Profile_IdentityTransferred IT ON IT.NewIdentity = I.Identity AND IT.BlockchainID = I.BlockchainID
//WHERE I.Version > 0 AND I.BlockchainID = @blockchainID", new
// {
// blockchainID
// })).ToArray();
foreach (OTIdentity currentIdentity in currentIdentities)
{
bool updateProfile = true;
DateTime?lastActivityDate = null;
if (currentIdentity.Version != Constants.CurrentERCVersion)
{
if (currentIdentity.LastSyncedTimestamp.HasValue)
{
DateTime adjustedNowTime = DateTime.Now;
if ((adjustedNowTime - currentIdentity.LastSyncedTimestamp.Value).TotalDays <= 14)
{
updateProfile = false;
}
}
}
else if (currentIdentity.LastSyncedTimestamp.HasValue)
{
var dates = (await connection.QueryAsync <DateTime?>(@"
select MAX(Timestamp) from otcontract_profile_identitycreated r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE r.NewIdentity = @identity AND r.blockchainID = @blockchainID
union
select MAX(Timestamp) from otcontract_profile_identitytransferred r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE r.NewIdentity = @identity AND r.blockchainID = @blockchainID
union
select MAX(Timestamp) from otcontract_profile_profilecreated r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE r.Profile = @identity AND r.blockchainID = @blockchainID
union
select MAX(Timestamp) from otcontract_profile_tokensdeposited r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE r.Profile = @identity AND r.blockchainID = @blockchainID
union
select MAX(Timestamp) from otcontract_profile_tokensreleased r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE r.Profile = @identity AND r.blockchainID = @blockchainID
union
select MAX(Timestamp) from otcontract_profile_tokensreserved r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE r.Profile = @identity AND r.blockchainID = @blockchainID
union
select MAX(Timestamp) from otcontract_profile_tokenstransferred r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE (r.Sender = @identity OR r.Receiver = @identity) AND r.blockchainID = @blockchainID
union
select MAX(Timestamp) from otcontract_profile_tokenswithdrawn r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE r.Profile = @identity AND r.blockchainID = @blockchainID
union
select MAX(b.Timestamp) from otoffer_holders h
join otoffer o on o.offerid = h.offerid and o.BlockchainID = h.BlockchainID
join ethblock b on b.blocknumber = o.finalizedblocknumber AND h.BlockchainID = b.BlockchainID
where h.Holder = @identity AND h.blockchainID = @blockchainID
union
SELECT MAX(Timestamp)
FROM otcontract_litigation_litigationcompleted lc
WHERE lc.HolderIdentity = @identity AND lc.DHWasPenalized = 1 AND lc.blockchainID = @blockchainID
union
select MAX(b.Timestamp) from otcontract_holding_paidout p
join ethblock b on b.blocknumber = p.blocknumber and b.BlockchainID = p.BlockchainID
where p.holder = @identity AND p.blockchainID = @blockchainID
union
select MAX(b.Timestamp) from otcontract_holding_offerfinalized of
join otcontract_holding_offercreated oc on oc.OfferId = of.OfferId and oc.BlockchainID = of.BlockchainID
join OTIdentity i on i.NodeId = oc.DCNodeId and i.BlockchainID = oc.BlockchainID
join ethblock b on of.BlockNumber = b.BlockNumber and b.BlockchainID = of.BlockchainID
where i.Identity = @identity AND of.blockchainID = @blockchainID", new
{
identity = currentIdentity.Identity,
blockchainID
})).ToArray().Where(d => d.HasValue).Select(d => d.Value).ToArray();
var adjustedNowTime = DateTime.Now;
if (dates.Any())
{
lastActivityDate = dates.Max();
if (lastActivityDate.Value <= currentIdentity.LastSyncedTimestamp)
{
if ((adjustedNowTime - currentIdentity.LastSyncedTimestamp.Value).TotalHours <= 16)
{
updateProfile = false;
}
}
}
else
{
if ((adjustedNowTime - currentIdentity.LastSyncedTimestamp.Value).TotalHours <= 24)
{
updateProfile = false;
}
}
}
if (updateProfile || (currentIdentity.NodeId ?? "").Length > 40)
{
var output =
await profileFunction.CallDeserializingToObjectAsync <ProfileFunctionOutput>(
currentIdentity.Identity);
var stake = Web3.Convert.FromWei(output.stake);
var stakeReserved = Web3.Convert.FromWei(output.stakeReserved);
var nodeId = HexHelper.ByteArrayToString(output.nodeId, false).Substring(0, 40);
var withdrawalAmount = Web3.Convert.FromWei(output.withdrawalAmount);
var withdrawalTimestamp = (UInt64)output.withdrawalTimestamp;
var reputation = (UInt64)output.reputation;
if (currentIdentity.Stake != stake ||
currentIdentity.StakeReserved != stakeReserved ||
currentIdentity.NodeId != nodeId ||
currentIdentity.WithdrawalAmount != withdrawalAmount ||
currentIdentity.WithdrawalPending != output.withdrawalPending ||
currentIdentity.WithdrawalTimestamp != withdrawalTimestamp ||
currentIdentity.Reputation != reputation)
{
currentIdentity.Stake = stake;
currentIdentity.StakeReserved = stakeReserved;
currentIdentity.NodeId = nodeId;
currentIdentity.WithdrawalAmount = withdrawalAmount;
currentIdentity.WithdrawalPending = output.withdrawalPending;
currentIdentity.WithdrawalTimestamp = withdrawalTimestamp;
currentIdentity.Reputation = reputation;
currentIdentity.LastSyncedTimestamp = DateTime.Now;
await OTIdentity.UpdateFromProfileFunction(connection, currentIdentity);
}
else
{
currentIdentity.LastSyncedTimestamp = DateTime.Now;
await OTIdentity.UpdateLastSyncedTimestamp(connection, currentIdentity);
}
}
if (!paidOutBalances.TryGetValue(currentIdentity.Identity, out var paidRow))
{
paidRow = 0;
}
offerTotals.TryGetValue(currentIdentity.Identity, out var offerRow);
if (currentIdentity.Paidout != paidRow ||
currentIdentity.TotalOffers != (offerRow?.OffersTotal ?? 0) ||
currentIdentity.OffersLast7Days != (offerRow?.OffersLast7Days ?? 0) ||
currentIdentity.ActiveOffers != 0 ||
(currentIdentity.LastActivityTimestamp != lastActivityDate && lastActivityDate.HasValue))
{
currentIdentity.Paidout = paidRow;
currentIdentity.TotalOffers = offerRow?.OffersTotal ?? 0;
currentIdentity.OffersLast7Days = offerRow?.OffersLast7Days ?? 0;
currentIdentity.ActiveOffers = 0;
currentIdentity.LastActivityTimestamp = lastActivityDate;
await OTIdentity.UpdateFromPaidoutAndApprovedCalculation(connection, currentIdentity);
}
}
}
return(true);
}
private async Task SyncLatestContractsOnHub(ulong fromBlockNumber,
Contract hubContract, MySqlConnection connection, int blockchainID, bool isLatest)
{
var tokenAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.Token.ToString());
var approvalAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.Approval.ToString());
var holdingStorageAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.HoldingStorage.ToString());
var holdingAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.Holding.ToString());
var profileStorageAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.ProfileStorage.ToString());
var profileAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.Profile.ToString());
var readingAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.Reading.ToString());
var readingStorageAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.ReadingStorage.ToString());
var litigationAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.Litigation.ToString());
var litigationStorageAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.LitigationStorage.ToString());
var replacementAddress = await hubContract.GetFunction("getContractAddress").CallAsync <string>(ContractTypeEnum.Replacement.ToString());
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = approvalAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.Approval,
BlockchainID = blockchainID
},
true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = holdingAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.Holding,
BlockchainID = blockchainID
},
true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = holdingStorageAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.HoldingStorage,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = profileAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.Profile,
BlockchainID = blockchainID
},
true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = profileStorageAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.ProfileStorage,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = tokenAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.Token,
BlockchainID = blockchainID
},
true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = readingAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.Reading,
BlockchainID = blockchainID
},
true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = readingStorageAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.ReadingStorage,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = litigationAddress,
IsLatest = true,
Type = (int)ContractTypeEnum.Litigation,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = litigationStorageAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.LitigationStorage,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = replacementAddress,
IsLatest = isLatest,
Type = (int)ContractTypeEnum.Replacement,
BlockchainID = blockchainID
}, true);
}
private static async Task PopulateOriginalETHContracts(MySqlConnection connection, int blockchainID,
ulong fromBlockNumber)
{
await OTContract.InsertOrUpdate(connection, new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0xefa914bd9ea22848df987d344eb75bc4dfd92b42",
Type = (int)ContractTypeEnum.Profile,
IsLatest = false,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x407da012319e0d97c6f17ac72e8dd8a56c3e1556",
IsLatest = false,
Type = (int)ContractTypeEnum.Holding,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0xcae2df21e532d92b05d55c9ec75d579ea24d8521",
IsLatest = false,
Type = (int)ContractTypeEnum.Profile,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0xaa7a9ca87d3694b5755f213b5d04094b8d0f0a6f",
IsLatest = false,
Type = (int)ContractTypeEnum.Token,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x2be3cf5bd3609fd63b77aa40d0971c778db77c8a",
IsLatest = false,
Type = (int)ContractTypeEnum.HoldingStorage,
BlockchainID = blockchainID
}, true);
//TODO remove from database
//OTContract.InsertOrUpdate(connection,
// new OTContract(fromBlockNumber, fromBlockNumber)
// {
// Address = "0xf130e4df48aeef509a3e106223febcde1f9d1a4b",
// IsLatest = false,
// Type = (int)ContractTypeEnum.Holding,
// BlockchainID = blockchainID
// }, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x24d4ce2c8538290b9f283fad8ff423c601d1e114",
IsLatest = false,
Type = (int)ContractTypeEnum.Approval,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x306d5e8af6aeb73359dcc5e22c894e2588f76ffb",
IsLatest = false,
Type = (int)ContractTypeEnum.ProfileStorage,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x1ea5cc419c6167ae8712d5bb1ba67120f37cbec8",
IsLatest = false,
Type = (int)ContractTypeEnum.Profile,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x951a11842f8a81e8f1ab31d029e4f11cf80c697a",
IsLatest = false,
Type = (int)ContractTypeEnum.Profile,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0xc3af0b170a02d108f55e224d6b2605fc3e93d68e",
IsLatest = false,
Type = (int)ContractTypeEnum.Profile,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0xe7db7f713b2ea963d0dcb67514b50394f1295cc1",
IsLatest = false,
Type = (int)ContractTypeEnum.Profile,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x6763c4c8293796b8726d9450a988d374a8e9f994",
IsLatest = false,
Type = (int)ContractTypeEnum.Profile,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x2b29bcc72a7420f791722da79e255852f171b38d",
IsLatest = false,
Type = (int)ContractTypeEnum.Holding,
BlockchainID = blockchainID
}, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x283a70a58c65112da7ee377a21a1fd3286581ffb",
IsLatest = false,
Type = (int)ContractTypeEnum.Holding,
BlockchainID = blockchainID
}, true);
//TODO remove from database
//OTContract.InsertOrUpdate(connection,
// new OTContract(fromBlockNumber, fromBlockNumber)
// {
// Address = "0x8d92ee115c126b751cfb0849efa629d2aadb8753",
// IsLatest = false,
// Type = (int)ContractTypeEnum.Holding,
// BlockchainID = blockchainID
// }, true);
await OTContract.InsertOrUpdate(connection,
new OTContract(fromBlockNumber, fromBlockNumber)
{
Address = "0x87e04af76ecbb0114fc2d681c89a11eee457a268",
IsLatest = false,
Type = (int)ContractTypeEnum.Holding,
BlockchainID = blockchainID
}, true);
}
public override async Task <bool> Execute(Source source, BlockchainType blockchain, BlockchainNetwork network)
{
await using (var connection =
new MySqlConnection(OTHubSettings.Instance.MariaDB.ConnectionString))
{
int blockchainID = await GetBlockchainID(connection, blockchain, network);
var profiles = await OTContract.GetByTypeAndBlockchain(connection, (int)ContractTypeEnum.Profile, blockchainID);
foreach (var otContract in profiles)
{
var dates = connection.Query <DateTime?>(
@"select MAX(Timestamp) from otcontract_profile_identitycreated r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID
union all
select MAX(Timestamp) from otcontract_profile_identitytransferred r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID
union all
select MAX(Timestamp) from otcontract_profile_profilecreated r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID
union all
select MAX(Timestamp) from otcontract_profile_tokensdeposited r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID
union all
select MAX(Timestamp) from otcontract_profile_tokensreleased r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID
union all
select MAX(Timestamp) from otcontract_profile_tokensreserved r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID
union all
select MAX(Timestamp) from otcontract_profile_tokenstransferred r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID
union all
select MAX(Timestamp) from otcontract_profile_tokenswithdrawn r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID", new
{
contract = otContract.Address, blockchainID = blockchainID
}).Where(d => d.HasValue).Select(d => d.Value).ToArray();
if (dates.Any())
{
var maxDate = dates.Max();
if ((DateTime.Now - maxDate).TotalDays >= 30)
{
if (!otContract.IsArchived)
{
otContract.IsArchived = true;
await OTContract.Update(connection, otContract, false, true);
}
}
else
{
if (otContract.IsArchived)
{
otContract.IsArchived = false;
await OTContract.Update(connection, otContract, false, true);
}
}
}
else
{
if (!otContract.IsArchived)
{
otContract.IsArchived = true;
await OTContract.Update(connection, otContract, false, true);
}
}
}
profiles = await OTContract.GetByTypeAndBlockchain(connection, (int)ContractTypeEnum.Holding, blockchainID);
foreach (var otContract in profiles)
{
var dates = (await connection.QueryAsync <DateTime?>(@"select MAX(Timestamp) from otcontract_holding_offertask r
join ethblock b on r.BlockNumber = b.BlockNumber AND r.BlockchainID = b.BlockchainID
WHERE r.ContractAddress = @contract AND b.BlockchainID = r.BlockchainID
union all
select MAX(Timestamp) from otcontract_holding_ownershiptransferred r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID
union all
select MAX(r.Timestamp) from otcontract_holding_paidout r
join ethblock b on r.BlockNumber = b.BlockNumber AND b.BlockchainID = r.BlockchainID
WHERE r.ContractAddress = @contract AND r.BlockchainID = @blockchainID", new { contract = otContract.Address, blockchainID = blockchainID })).Where(d => d.HasValue).Select(d => d.Value).ToArray();
if (dates.Any())
{
var maxDate = dates.Max();
if ((DateTime.Now - maxDate).TotalDays >= 30)
{
if (!otContract.IsArchived)
{
otContract.IsArchived = true;
await OTContract.Update(connection, otContract, false, true);
}
}
else
{
if (otContract.IsArchived)
{
otContract.IsArchived = false;
await OTContract.Update(connection, otContract, false, true);
}
}
}
else
{
if (!otContract.IsArchived)
{
otContract.IsArchived = true;
await OTContract.Update(connection, otContract, false, true);
}
}
}
}
return(true);
}
private async Task Sync(MySqlConnection connection, OTContract contract, Event offerCreatedEvent,
Event offerFinalizedEvent, Event paidOutEvent, Event ownershipTransferredEvent, Event offerTaskEvent,
Source source, ulong start, ulong end, int blockchainID, Web3 cl)
{
Logger.WriteLine(source, "Syncing holding " + start + " to " + end);
var toBlock = new BlockParameter(end);
var createEvents = await offerCreatedEvent.GetAllChanges <Models.Program.OfferCreated>(
offerCreatedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var finalizedEvents = await offerFinalizedEvent.GetAllChangesDefault(
offerFinalizedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var payoutEvents = await paidOutEvent.GetAllChangesDefault(
paidOutEvent.CreateFilterInput(new BlockParameter(start), toBlock));
var ownershipTransferredEvents = await ownershipTransferredEvent.GetAllChangesDefault(
ownershipTransferredEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var offerTaskEvents = await offerTaskEvent.GetAllChangesDefault(
offerTaskEvent.CreateFilterInput(new BlockParameter(start), toBlock));
if (createEvents.Any())
{
Logger.WriteLine(source, "Found " + createEvents.Count + " offer created events");
}
if (finalizedEvents.Any())
{
Logger.WriteLine(source, "Found " + finalizedEvents.Count + " offer finalized events");
}
if (payoutEvents.Any())
{
Logger.WriteLine(source, "Found " + payoutEvents.Count + " offer payout events");
}
if (ownershipTransferredEvents.Any())
{
Logger.WriteLine(source, "Found " + ownershipTransferredEvents.Count + " ownership transferred events");
}
if (offerTaskEvents.Any())
{
Logger.WriteLine(source, "Found " + offerTaskEvents.Count + " offer task events");
}
foreach (EventLog <Models.Program.OfferCreated> eventLog in createEvents)
{
await ProcessOfferCreated(connection, blockchainID, cl, contract.Address, eventLog);
}
foreach (EventLog <List <ParameterOutput> > eventLog in finalizedEvents)
{
await ProcessOfferFinalised(connection, blockchainID, cl, contract.Address, eventLog);
}
foreach (EventLog <List <ParameterOutput> > eventLog in payoutEvents)
{
await ProcessPayout(connection, blockchainID, cl, contract.Address, eventLog);
}
var eth = new EthApiService(cl.Client);
foreach (EventLog <List <ParameterOutput> > eventLog in ownershipTransferredEvents)
{
var block = await BlockHelper.GetBlock(connection, eventLog.Log.BlockHash, eventLog.Log.BlockNumber,
cl, blockchainID);
var previousOwner = (string)eventLog.Event
.FirstOrDefault(e => e.Parameter.Name == "previousOwner").Result;
var newOwner = (string)eventLog.Event.FirstOrDefault(e => e.Parameter.Name == "newOwner")
.Result;
var transaction = eth.Transactions.GetTransactionByHash.SendRequestAsync(eventLog.Log.TransactionHash);
var receipt = eth.Transactions.GetTransactionReceipt.SendRequestAsync(eventLog.Log.TransactionHash);
await transaction;
await receipt;
OTContract_Holding_OwnershipTransferred.InsertIfNotExist(connection,
new OTContract_Holding_OwnershipTransferred
{
TransactionHash = eventLog.Log.TransactionHash,
BlockNumber = (UInt64)eventLog.Log.BlockNumber.Value,
ContractAddress = contract.Address,
NewOwner = newOwner,
PreviousOwner = previousOwner,
GasPrice = (UInt64)transaction.Result.GasPrice.Value,
GasUsed = (UInt64)receipt.Result.GasUsed.Value,
BlockchainID = blockchainID
});
}
foreach (EventLog <List <ParameterOutput> > eventLog in offerTaskEvents)
{
await ProcessOfferTasks(connection, blockchainID, cl, contract.Address, eventLog, eth);
}
contract.LastSyncedTimestamp = DateTime.Now;
contract.SyncBlockNumber = end;
await OTContract.Update(connection, contract, false, false);
}
private async Task Sync(MySqlConnection connection, Event profileCreatedEvent, Event identityCreatedEvent,
Event identityTransferredEvent, Event tokensDepositedEvent, Event tokensReleasedEvent,
Event tokensWithdrawnEvent, Event tokensTransferredEvent, Event tokensReservedEvent, OTContract contract,
Source source, Function createProfileFunction, Function transferProfileFunction, ulong start, ulong end,
int blockchainID, Web3 cl)
{
Logger.WriteLine(source, "Syncing profile " + start + " to " + end);
var toBlock = new BlockParameter(end);
var identityCreatedEvents = await identityCreatedEvent.GetAllChangesDefault(
identityCreatedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var identityTransferredEvents = await identityTransferredEvent.GetAllChangesDefault(
identityTransferredEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var profileCreatedEvents = await profileCreatedEvent.GetAllChangesDefault(
profileCreatedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var tokensDepositedEvents = await tokensDepositedEvent.GetAllChangesDefault(
tokensDepositedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var tokensReleasedEvents = await tokensReleasedEvent.GetAllChangesDefault(
tokensReleasedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var tokensWithdrawnEvents = await tokensWithdrawnEvent.GetAllChangesDefault(
tokensWithdrawnEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var tokensTransferredEvents = await tokensTransferredEvent.GetAllChangesDefault(
tokensTransferredEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var tokensReservedEvents = await tokensReservedEvent.GetAllChangesDefault(
tokensReservedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
if (identityCreatedEvents.Any())
{
Logger.WriteLine(source, "Found " + identityCreatedEvents.Count + " identity created events");
}
if (identityTransferredEvents.Any())
{
Logger.WriteLine(source, "Found " + identityTransferredEvents.Count + " identity transferred events");
}
if (profileCreatedEvents.Any())
{
Logger.WriteLine(source, "Found " + profileCreatedEvents.Count + " profile created events");
}
if (tokensDepositedEvents.Any())
{
Logger.WriteLine(source, "Found " + tokensDepositedEvents.Count + " tokens deposited events");
}
if (tokensReleasedEvents.Any())
{
Logger.WriteLine(source, "Found " + tokensReleasedEvents.Count + " tokens released events");
}
if (tokensWithdrawnEvents.Any())
{
Logger.WriteLine(source, "Found " + tokensWithdrawnEvents.Count + " tokens withdrawn events");
}
if (tokensTransferredEvents.Any())
{
Logger.WriteLine(source, "Found " + tokensTransferredEvents.Count + " tokens transferred events");
}
if (tokensReservedEvents.Any())
{
Logger.WriteLine(source, "Found " + tokensReservedEvents.Count + " tokens reserved events");
}
var eth = new EthApiService(cl.Client);
foreach (EventLog <List <ParameterOutput> > eventLog in identityCreatedEvents)
{
await ProcessIdentityCreated(connection, contract.Address, blockchainID, cl, eventLog, eth);
}
foreach (EventLog <List <ParameterOutput> > eventLog in profileCreatedEvents)
{
await ProcessProfileCreated(connection, contract.Address, createProfileFunction, blockchainID, cl, eventLog, eth);
}
foreach (EventLog <List <ParameterOutput> > eventLog in identityTransferredEvents)
{
var block = await BlockHelper.GetBlock(connection, eventLog.Log.BlockHash, eventLog.Log.BlockNumber,
cl, blockchainID);
var oldIdentity = (string)eventLog.Event
.FirstOrDefault(p => p.Parameter.Name == "oldIdentity").Result;
var newIdentity = (string)eventLog.Event
.FirstOrDefault(p => p.Parameter.Name == "newIdentity").Result;
var nodeId = HexHelper.ByteArrayToString((byte[])eventLog.Event
.FirstOrDefault(p => p.Parameter.Name == "nodeId").Result, false);
var transaction = eth.Transactions.GetTransactionByHash.SendRequestAsync(eventLog.Log.TransactionHash);
var receipt = eth.Transactions.GetTransactionReceipt.SendRequestAsync(eventLog.Log.TransactionHash);
await transaction;
await receipt;
var row = new OTContract_Profile_IdentityTransferred
{
TransactionHash = eventLog.Log.TransactionHash,
ContractAddress = contract.Address,
NewIdentity = newIdentity,
BlockNumber = (UInt64)eventLog.Log.BlockNumber.Value,
OldIdentity = oldIdentity,
NodeId = nodeId,
GasUsed = (UInt64)receipt.Result.GasUsed.Value,
GasPrice = (UInt64)transaction.Result.GasPrice.Value,
BlockchainID = blockchainID
};
var transferProfileFunctionData = transferProfileFunction.DecodeInput(transaction.Result.Input);
if (transferProfileFunctionData != null)
{
row.ManagementWallet = (string)transferProfileFunctionData.FirstOrDefault(p => p.Parameter.Name == "managementWallet")?.Result;
}
OTContract_Profile_IdentityTransferred.InsertIfNotExist(connection, row);
}
foreach (var group in tokensDepositedEvents.GroupBy(t => t.Log.TransactionHash))
{
await ProcessTokensDeposited(connection, contract.Address, blockchainID, cl, @group, eth);
}
foreach (var group in tokensReleasedEvents.GroupBy(t => t.Log.TransactionHash))
{
await ProcessTokensReleased(connection, contract.Address, blockchainID, cl, @group, eth);
}
foreach (var group in tokensWithdrawnEvents.GroupBy(t => t.Log.TransactionHash))
{
await ProcessTokensWithdrawn(connection, contract.Address, blockchainID, cl, @group, eth);
}
foreach (var group in tokensTransferredEvents.GroupBy(t => t.Log.TransactionHash))
{
if (OTContract_Profile_TokensTransferred.TransactionExists(connection, group.Key, blockchainID))
{
continue;
}
foreach (var eventLog in group)
{
var sender = (string)eventLog.Event.FirstOrDefault(p => p.Parameter.Name == "sender")
.Result;
var receiver = (string)eventLog.Event
.FirstOrDefault(p => p.Parameter.Name == "receiver")
.Result;
var amount = Web3.Convert.FromWei((BigInteger)eventLog.Event
.FirstOrDefault(p => p.Parameter.Name == "amount").Result);
var transaction = eth.Transactions.GetTransactionByHash.SendRequestAsync(eventLog.Log.TransactionHash);
var receipt = eth.Transactions.GetTransactionReceipt.SendRequestAsync(eventLog.Log.TransactionHash);
await transaction;
await receipt;
var block = await BlockHelper.GetBlock(connection, eventLog.Log.BlockHash,
eventLog.Log.BlockNumber,
cl, blockchainID);
OTContract_Profile_TokensTransferred.Insert(connection,
new OTContract_Profile_TokensTransferred
{
BlockNumber = block.BlockNumber,
TransactionHash = eventLog.Log.TransactionHash,
ContractAddress = contract.Address,
Amount = amount,
Receiver = receiver,
Sender = sender,
GasUsed = (UInt64)receipt.Result.GasUsed.Value,
GasPrice = (UInt64)transaction.Result.GasPrice.Value,
BlockchainID = blockchainID
});
}
}
foreach (var group in tokensReservedEvents.GroupBy(t => t.Log.TransactionHash))
{
if (OTContract_Profile_TokensReserved.TransactionExists(connection, group.Key, blockchainID))
{
continue;
}
foreach (var eventLog in group)
{
var block = await BlockHelper.GetBlock(connection, eventLog.Log.BlockHash,
eventLog.Log.BlockNumber,
cl, blockchainID);
var profile = (string)eventLog.Event.FirstOrDefault(p => p.Parameter.Name == "profile")
.Result;
var amountReserved = Web3.Convert.FromWei((BigInteger)eventLog.Event
.FirstOrDefault(p => p.Parameter.Name == "amountReserved").Result);
var transaction = eth.Transactions.GetTransactionByHash.SendRequestAsync(eventLog.Log.TransactionHash);
var receipt = eth.Transactions.GetTransactionReceipt.SendRequestAsync(eventLog.Log.TransactionHash);
await transaction;
await receipt;
OTContract_Profile_TokensReserved.Insert(connection,
new OTContract_Profile_TokensReserved
{
TransactionHash = eventLog.Log.TransactionHash,
BlockNumber = block.BlockNumber,
ContractAddress = contract.Address,
Profile = profile,
AmountReserved = amountReserved,
GasUsed = (UInt64)receipt.Result.GasUsed.Value,
GasPrice = (UInt64)transaction.Result.GasPrice.Value,
BlockchainID = blockchainID
});
}
}
contract.LastSyncedTimestamp = DateTime.Now;
contract.SyncBlockNumber = end;
await OTContract.Update(connection, contract, false, false);
}
public override async Task <bool> Execute(Source source, BlockchainType blockchain, BlockchainNetwork network)
{
ClientBase.ConnectionTimeout = new TimeSpan(0, 0, 5, 0);
await using (var connection =
new MySqlConnection(OTHubSettings.Instance.MariaDB.ConnectionString))
{
int blockchainID = await GetBlockchainID(connection, blockchain, network);
var cl = await GetWeb3(connection, blockchainID, blockchain);
var eth = new EthApiService(cl.Client);
foreach (var contract in await OTContract.GetByTypeAndBlockchain(connection, (int)ContractTypeEnum.Profile, blockchainID))
{
if (contract.IsArchived && contract.LastSyncedTimestamp.HasValue &&
(DateTime.Now - contract.LastSyncedTimestamp.Value).TotalDays <= 5)
{
#if DEBUG
Logger.WriteLine(source, " Skipping contract: " + contract.Address);
#endif
continue;
}
Logger.WriteLine(source, " Using contract: " + contract.Address);
string abi = AbiHelper.GetContractAbi(ContractTypeEnum.Profile, blockchain, network);
var profileContract = new Contract(eth, abi, contract.Address);
var profileCreatedEvent = profileContract.GetEvent("ProfileCreated");
var identityCreatedEvent = profileContract.GetEvent("IdentityCreated");
var identityTransferredEvent = profileContract.GetEvent("IdentityTransferred");
var tokensDepositedEvent = profileContract.GetEvent("TokensDeposited");
var tokensReleasedEvent = profileContract.GetEvent("TokensReleased");
var tokensWithdrawnEvent = profileContract.GetEvent("TokensWithdrawn");
var tokensTransferredEvent = profileContract.GetEvent("TokensTransferred");
var tokensReservedEvent = profileContract.GetEvent("TokensReserved");
Function createProfileFunction = profileContract.GetFunction("createProfile");
Function transferProfileFunction = profileContract.GetFunction("transferProfile");
ulong size = (ulong)10000;
BlockBatcher batcher = BlockBatcher.Start(contract.SyncBlockNumber, (ulong)LatestBlockNumber.Value, size,
async delegate(ulong start, ulong end)
{
await Sync(connection, profileCreatedEvent, identityCreatedEvent,
identityTransferredEvent,
tokensDepositedEvent,
tokensReleasedEvent, tokensWithdrawnEvent, tokensTransferredEvent,
tokensReservedEvent,
contract, source, createProfileFunction, transferProfileFunction, start,
end, blockchainID, cl);
});
await batcher.Execute();
}
await CreateMissingIdentities(connection, cl, blockchainID, blockchain, network);
}
return(true);
}
private async Task Sync(MySqlConnection connection, Event litigationInitiatedEvent,
Event litigationAnsweredEvent, Event litigationTimedOutEvent, Event litigationCompletedEvent,
Event replacementStartedEvent, OTContract contract, Source source, ulong start, ulong end, int blockchainID,
Web3 cl)
{
Logger.WriteLine(source, "Syncing litigation " + start + " to " + end);
var toBlock = new BlockParameter(end);
var litigationInitiatedEventsEventLogs = await litigationInitiatedEvent.GetAllChangesDefault(
litigationInitiatedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var litigationAnsweredEvents = await litigationAnsweredEvent.GetAllChangesDefault(
litigationAnsweredEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var litigationTimedOutEvents = await litigationTimedOutEvent.GetAllChangesDefault(
litigationTimedOutEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var litigationCompletedEvents = await litigationCompletedEvent.GetAllChangesDefault(
litigationCompletedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
var replacementStartedEvents = await replacementStartedEvent.GetAllChangesDefault(
replacementStartedEvent.CreateFilterInput(new BlockParameter(start),
toBlock));
if (litigationInitiatedEventsEventLogs.Any())
{
Logger.WriteLine(source, "Found " + litigationInitiatedEventsEventLogs.Count + " litigation initiated events");
}
if (litigationAnsweredEvents.Any())
{
Logger.WriteLine(source, "Found " + litigationAnsweredEvents.Count + " litigation answered completed events");
}
if (litigationTimedOutEvents.Any())
{
Logger.WriteLine(source, "Found " + litigationTimedOutEvents.Count + " litigation timed out events");
}
if (litigationCompletedEvents.Any())
{
Logger.WriteLine(source, "Found " + litigationCompletedEvents.Count + " litigation completed events");
}
if (replacementStartedEvents.Any())
{
Logger.WriteLine(source, "Found " + replacementStartedEvents.Count + " replacement started events");
}
//var childTask = Task.Run(async () =>
//{
// IEnumerable<IEventLog> items = litigationInitiatedEventsEventLogs
// .Union(litigationAnsweredEvents)
// .Union(litigationTimedOutEvents)
// .Union(litigationCompletedEvents)
// .Union(replacementStartedEvents);
// foreach (var eventLog in items)
// {
// await Program.GetEthBlock(connection, eventLog.Log.BlockHash, eventLog.Log.BlockNumber, cl);
// }
//});
var eth = new EthApiService(cl.Client);
foreach (EventLog <List <ParameterOutput> > eventLog in litigationInitiatedEventsEventLogs)
{
await ProcessLitigationInitiated(connection, blockchainID, cl, eventLog, eth);
}
foreach (EventLog <List <ParameterOutput> > eventLog in litigationAnsweredEvents)
{
await ProcessLitigationAnswered(connection, blockchainID, cl, eventLog, eth);
}
foreach (EventLog <List <ParameterOutput> > eventLog in litigationTimedOutEvents)
{
await ProcessLitigationTimedOut(connection, blockchainID, cl, eventLog, eth);
}
foreach (EventLog <List <ParameterOutput> > eventLog in litigationCompletedEvents)
{
await ProcessLitigationCompleted(connection, blockchainID, cl, eventLog, eth);
}
foreach (EventLog <List <ParameterOutput> > eventLog in replacementStartedEvents)
{
await ProcessReplacementStarted(connection, blockchainID, cl, eventLog, eth);
}
contract.LastSyncedTimestamp = DateTime.Now;
contract.SyncBlockNumber = end;
await OTContract.Update(connection, contract, false, false);
//childTask.Wait();
}
