private void DecodeTx() { try { BTx = Transaction.DecodeRawTx(Tx); TxInList = new BindingList <TxIn>(); foreach (var item in BTx.TxInList) { TxInList.Add(item); } // The following commented line throws Collection Read Only when item is added to BindingList! // TxInList = new BindingList<TxIn>(bTx.TxInList); ReceiveList = new BindingList <ReceivingAddress>(); foreach (var item in BTx.TxOutList) { ReceivingAddress r = new ReceivingAddress(); r.Address = GetAddressFromScript(item.PkScript); r.Payment = item.Amount * BitcoinConversions.Satoshi; ReceiveList.Add(r); } TotalInput = 0; TotalOutput = BTx.TxOutList.Select(x => x.Amount).Aggregate((a, b) => a + b) / BitcoinConversions.Satoshi; Fee = 0; MakeTxCommand.RaiseCanExecuteChanged(); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public Task PostAsync_WithValidArgs_ShouldGenerateNewAddress() { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, false, new Collection <ReceivingAddressReservation>()); var request = new CreateReceivingAddressesRequest(); this.pool .Setup(p => p.GenerateAddressAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(address); // Act. var result = await this.subject.PostAsync(request, cancellationToken); // Assert. var ok = Assert.IsType <OkObjectResult>(result); var response = Assert.IsType <CreateReceivingAddressesResponse>(ok.Value); Assert.Equal(address.Address, response.Address); this.pool.Verify(p => p.GenerateAddressAsync(cancellationToken), Times.Once()); })); }
public RuleTests() { this.property = new PropertyId(3); this.address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, true, new Collection <ReceivingAddressReservation>()); this.reservation = new ReceivingAddressReservation(Guid.NewGuid(), this.address, DateTime.Now, null); this.address.Reservations.Add(this.reservation); this.targetAmount = new PropertyAmount(100); this.targetConfirmation = 6; this.timeout = TimeSpan.FromHours(1); this.callback = new TokenReceivingCallback( new Callback( Guid.NewGuid(), IPAddress.Parse("192.168.1.2"), DateTime.Now, false, new Uri("http://localhost")), "timeout"); this.id = Guid.NewGuid(); this.subject = new Rule( this.property, this.reservation, this.targetAmount, this.targetConfirmation, this.timeout, this.callback, this.id); }
public Task GenerateAddressAsync_WhenInvoke_ShouldReturnGeneratedAddress() { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, false, new Collection <ReceivingAddressReservation>()); this.generator .Setup(g => g.GenerateAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(address.Address); this.repository .Setup(r => r.AddAsync(address.Address, It.IsAny <CancellationToken>())) .ReturnsAsync(address); // Act. var result = await this.subject.GenerateAddressAsync(cancellationToken); // Assert. Assert.Same(address, result); this.generator.Verify(g => g.GenerateAsync(cancellationToken), Times.Once()); this.repository.Verify(r => r.AddAsync(address.Address, CancellationToken.None), Times.Once()); })); }
public void Construct_WithValidArgsAndNotNullReleasedTime_ShouldBeSet() { // Arrange. var id = Guid.NewGuid(); var address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Mainnet1, false, new Collection <ReceivingAddressReservation>()); var reserved = DateTime.UtcNow; var released = reserved.Add(TimeSpan.FromHours(10)); // Act. var r = new ReceivingAddressReservation ( id, address, reserved, released ); // Assert. Assert.Equal(id, r.Id); Assert.Equal(address, r.Address); Assert.Equal(reserved, r.ReservedDate); Assert.Equal(released, r.ReleasedDate); }
public virtual Task <ReceivingAddress> AddAsync(BitcoinAddress address, CancellationToken cancellationToken) { var recv = new ReceivingAddress(Guid.NewGuid(), address, false, new Collection <ReceivingAddressReservation>()); this.receivingAddresses.Add(recv.Id, recv); return(Task.FromResult(recv)); }
internal ReceivingAddressValueObject(ReceivingAddress address) : this(ArgumentUtilities.NotNull(address, nameof(address)).City, address.Province, address.Area, address.Street, address.HouseNumber, address.Receiver, address.ContactPhone, address.Country) { }
public void Equals_WithDifferentId_ShouldReturnFalse() { var id = Guid.NewGuid(); var address = TestAddress.Mainnet1; var isLocked = false; var reservations = new Collection <ReceivingAddressReservation>(); var r = new ReceivingAddress(id, address, isLocked, reservations); ReceivingAddress another = new ReceivingAddress(Guid.NewGuid(), address, isLocked, reservations); Assert.False(r.Equals(another)); }
public Task TryLockAddressAsync_AndHaveAnAvailable_ShouldSuccess() { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, false, new Collection <ReceivingAddressReservation>()); var addresses = new[] { address }; this.repository .Setup(r => r.ListAsync(AddressFilter.Available, It.IsAny <CancellationToken>())) .ReturnsAsync(addresses); this.choser .Setup(c => c.Choose(addresses)) .Returns(address); this.repository .Setup(r => r.TryLockAsync(address.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(() => { var reservation = new ReceivingAddressReservation(Guid.NewGuid(), address, DateTime.Now, null); address.Reservations.Add(reservation); return reservation; }); // Act. var recv = await this.subject.TryLockAddressAsync(cancellationToken); // Assert. Assert.NotNull(recv); Assert.Equal(address, recv.Address); Assert.NotEqual(Guid.Empty, recv.Id); Assert.Null(recv.ReleasedDate); Assert.Equal(DateTime.Now, recv.ReservedDate, TimeSpan.FromSeconds(1)); this.repository.Verify( r => r.ListAsync(It.Is <AddressFilter>(f => f.HasFlag(AddressFilter.Available)), cancellationToken), Times.Once()); this.choser.Verify(c => c.Choose(addresses), Times.Once()); this.repository.Verify(r => r.TryLockAsync(address.Id, cancellationToken), Times.Once()); })); }
async Task CreateAddressAsync(ReceivingAddress address) { var entity = new Ztm.Data.Entity.Contexts.Main.ReceivingAddress() { Id = address.Id, Address = address.Address.ToString(), IsLocked = address.IsLocked, }; using (var db = this.db.CreateDbContext()) { await db.ReceivingAddresses.AddAsync(entity); await db.SaveChangesAsync(); } }
public EntityRuleRepositoryTests() { this.property = new PropertyId(3); this.address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, true, new Collection <ReceivingAddressReservation>()); this.reservation = new ReceivingAddressReservation(Guid.NewGuid(), address, DateTime.Now, null); this.address.Reservations.Add(this.reservation); this.callback = new Callback( Guid.NewGuid(), IPAddress.Parse("192.168.1.2"), DateTime.Now, false, new Uri("http://localhost/a")); this.rule = new Rule( this.property, this.reservation, new PropertyAmount(100), 6, TimeSpan.FromHours(1), new TokenReceivingCallback(this.callback, "timeout")); this.db = new TestMainDatabaseFactory(); try { this.callbacks = new Mock <ICallbackRepository>(); this.addresses = new Mock <IReceivingAddressRepository>(); this.callbacks .Setup(r => r.GetAsync(this.callback.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(this.callback); this.addresses .Setup(r => r.GetReservationAsync(this.reservation.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(this.reservation); this.subject = new EntityRuleRepository(this.db, this.callbacks.Object, this.addresses.Object); } catch { this.db.Dispose(); throw; } }
public void Construct_WithValidArgs_ShouldSuccess() { // Arrange. var id = Guid.NewGuid(); var address = TestAddress.Mainnet1; var isLocked = false; var reservations = new Collection <ReceivingAddressReservation>(); // Act. var r = new ReceivingAddress(id, address, isLocked, reservations); // Assert. Assert.Equal(id, r.Id); Assert.Equal(address, r.Address); Assert.Equal(isLocked, r.IsLocked); Assert.Same(reservations, r.Reservations); }
public override void WriteToBitcoinBuffer(byte[] buffer, int offset) { Version.WriteBytes(buffer, offset); ((ulong)Services).WriteBytes(buffer, offset + SERVICES_OFFSET); Timestamp.WriteBytes(buffer, offset + TIMESTAMP_OFFSET); EmittingAddress.WriteToBitcoinBuffer(buffer, offset + EMIT_ADDRESS_OFFSET); if (Version >= 106) { ReceivingAddress.WriteToBitcoinBuffer(buffer, offset + RECV_ADDRESS_OFFSET); Nonce.WriteBytes(buffer, offset + NONCE_OFFSET); SubVersionNum.WriteToBitcoinBuffer(buffer, offset + SUBVER_OFFSET); } if (Version >= 209) { StartHeight.WriteBytes(buffer, offset + STARTHEIGHT_OFFSET); } }
public virtual Task ReleaseAsync(Guid id, CancellationToken cancellationToken) { if (this.receivingAddresses.TryGetValue(id, out var recv)) { var reservations = recv.Reservations; var last = reservations.Last(); reservations.Remove(last); reservations.Add(new ReceivingAddressReservation(last.Id, last.Address, last.ReservedDate, DateTime.UtcNow)); var updated = new ReceivingAddress(recv.Id, recv.Address, false, reservations); this.receivingAddresses.Remove(id); this.receivingAddresses.Add(id, updated); } return(Task.CompletedTask); }
public void Equals_WithSameId_ShouldReturnTrue() { var id = Guid.NewGuid(); var address = TestAddress.Mainnet1; var isLocked = false; var reservations = new Collection <ReceivingAddressReservation>(); var r = new ReceivingAddress(id, address, isLocked, reservations); ReceivingAddress another; another = new ReceivingAddress(id, TestAddress.Regtest1, isLocked, reservations); Assert.True(r.Equals(another)); another = new ReceivingAddress(id, address, true, reservations); Assert.True(r.Equals(another)); another = new ReceivingAddress(id, address, isLocked, new Collection <ReceivingAddressReservation>()); Assert.True(r.Equals(another)); }
public ReceivingControllerTests() { this.address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, true, new Collection <ReceivingAddressReservation>()); this.reservation = new ReceivingAddressReservation(Guid.NewGuid(), this.address, DateTime.Now, null); this.address.Reservations.Add(this.reservation); this.config = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary <string, string>() { { "Api:Default:RequiredConfirmation", "6" }, { "Api:Default:TransactionTimeout", "1:00:00" }, }).Build(); this.pool = new Mock <IReceivingAddressPool>(); this.watcher = new Mock <ITokenReceivingWatcher>(); }
public WatchingTests() { var address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, true, new Collection <ReceivingAddressReservation>()); var reservation = new ReceivingAddressReservation(Guid.NewGuid(), address, DateTime.Now, null); address.Reservations.Add(reservation); this.rule = new Rule( new PropertyId(3), reservation, new PropertyAmount(100), 6, TimeSpan.FromHours(1), null); this.timer = new Timer(); this.subject = new Watching(this.rule, this.timer); }
public WatchingTests() { var address = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, true, new Collection <ReceivingAddressReservation>()); var reservation = new ReceivingAddressReservation(Guid.NewGuid(), address, DateTime.Now, null); address.Reservations.Add(reservation); this.rule = new Rule( new PropertyId(3), reservation, new PropertyAmount(100), 6, TimeSpan.FromHours(1), "timeout", new Callback(Guid.NewGuid(), IPAddress.Loopback, DateTime.Now, false, new Uri("http://localhost"))); this.timer = new Timer(); this.subject = new Watching(this.rule, this.timer); }
public virtual Task <ReceivingAddressReservation> TryLockAsync(Guid id, CancellationToken cancellationToken) { if (this.receivingAddresses.TryGetValue(id, out var recv)) { if (recv.IsLocked) { throw new InvalidOperationException(); } var lockedAt = DateTime.UtcNow; var reservation = new ReceivingAddressReservation(Guid.NewGuid(), recv, lockedAt, DateTime.MinValue); var reservations = recv.Reservations; reservations.Add(reservation); var updated = new ReceivingAddress(recv.Id, recv.Address, true, reservations); this.receivingAddresses.Remove(id); this.receivingAddresses.Add(id, updated); return(Task.FromResult(reservation)); } return(Task.FromResult <ReceivingAddressReservation>(null)); }
public EntityWatchRepositoryTests() { var network = ZcoinNetworks.Instance.Regtest; this.block1 = Block.CreateBlock(network); this.block2 = Block.CreateBlock(network); this.tx1 = Transaction.Create(network); this.tx1.Inputs.Add(TxIn.CreateCoinbase(102)); this.tx1.Outputs.Add(Money.Coins(30), TestAddress.Regtest1); this.tx1.Outputs.Add(Money.Coins(10), TestAddress.Regtest2); this.tx2 = Transaction.Create(network); this.tx2.Inputs.Add(TxIn.CreateCoinbase(103)); this.tx2.Outputs.Add(Money.Coins(40), TestAddress.Regtest2); this.tx3 = Transaction.Create(network); this.tx3.Inputs.Add(this.tx1, 0).ScriptSig = new Script(OpcodeType.OP_0); this.tx3.Outputs.Add(Money.Cents(1), TestAddress.Regtest2); this.tx4 = Transaction.Create(network); this.tx4.Inputs.Add(this.tx1, 1).ScriptSig = new Script(OpcodeType.OP_0); this.tx4.Outputs.Add(Money.Cents(1), TestAddress.Regtest2); this.block1.AddTransaction(this.tx1); this.block2.AddTransaction(this.tx2); this.block2.AddTransaction(this.tx3); this.block2.AddTransaction(this.tx4); this.block1.UpdateMerkleRoot(); this.block2.UpdateMerkleRoot(); this.address1 = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, true, new Collection <ReceivingAddressReservation>()); this.address2 = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest2, true, new Collection <ReceivingAddressReservation>()); this.reservation1 = new ReceivingAddressReservation(Guid.NewGuid(), this.address1, DateTime.Now, null); this.reservation2 = new ReceivingAddressReservation(Guid.NewGuid(), this.address2, DateTime.Now, null); this.rule1 = new Rule( new PropertyId(3), this.reservation1, new PropertyAmount(100), 6, TimeSpan.FromHours(1), new TokenReceivingCallback( new Callback( Guid.NewGuid(), IPAddress.Parse("192.168.1.2"), DateTime.Now, false, new Uri("http://localhost/a")), "timeout")); this.rule2 = new Rule( new PropertyId(4), this.reservation2, new PropertyAmount(40), 3, TimeSpan.FromMinutes(30), null); this.watch1 = new DomainModel( this.rule1, this.block1.GetHash(), this.tx1.GetHash(), this.rule1.AddressReservation.Address.Address, new PropertyAmount(100)); this.watch2 = new DomainModel( this.rule2, this.block1.GetHash(), this.tx1.GetHash(), this.rule2.AddressReservation.Address.Address, new PropertyAmount(10)); this.watch3 = new DomainModel( this.rule2, this.block2.GetHash(), this.tx2.GetHash(), this.rule2.AddressReservation.Address.Address, new PropertyAmount(10)); this.watch4 = new DomainModel( this.rule2, this.block2.GetHash(), this.tx3.GetHash(), this.rule2.AddressReservation.Address.Address, new PropertyAmount(10)); this.watch5 = new DomainModel( this.rule2, this.block2.GetHash(), this.tx4.GetHash(), this.rule2.AddressReservation.Address.Address, new PropertyAmount(10)); this.db = new TestMainDatabaseFactory(); try { this.rules = new Mock <IRuleRepository>(); this.rules .Setup(r => r.GetAsync(this.rule1.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(this.rule1); this.rules .Setup(r => r.GetAsync(this.rule2.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(this.rule2); this.subject = new EntityWatchRepository(this.db, this.rules.Object); } catch { this.db.Dispose(); throw; } }
public async Task ListUncompletedAsync_WithNonNullProperty_ShouldReturnUncompletedForThatProperty() { // Arrange. var property1 = new PropertyId(3); var property2 = new PropertyId(4); var address1 = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest1, true, new Collection <ReceivingAddressReservation>()); var address2 = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest2, true, new Collection <ReceivingAddressReservation>()); var address3 = new ReceivingAddress( Guid.NewGuid(), TestAddress.Regtest3, true, new Collection <ReceivingAddressReservation>()); var reservation1 = new ReceivingAddressReservation(Guid.NewGuid(), address1, DateTime.Now, null); var reservation2 = new ReceivingAddressReservation(Guid.NewGuid(), address2, DateTime.Now, DateTime.Now); var reservation3 = new ReceivingAddressReservation(Guid.NewGuid(), address2, DateTime.Now, DateTime.Now); var reservation4 = new ReceivingAddressReservation(Guid.NewGuid(), address2, DateTime.Now, null); var reservation5 = new ReceivingAddressReservation(Guid.NewGuid(), address3, DateTime.Now, null); address1.Reservations.Add(reservation1); address2.Reservations.Add(reservation2); address2.Reservations.Add(reservation3); address2.Reservations.Add(reservation4); address3.Reservations.Add(reservation5); var callback1 = new Callback( Guid.NewGuid(), IPAddress.Parse("192.168.1.2"), DateTime.Now, false, new Uri("http://localhost/a")); var rule1 = new Rule( property1, reservation1, new PropertyAmount(1), 1, TimeSpan.FromMinutes(1), null); var rule2 = new Rule( property2, reservation2, new PropertyAmount(2), 2, TimeSpan.FromMinutes(2), null); var rule3 = new Rule( property2, reservation3, new PropertyAmount(3), 3, TimeSpan.FromMinutes(3), null); var rule4 = new Rule( property2, reservation4, new PropertyAmount(4), 4, TimeSpan.FromMinutes(4), new TokenReceivingCallback(callback1, "1")); var rule5 = new Rule( property2, reservation5, new PropertyAmount(5), 5, TimeSpan.FromMinutes(5), null); await CreateAddressAsync(address1); await CreateAddressAsync(address2); await CreateAddressAsync(address3); await CreateAddressReservationAsync(reservation1); await CreateAddressReservationAsync(reservation2); await CreateAddressReservationAsync(reservation3); await CreateAddressReservationAsync(reservation4); await CreateAddressReservationAsync(reservation5); await CreateCallbackAsync(callback1); await this.subject.AddAsync(rule1, CancellationToken.None); await this.subject.AddAsync(rule2, CancellationToken.None); await this.subject.AddAsync(rule3, CancellationToken.None); await this.subject.AddAsync(rule4, CancellationToken.None); await this.subject.AddAsync(rule5, CancellationToken.None); await this.subject.SetSucceededAsync(rule2.Id, CancellationToken.None); await this.subject.SetTimedOutAsync(rule3.Id, CancellationToken.None); this.addresses .Setup(r => r.GetReservationAsync(reservation1.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(reservation1); this.addresses .Setup(r => r.GetReservationAsync(reservation2.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(reservation2); this.addresses .Setup(r => r.GetReservationAsync(reservation3.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(reservation3); this.addresses .Setup(r => r.GetReservationAsync(reservation4.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(reservation4); this.addresses .Setup(r => r.GetReservationAsync(reservation5.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(reservation5); this.callbacks .Setup(r => r.GetAsync(callback1.Id, It.IsAny <CancellationToken>())) .ReturnsAsync(callback1); // Act. var result = await this.subject.ListUncompletedAsync(property2, CancellationToken.None); // Assert. Assert.Collection( result, r => { Assert.Equal(rule4.AddressReservation, r.AddressReservation); Assert.Equal(rule4.Callback, r.Callback); Assert.Equal(rule4.Id, r.Id); Assert.Equal(rule4.OriginalTimeout, r.OriginalTimeout); Assert.Equal(rule4.Property, r.Property); Assert.Equal(rule4.TargetAmount, r.TargetAmount); Assert.Equal(rule4.TargetConfirmation, r.TargetConfirmation); }, r => { Assert.Equal(rule5.AddressReservation, r.AddressReservation); Assert.Null(r.Callback); Assert.Equal(rule5.Id, r.Id); Assert.Equal(rule5.OriginalTimeout, r.OriginalTimeout); Assert.Equal(rule5.Property, r.Property); Assert.Equal(rule5.TargetAmount, r.TargetAmount); Assert.Equal(rule5.TargetConfirmation, r.TargetConfirmation); }); }