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);
}
}
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);
}
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();
}
public static async Task <int> Execute(
IBlockchainStoreRepositoryFactory repositoryFactory,
BlockchainSourceConfiguration configuration,
FilterContainer filterContainer = null,
bool useGeth = false,
ILog log = null)
{
IWeb3 web3 =
useGeth
? new Web3Geth(configuration.BlockchainUrl)
: new Web3.Web3(configuration.BlockchainUrl);
using (var repositoryHandlerContext = new RepositoryHandlerContext(repositoryFactory))
{
var blockProcessor = BlockProcessorFactory
.Create(
web3,
repositoryHandlerContext.Handlers,
filters: filterContainer,
postVm: configuration.PostVm,
processTransactionsInParallel: configuration.ProcessBlockTransactionsInParallel);
var storageProcessingStrategy = new StorageProcessingStrategy(
repositoryHandlerContext, blockProcessor)
{
MinimumBlockNumber = configuration.MinimumBlockNumber ?? 0,
MinimumBlockConfirmations = configuration.MinimumBlockConfirmations ?? 0
};
var blockchainProcessor = new BlockchainProcessor(storageProcessingStrategy, log);
var stopWatch = Stopwatch.StartNew();
var result = await blockchainProcessor.ExecuteAsync(configuration.FromBlock, configuration.ToBlock)
.ConfigureAwait(false);
System.Console.WriteLine("Duration: " + stopWatch.Elapsed);
Debug.WriteLine($"Finished With Success: {result}");
System.Console.WriteLine("Finished. Success:" + result);
System.Console.ReadLine();
return(result ? 0 : 1);
}
}
public static async Task <int> Execute(
IBlockchainStoreRepositoryFactory repositoryFactory,
BlockchainSourceConfiguration configuration,
FilterContainer filterContainer = null,
bool useGeth = false)
{
IWeb3Wrapper web3 = new Web3Wrapper(
useGeth
? new Web3Geth(configuration.BlockchainUrl)
: new Web3.Web3(configuration.BlockchainUrl));
using (_strategy = new PersistenceStrategy(
repositoryFactory, filterContainer, minimumBlockNumber: configuration.MinimumBlockNumber ?? 0))
{
var blockProcessor = new BlockProcessorFactory()
.Create(
web3,
_strategy,
configuration.PostVm,
configuration.ProcessBlockTransactionsInParallel);
var blockchainProcessor = new BlockchainProcessor(_strategy, blockProcessor);
//this should not really be necessary
//but without it, when the process is killed early, some csv records where not being flushed
AppDomain.CurrentDomain.ProcessExit += (s, e) =>
{
_strategy?.Dispose();
};
var stopWatch = Stopwatch.StartNew();
var result = await blockchainProcessor.ExecuteAsync(configuration.FromBlock, configuration.ToBlock)
.ConfigureAwait(false);
System.Console.WriteLine("Duration: " + stopWatch.Elapsed);
Debug.WriteLine($"Finished With Success: {result}");
System.Console.WriteLine("Finished. Success:" + result);
System.Console.ReadLine();
return(result ? 0 : 1);
}
}
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);
}
