static void Main(string[] args)
        {
            Console.WriteLine("Usage: dotnet IndexationStateEditor.dll read|write <bil-ethereum-worker-azure-storage-connection-string> ");

            if (args.Length != 2)
            {
                Console.WriteLine("Invalid parameters count");
                return;
            }

            var connectionString = ConstantReloadingManager.From(args[1]);
            var repository       = BlockchainIndexationStateRepository.Create(connectionString);

            if (args[0] == "read")
            {
                Read(repository).Wait();
            }
            else if (args[0] == "write")
            {
                Write(repository).Wait();
            }
            else
            {
                Console.WriteLine($"Unknown command: {args[0]}");
            }
        }
        static async Task Main(string[] args)
        {
            Console.WriteLine("Usage: dotnet IndexationStateEditor.dll read|write <bil-ethereum-worker-azure-storage-connection-string> ");

            if (args.Length != 2)
            {
                Console.WriteLine("Invalid parameters count");
                return;
            }

            if (args[0] == "read")
            {
                var connectionString = ConstantReloadingManager.From(args[1]);
                var repository       = BlockchainIndexationStateRepository.Create(connectionString);

                await Read(repository);
            }
            else if (args[0] == "write")
            {
                var connectionString = ConstantReloadingManager.From(args[1]);
                var repository       = BlockchainIndexationStateRepository.Create(connectionString);

                await Write(repository);
            }
            else if (args[0] == "read-file")
            {
                var sourceFilePath = args[1];

                await ReadFile(sourceFilePath);
            }
            else if (args[0] == "write-file")
            {
                var destinationFilePath = args[1];

                await WriteFile(destinationFilePath);
            }
            else
            {
                Console.WriteLine($"Unknown command: {args[0]}");
            }
        }
        private void LoadRepositories(
            ContainerBuilder builder)
        {
            var connectionString = _appSettings.ConnectionString(x => x.WorkerService.Db.DataConnString);

            // BalanceObservationTaskRepository

            builder
            .Register(x => BalanceObservationTaskRepository.Create
                      (
                          connectionString: connectionString
                      ))
            .As <IBalanceObservationTaskRepository>()
            .SingleInstance();

            // BlacklistedAddressRepository

            builder
            .Register(x => BlacklistedAddressRepository.Create
                      (
                          connectionString: connectionString,
                          logFactory: x.Resolve <ILogFactory>()
                      ))
            .As <IBlacklistedAddressRepository>()
            .SingleInstance();

            // BlockchainIndexationStateRepository

            builder
            .Register(x => BlockchainIndexationStateRepository.Create
                      (
                          connectionString: connectionString
                      ))
            .As <IBlockchainIndexationStateRepository>()
            .SingleInstance();

            // BlockIndexationLockRepository

            builder
            .Register(x => BlockIndexationLockRepository.Create
                      (
                          connectionString: connectionString,
                          logFactory: x.Resolve <ILogFactory>()
                      ))
            .As <IBlockIndexationLockRepository>()
            .SingleInstance();

            // ObservableBalanceRepository

            builder
            .Register(x => ObservableBalanceRepository.Create
                      (
                          connectionString: connectionString,
                          logFactory: x.Resolve <ILogFactory>()
                      ))
            .As <IObservableBalanceRepository>()
            .SingleInstance();

            // TransactionMonitoringTaskRepository

            builder
            .Register(x => TransactionMonitoringTaskRepository.Create
                      (
                          connectionString: connectionString
                      ))
            .As <ITransactionMonitoringTaskRepository>()
            .SingleInstance();

            // TransactionReceiptRepository

            builder
            .Register(x => TransactionReceiptRepository.Create
                      (
                          connectionString: connectionString,
                          logFactory: x.Resolve <ILogFactory>()
                      ))
            .As <ITransactionReceiptRepository>()
            .SingleInstance();

            // TransactionRepository

            builder
            .Register(x => TransactionRepository.Create
                      (
                          connectionString: connectionString,
                          logFactory: x.Resolve <ILogFactory>()
                      ))
            .As <ITransactionRepository>()
            .SingleInstance();
        }