public async Task Run()
{
var blockchainProxyService = new BlockchainProxyService("https://rinkeby.infura.io/v3/25e7b6dfc51040b3bfc0e47317d38f60");
var transactionHandler = new SimpleTransactionHandler();
var handlers = new HandlerContainer {
TransactionHandler = transactionHandler
};
//only tx sent to this address
var transactionFilter = TransactionFilter.To("0xc0e15e11306334258d61fee52a22d15e6c9c59e0");
var filter = new FilterContainer(transactionFilter);
var blockProcessor = BlockProcessorFactory.Create(
blockchainProxyService,
handlers,
filter,
processTransactionsInParallel: false);
var processingStrategy = new ProcessingStrategy(blockProcessor);
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var result = await blockchainProcessor.ExecuteAsync(2830143, 2830153);
Assert.True(result);
Assert.Equal(12, transactionHandler.TransactionsHandled.Count);
Assert.Empty(transactionHandler.ContractCreationTransactionsHandled);
}
public RepositoryHandlerContext(IBlockchainStoreRepositoryFactory repositoryFactory)
{
BlockRepository = repositoryFactory.CreateBlockRepository();
ContractRepository = repositoryFactory.CreateContractRepository();
TransactionRepository = repositoryFactory.CreateTransactionRepository();
AddressTransactionRepository = repositoryFactory.CreateAddressTransactionRepository();
TransactionLogRepository = repositoryFactory.CreateTransactionLogRepository();
TransactionVmStackRepository = repositoryFactory.CreateTransactionVmStackRepository();
_repositories.Add(BlockRepository);
_repositories.Add(ContractRepository);
_repositories.Add(TransactionLogRepository);
_repositories.Add(AddressTransactionRepository);
_repositories.Add(TransactionLogRepository);
_repositories.Add(TransactionVmStackRepository);
Handlers = new HandlerContainer
{
BlockHandler = new BlockRepositoryHandler(BlockRepository),
ContractHandler = new ContractRepositoryHandler(ContractRepository),
TransactionHandler = new TransactionRepositoryHandler(TransactionRepository),
TransactionLogHandler = new TransactionLogRepositoryHandler(TransactionLogRepository),
TransactionVmStackHandler = new TransactionVMStackRepositoryHandler(TransactionVmStackRepository)
};
}
// ######################## FUNCTIONALITY ######################## //
/// <summary>
/// Register a Handler
/// </summary>
/// <typeparam name="T">A Network Message Type. Needs to be derived from MessageBase</typeparam>
/// <param name="server">Register on server or on client?</param>
/// <param name="msgType">Message type number</param>
/// <param name="handler">Function handler which will be invoked when this type of message is recieved</param>
/// <param name="client">If registering on a client, this is the client to register to</param>
private static void RegisterHandler <T>(bool server, short msgType, ReceivedNetworkMessageDelegate <T> handler, NetworkClient client = null) where T : MessageBase, new()
{
// go through all handler containers and see if we allready have one for this msgType
foreach (HandlerContainerBase container in _handlerContainers)
{
if (container.MessageId == msgType) // If we found one, register the handler function
{
if (!server && container.Client != client)
{
continue;
}
HandlerContainer <T> c = (HandlerContainer <T>)container;
c.OnMessageReceived += handler;
return;
}
}
// if we reach this it means there is no container for this type of message yet, so we need to add one
HandlerContainer <T> newContainer = new HandlerContainer <T>(msgType, server, client);
newContainer.OnMessageReceived += handler;
_handlerContainers.Add(newContainer);
}
static RestHandler()
{
Type t = typeof(IHandlerServices);
Type ctxType = typeof(HttpContext);
_handler = t.Assembly.GetTypes().Where(type => !type.IsInterface && !type.IsAbstract && t.IsAssignableFrom(type)).ToDictionary(type => Regex.Replace(type.Name, "(\\w+)Handler", "$1").ToLower(), type =>
{
var container = new HandlerContainer
{
Handler = Activator.CreateInstance(type),
Methods = new Dictionary<string, HandlerMethodInfo>()
};
foreach (var method in type.GetMethods(System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public))
{
var name = method.Name.ToLower();
if (!container.Methods.ContainsKey(name))
{
var args = method.GetParameters();
var mi = new HandlerMethodInfo
{
ResultType = ServicesResult.GetResultType(method.ReturnType),
ArgCount = args.Length,
IsHttpContextArg = args.Length == 1 && args[0].ParameterType.Equals(ctxType),
Method = method
};
container.Methods.Add(name, mi);
}
}
return container;
});
}
public async Task Run()
{
var web3 = new Web3.Web3(TestConfiguration.BlockchainUrls.Infura.Rinkeby);
var transactionHandler = new SimpleTransactionHandler();
var handlers = new HandlerContainer {
TransactionHandler = transactionHandler
};
//only tx sent to this address
var transactionFilter = TransactionFilter.To("0xc0e15e11306334258d61fee52a22d15e6c9c59e0");
var filter = new FilterContainer(transactionFilter);
var blockProcessor = BlockProcessorFactory.Create(
web3,
handlers,
filter,
processTransactionsInParallel: false);
var processingStrategy = new ProcessingStrategy(blockProcessor);
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var result = await blockchainProcessor.ExecuteAsync(2830143, 2830153);
Assert.True(result);
Assert.Equal(12, transactionHandler.TransactionsHandled.Count);
Assert.Empty(transactionHandler.ContractCreationTransactionsHandled);
}
public async Task IndexingTransferFunctions()
{
using (var azureSearchService = new AzureSearchService(AzureSearchServiceName, _azureSearchApiKey))
{
await azureSearchService.DeleteIndexAsync(AzureTransferIndexName);
using (var azureFunctionMessageIndexer =
await azureSearchService.GetOrCreateFunctionIndex <TransferFunction>(indexName: AzureTransferIndexName))
{
var transferHandler =
new FunctionIndexTransactionHandler <TransferFunction>(azureFunctionMessageIndexer);
var web3 = new Web3.Web3("https://rinkeby.infura.io/v3/25e7b6dfc51040b3bfc0e47317d38f60");
var blockchainProxy = new BlockchainProxyService(web3);
var handlers = new HandlerContainer {
TransactionHandler = transferHandler
};
var blockProcessor = BlockProcessorFactory.Create(blockchainProxy, handlers);
var processingStrategy = new ProcessingStrategy(blockProcessor);
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var blockRange = new BlockRange(3146684, 3146694);
await blockchainProcessor.ProcessAsync(blockRange);
await Task.Delay(TimeSpan.FromSeconds(5));
//ensure we have written the expected docs to the index
Assert.Equal(3, await azureFunctionMessageIndexer.DocumentCountAsync());
}
await azureSearchService.DeleteIndexAsync(AzureTransferIndexName);
}
}
static void Main(string[] args)
{
// This particular sample should be run with the following CLI args
// A random contract on the Rinkeby network was chosen as an example
// --Blockchain rinkeby --FromBlock 3146650
System.Console.WriteLine("CLI args: " + string.Join(" ", args));
var appConfig = ConfigurationUtils.Build(args).AddConsoleLogging();
var targetBlockchain = BlockchainSourceConfigurationFactory.Get(appConfig);
System.Console.WriteLine($"Target Node/Name (URL): {targetBlockchain.Name}, {targetBlockchain.BlockchainUrl}");
//only process transactions that created or called our contract
var filters = new ContractSpecificFilterBuilder(ContractAddress).Filters;
//for specific functions on our contract, output the name and input arg values
var transactionRouter = new TransactionRouter();
transactionRouter.AddContractCreationHandler(
new ContractCreationPrinter <GlitchGoonsItemConstructor>());
transactionRouter.AddTransactionHandler(new FunctionPrinter <BuyApprenticeFunction>());
transactionRouter.AddTransactionHandler(new FunctionPrinter <OpenChestFunction>());
//for specific events, output the values
var transactionLogRouter = new TransactionLogRouter();
transactionLogRouter.AddHandler(new EventPrinter <TransferEvent>());
var handlers = new HandlerContainer()
{
TransactionHandler = transactionRouter,
TransactionLogHandler = transactionLogRouter,
};
var blockchainProxy = new BlockchainProxyService(targetBlockchain.BlockchainUrl);
var blockProcessor = BlockProcessorFactory.Create(
blockchainProxy,
handlers,
filters,
processTransactionsInParallel: false);
var strategy = new ProcessingStrategy(blockProcessor)
{
MinimumBlockConfirmations = 6 //wait for 6 block confirmations before processing block
};
var blockchainProcessor = new BlockchainProcessor(strategy);
blockchainProcessor.ExecuteAsync
(targetBlockchain.FromBlock, targetBlockchain.ToBlock)
.GetAwaiter().GetResult();
System.Console.WriteLine($"Contracts Created: {transactionRouter.ContractsCreated}");
System.Console.WriteLine($"Transactions Handled: {transactionRouter.TransactionsHandled}");
System.Console.ReadLine();
}
private void LoadModules()
{
logger.LogDebug("Loading modules for development server.");
HandlerContainer = new HandlerContainer(logger, testRemoteConnection);
dynamic binPath = Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location) + Path.DirectorySeparatorChar;
handlerLoader = new HandlerLoader(logger, testRemoteConnection, binPath, HandlerContainer);
handlerLoader.RegisterAllHandlersToContainer();
logger.LogDebug("Modules loaded.");
}
public void RegisterHandler(int msgID, DelegateRecvHandler handler, int timeout = 0)
{
HandlerContainer container = new HandlerContainer();
if (0 < timeout)
{
container.timer = new System.Timers.Timer();
container.timer.Interval = timeout * 1000;
container.timer.AutoReset = false;
container.timer.Elapsed += delegate { HandlerContainer.Timeout(this); };
container.timer.Start();
}
container.handler = handler;
_dictHandler [msgID] = container;
}
public static IBlockProcessor Create(
IBlockchainProxyService web3, IVmStackErrorChecker vmStackErrorChecker,
HandlerContainer handlers, FilterContainer filters = null, bool postVm = false, bool processTransactionsInParallel = true)
{
var transactionLogProcessor = new TransactionLogProcessor(
filters?.TransactionLogFilters,
handlers.TransactionLogHandler);
var contractTransactionProcessor = new ContractTransactionProcessor(
web3, vmStackErrorChecker, handlers.ContractHandler,
handlers.TransactionHandler, handlers.TransactionVmStackHandler);
var contractCreationTransactionProcessor = new ContractCreationTransactionProcessor(
web3, handlers.ContractHandler,
handlers.TransactionHandler);
var valueTransactionProcessor = new ValueTransactionProcessor(
handlers.TransactionHandler);
var transactionProcessor = new TransactionProcessor(
web3,
contractTransactionProcessor,
valueTransactionProcessor,
contractCreationTransactionProcessor,
transactionLogProcessor,
filters?.TransactionFilters,
filters?.TransactionReceiptFilters,
filters?.TransactionAndReceiptFilters);
if (postVm)
{
return new BlockVmPostProcessor(
web3, handlers.BlockHandler, transactionProcessor)
{
ProcessTransactionsInParallel = processTransactionsInParallel
}
}
;
transactionProcessor.ContractTransactionProcessor.EnabledVmProcessing = false;
return(new BlockProcessor(
web3, handlers.BlockHandler, transactionProcessor, filters?.BlockFilters)
{
ProcessTransactionsInParallel = processTransactionsInParallel
});
}
}
public override void OnReceive(Gamnet.Buffer buf)
{
recvBuffer += buf;
while (recvBuffer.Size() >= PACKET_HEADER_SIZE)
{
ushort packetLength = BitConverter.ToUInt16(recvBuffer.buffer, recvBuffer.readIndex + PACKET_SIZE_OFFSET);
if (packetLength > Gamnet.Buffer.BUFFER_SIZE)
{
throw new Exception(string.Format("The packet length is greater than the buffer max length."));
}
if (packetLength > recvBuffer.Size())
{
return;
}
Gamnet.Buffer tmpBuffer = new Gamnet.Buffer(recvBuffer);
int msgID = BitConverter.ToInt32(tmpBuffer.buffer, tmpBuffer.readIndex + MSGID_OFFSET);
if (false == _dictHandler.ContainsKey(msgID))
{
UnityEngine.Debug.Log("msg_id:" + msgID + " is not registered");
ErrorEvent evt = new ErrorEvent();
evt.session = this;
evt.error = new System.Collections.Generic.KeyNotFoundException();
eventQueue.Enqueue(evt);
return;
}
HandlerContainer container = _dictHandler[msgID];
if (null != container.timer)
{
container.timer.Stop();
container.timer.Close();
}
tmpBuffer.readIndex += PACKET_HEADER_SIZE;
try
{
container.handler(tmpBuffer);
}
catch (System.Exception) {}
recvBuffer.readIndex += packetLength;
recvBuffer = new Gamnet.Buffer(recvBuffer);
}
}
/// <summary>
/// Unregister a Handler
/// </summary>
/// <typeparam name="T">A Network Message Type. Needs to be derived from MessageBase</typeparam>
/// <param name="msgType">Message type number</param>
/// <param name="handler">Delegate to unregister</param>
public static void UnregisterHandler <T>(short msgType, ReceivedNetworkMessageDelegate <T> handler) where T : MessageBase, new()
{
// go through all handler containers and look for the handler
foreach (HandlerContainerBase container in _handlerContainers)
{
if (container.MessageId == msgType) // if we found the right handler container, unregister the delegate
{
HandlerContainer <T> c = (HandlerContainer <T>)container;
if (!c.UnregisterDelegate(handler))
{
continue;
}
return;
}
}
Debug.LogWarningFormat("Could not find {0} in registered handlers", handler.Method.Name);
}
public async Task IndexingTransferFunctions()
{
using (var azureSearchService = new AzureSearchService(AzureSearchServiceName, _azureSearchApiKey))
{
await azureSearchService.DeleteIndexAsync(AzureTransferIndexName);
try
{
using (var azureFunctionMessageIndexer =
await azureSearchService.CreateFunctionIndexer <TransferFunction>(
indexName: AzureTransferIndexName))
{
var transferHandler =
new FunctionIndexTransactionHandler <TransferFunction>(azureFunctionMessageIndexer);
var web3 = new Web3.Web3(TestConfiguration.BlockchainUrls.Infura.Rinkeby);
var blockchainProxy = new BlockchainProxyService(web3);
var handlers = new HandlerContainer {
TransactionHandler = transferHandler
};
var blockProcessor = BlockProcessorFactory.Create(blockchainProxy, handlers);
var processingStrategy = new ProcessingStrategy(blockProcessor);
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var blockRange = new BlockRange(3146684, 3146694);
await blockchainProcessor.ProcessAsync(blockRange);
await Task.Delay(TimeSpan.FromSeconds(5));
//ensure we have written the expected docs to the index
Assert.Equal(3, await azureFunctionMessageIndexer.DocumentCountAsync());
}
}
finally
{
await azureSearchService.DeleteIndexAsync(AzureTransferIndexName);
}
}
}
public async Task Run()
{
var web3 = new Web3.Web3(TestConfiguration.BlockchainUrls.Infura.Rinkeby);
var transactionHandler = new SimpleTransactionHandler();
var handlers = new HandlerContainer {
TransactionHandler = transactionHandler
};
var blockProcessor = BlockProcessorFactory.Create(
web3,
handlers,
processTransactionsInParallel: false);
var processingStrategy = new ProcessingStrategy(blockProcessor);
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var result = await blockchainProcessor.ExecuteAsync(2830144, 2830145);
Assert.True(result);
Assert.Equal(20, transactionHandler.TransactionsHandled?.Count);
Assert.Equal(5, transactionHandler.ContractCreationsHandled?.Count);
}
public async Task Run()
{
var contractAddresses = new[]
{ "0xd2e474c616cc60fb95d8b5f86c1043fa4552611b" };
const ulong FromBlock = 4347;
const ulong ToBlock = 4347;
var web3geth = new Web3Geth();
var blockchainProxyService = new BlockchainProxyService(web3geth);
var transactionHandler = new SimpleTransactionHandler();
var vmStackHandler = new VmStackHandler();
var contractHandler = new ContractHandler();
foreach (var contractAddress in contractAddresses)
{
contractHandler.ContractAddresses.Add(contractAddress);
}
var handlers = new HandlerContainer {
ContractHandler = contractHandler, TransactionHandler = transactionHandler, TransactionVmStackHandler = vmStackHandler
};
var blockProcessor = BlockProcessorFactory.Create(
blockchainProxyService,
handlers,
processTransactionsInParallel: false,
postVm: true);
var processingStrategy = new ProcessingStrategy(blockProcessor)
{
};
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var result = await blockchainProcessor.ExecuteAsync(FromBlock, ToBlock);
Assert.True(result);
}
public async Task Run()
{
var blockchainProxy = new BlockchainProxyService("https://rinkeby.infura.io/v3/25e7b6dfc51040b3bfc0e47317d38f60");
var transactionHandler = new SimpleTransactionHandler();
var handlers = new HandlerContainer {
TransactionHandler = transactionHandler
};
var blockProcessor = BlockProcessorFactory.Create(
blockchainProxy,
handlers,
processTransactionsInParallel: false);
var processingStrategy = new ProcessingStrategy(blockProcessor);
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var result = await blockchainProcessor.ExecuteAsync(2830144, 2830145);
Assert.True(result);
Assert.Equal(20, transactionHandler.TransactionsHandled?.Count);
Assert.Equal(5, transactionHandler.ContractCreationsHandled?.Count);
}
public void ShouldUnsubscribeFromStaleEvents()
{
eventBus.IsAsynchronous = false;
var mock = new HandlerContainer();
eventBus.Subscribe<Event1>(mock.OnFire);
eventBus.SubscribedCount<Event1>().ShouldBe(1);
// ---
mock.Dispose();
GC.Collect();
eventBus.Publish(new Event1());
eventBus.SubscribedCount<Event1>().ShouldBe(1);
mock = null;
GC.Collect(); // Only become stale after variable ref is released.
eventBus.Publish(new Event1());
eventBus.SubscribedCount<Event1>().ShouldBe(0);
}
public static IBlockProcessor Create(IBlockchainProxyService web3,
HandlerContainer handlers, FilterContainer filters = null, bool postVm = false, bool processTransactionsInParallel = true)
{
return(Create(web3, new VmStackErrorCheckerWrapper(), handlers, filters, postVm, processTransactionsInParallel));
}
public AuthBusinessAccess(IAuthDataAccess authDataAccess, HandlerContainer handlerContainer)
{
this.authDataAccess = authDataAccess;
this.handlerContainer = handlerContainer;
}