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);
});
}
