Example #1
0
        protected override void Load(ContainerBuilder builder)
        {
            builder.Register(c => EnrolledBalanceRepository.Create(_dbSettings.Nested(x => x.DataConnString), c.Resolve <ILogFactory>()))
            .As <IEnrolledBalanceRepository>()
            .SingleInstance();

            builder.Register(c => MatchingEngineCallsDeduplicationRepository.Create(_dbSettings.Nested(x => x.DataConnString), c.Resolve <ILogFactory>()))
            .As <IMatchingEngineCallsDeduplicationRepository>()
            .SingleInstance();

            builder.Register(c => CashinRepository.Create(
                                 _dbSettings.Nested(x => x.DataConnString),
                                 c.Resolve <ILogFactory>(),
                                 c.Resolve <IChaosKitty>()))
            .As <ICashinRepository>()
            .SingleInstance();

            builder.Register(c => DepositWalletLockRepository.Create(
                                 _dbSettings.Nested(x => x.DataConnString),
                                 c.Resolve <ILogFactory>()))
            .As <IDepositWalletLockRepository>()
            .SingleInstance();
        }
        private static async Task Execute(string settingsUrl, string blockchainType, string bitcoinCashNetwork)
        {
            {
                if (!Uri.TryCreate(settingsUrl, UriKind.Absolute, out _))
                {
                    throw new ArgumentException("SettingsUrl should be a valid uri", nameof(settingsUrl));
                }

                BCash.Instance.EnsureRegistered();
                var network          = Network.GetNetwork(bitcoinCashNetwork);
                var bcashNetwork     = network == Network.Main ? BCash.Instance.Mainnet : BCash.Instance.Regtest;
                var addressValidator = new AddressValidator(network, bcashNetwork);

                var logFactory = LogFactory.Create().AddConsole();

                var appSettings = new SettingsServiceReloadingManager <AppSettings>(settingsUrl, options => { });

                var enrolledBalanceStorage = AzureTableStorage <EnrolledBalanceEntity> .Create(
                    appSettings.Nested(p => p.BlockchainCashinDetectorJob.Db.DataConnString),
                    "EnrolledBalance",
                    logFactory);

                var enrolledBalanceRepository = EnrolledBalanceRepository.Create(
                    appSettings.Nested(p => p.BlockchainCashinDetectorJob.Db.DataConnString), logFactory);


                Console.WriteLine("Retrieving enrolled balances");
                var enrolledBalances = (await enrolledBalanceStorage.GetDataAsync())
                                       .Where(p => p.BlockchainType == blockchainType)
                                       .ToList();

                var counter = 0;
                foreach (var enrolledBalanceEntity in enrolledBalances)
                {
                    counter++;
                    Console.WriteLine("Processing " +
                                      $"{enrolledBalanceEntity} : {enrolledBalanceEntity.Balance} : {enrolledBalanceEntity.Block} " +
                                      $"--- {counter} of {enrolledBalances.Count}");

                    var address = addressValidator.GetBitcoinAddress(enrolledBalanceEntity.DepositWalletAddress);

                    if (address == null)
                    {
                        throw new ArgumentException(
                                  $"Unable to recognize address {enrolledBalanceEntity.DepositWalletAddress}",
                                  nameof(enrolledBalanceEntity.DepositWalletAddress));
                    }
                    var oldAdrr = address.ScriptPubKey.GetDestinationAddress(network).ToString();
                    var newAddr = address.ScriptPubKey.GetDestinationAddress(bcashNetwork).ToString();

                    Console.WriteLine("Processing " +
                                      $"{enrolledBalanceEntity.DepositWalletAddress}:{oldAdrr}:{newAddr} " +
                                      $"--- {enrolledBalanceEntity.Balance} " +
                                      $"--- {enrolledBalanceEntity.Block} " +
                                      $"| {counter} of {enrolledBalances.Count}");


                    if (!string.Equals(enrolledBalanceEntity.DepositWalletAddress, oldAdrr, StringComparison.InvariantCultureIgnoreCase))
                    {
                        var prevColor = Console.ForegroundColor;
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        Console.WriteLine($"{enrolledBalanceEntity.DepositWalletAddress} not in obsolete format. Old format: {oldAdrr} | New Format {newAddr}. Skipping.");
                        Console.ForegroundColor = prevColor;

                        continue;
                    }

                    await enrolledBalanceRepository.SetBalanceAsync(new DepositWalletKey(enrolledBalanceEntity.BlockchainAssetId,
                                                                                         enrolledBalanceEntity.BlockchainType,
                                                                                         newAddr),
                                                                    enrolledBalanceEntity.Balance,
                                                                    enrolledBalanceEntity.Block);

                    await enrolledBalanceRepository.ResetBalanceAsync(new DepositWalletKey(
                                                                          enrolledBalanceEntity.BlockchainAssetId,
                                                                          enrolledBalanceEntity.BlockchainType,
                                                                          oldAdrr), enrolledBalanceEntity.Block);
                }

                Console.WriteLine("All done");
            }
        }