public void CanTrack3()
{
using (var tester = ServerTester.Create())
{
var key = new BitcoinExtKey(new ExtKey(), tester.Network);
var pubkey = CreateDerivationStrategy(key.Neuter());
tester.Client.Track(pubkey);
tester.Client.GetUTXOs(pubkey, null, false); //Track things do not wait
var events = tester.Client.CreateNotificationSession();
events.ListenDerivationSchemes(new[] { pubkey });
var id = tester.RPC.SendToAddress(AddressOf(key, "0/0"), Money.Coins(1.0m));
id = tester.RPC.SendToAddress(AddressOf(key, "0/1"), Money.Coins(1.1m));
id = tester.RPC.SendToAddress(AddressOf(key, "0/2"), Money.Coins(1.2m));
id = tester.RPC.SendToAddress(AddressOf(key, "0"), Money.Coins(1.2m));
id = tester.RPC.SendToAddress(AddressOf(key, "1"), Money.Coins(1.2m));
events.NextEvent(Timeout);
events.NextEvent(Timeout);
events.NextEvent(Timeout);
events.NextEvent(Timeout);
events.NextEvent(Timeout);
var utxo = tester.Client.GetUTXOs(pubkey, null);
tester.RPC.Generate(1);
var prev = utxo;
utxo = tester.Client.GetUTXOs(pubkey, prev);
Assert.True(utxo.HasChanges);
Assert.Equal(5, utxo.Confirmed.UTXOs.Count);
utxo = tester.Client.GetUTXOs(pubkey, utxo, false);
Assert.False(utxo.HasChanges);
}
}
public void CanTrack3()
{
using (var tester = ServerTester.Create())
{
var key = new BitcoinExtKey(new ExtKey(), tester.Network);
var pubkey = CreateDerivationStrategy(key.Neuter());
tester.Client.Track(pubkey);
tester.Client.Sync(pubkey, null, null, true); //Track things do not wait
var id = tester.RPC.SendToAddress(AddressOf(key, "0/0"), Money.Coins(1.0m));
id = tester.RPC.SendToAddress(AddressOf(key, "0/1"), Money.Coins(1.1m));
id = tester.RPC.SendToAddress(AddressOf(key, "0/2"), Money.Coins(1.2m));
UTXOChanges utxo = null;
while (utxo == null || utxo.Unconfirmed.UTXOs.Count != 3)
{
utxo = tester.Client.Sync(pubkey, null, null);
}
tester.RPC.Generate(1);
utxo = tester.Client.Sync(pubkey, utxo);
Assert.True(utxo.HasChanges);
Assert.Equal(3, utxo.Confirmed.UTXOs.Count);
utxo = tester.Client.Sync(pubkey, utxo, true);
Assert.False(utxo.HasChanges);
}
}
public async Task <StoresController> CreateStoreAsync()
{
ExtKey = new ExtKey().GetWif(parent.Network);
var store = parent.PayTester.GetController <StoresController>(UserId);
await store.CreateStore(new CreateStoreViewModel()
{
Name = "Test Store"
});
StoreId = store.CreatedStoreId;
DerivationScheme = new DerivationStrategyFactory(parent.Network).Parse(ExtKey.Neuter().ToString() + "-[legacy]");
await store.UpdateStore(StoreId, new StoreViewModel()
{
SpeedPolicy = SpeedPolicy.MediumSpeed
});
await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
{
CryptoCurrency = "BTC",
DerivationSchemeFormat = "BTCPay",
DerivationScheme = DerivationScheme.ToString(),
}, "Save");
return(store);
}
public void CanRebaseKeypathInPSBT()
{
var masterExtkey = new BitcoinExtKey("tprv8ZgxMBicQKsPd9TeAdPADNnSyH9SSUUbTVeFszDE23Ki6TBB5nCefAdHkK8Fm3qMQR6sHwA56zqRmKmxnHk37JkiFzvncDqoKmPWubu7hDF", Network.TestNet);
var masterFP = masterExtkey.GetPublicKey().GetHDFingerPrint();
var accountExtKey = masterExtkey.Derive(new KeyPath("0'/0'/0'"));
var accountRootedKeyPath = new KeyPath("0'/0'/0'").ToRootedKeyPath(masterExtkey);
uint hardenedFlag = 0x80000000U;
retry:
Transaction funding = masterExtkey.Network.CreateTransaction();
funding.Outputs.Add(Money.Coins(2.0m), accountExtKey.Derive(0 | hardenedFlag).ScriptPubKey);
funding.Outputs.Add(Money.Coins(2.0m), accountExtKey.Derive(1 | hardenedFlag).ScriptPubKey);
Transaction tx = masterExtkey.Network.CreateTransaction();
tx.Version = 2;
tx.Outputs.Add(Money.Coins(1.49990000m), new Script(Encoders.Hex.DecodeData("0014d85c2b71d0060b09c9886aeb815e50991dda124d")));
tx.Outputs.Add(Money.Coins(1.00000000m), new Script(Encoders.Hex.DecodeData("001400aea9a2e5f0f876a588df5546e8742d1d87008f")));
tx.Inputs.Add(funding, 0);
tx.Inputs.Add(funding, 1);
var psbt = PSBT.FromTransaction(tx, Network.TestNet);
psbt.AddTransactions(funding);
psbt.AddKeyPath(accountExtKey, Tuple.Create(new KeyPath(0 | hardenedFlag), funding.Outputs[0].ScriptPubKey),
Tuple.Create(new KeyPath(1 | hardenedFlag), funding.Outputs[1].ScriptPubKey));
Assert.Equal(new KeyPath(0 | hardenedFlag), psbt.Inputs[0].HDKeyPaths[accountExtKey.Derive(0 | hardenedFlag).GetPublicKey()].KeyPath);
Assert.Equal(new KeyPath(1 | hardenedFlag), psbt.Inputs[1].HDKeyPaths[accountExtKey.Derive(1 | hardenedFlag).GetPublicKey()].KeyPath);
Assert.Equal(accountExtKey.GetPublicKey().GetHDFingerPrint(), psbt.Inputs[0].HDKeyPaths[accountExtKey.Derive(0 | hardenedFlag).GetPublicKey()].MasterFingerprint);
Assert.Equal(accountExtKey.GetPublicKey().GetHDFingerPrint(), psbt.Inputs[1].HDKeyPaths[accountExtKey.Derive(1 | hardenedFlag).GetPublicKey()].MasterFingerprint);
var memento = psbt.Clone();
psbt.GlobalXPubs.Add(accountExtKey.Neuter(), new RootedKeyPath(accountExtKey, new KeyPath()));
var rebasingKeyPath = new RootedKeyPath(masterExtkey.GetPublicKey().GetHDFingerPrint(), new KeyPath("0'/0'/0'"));
psbt.RebaseKeyPaths(accountExtKey, rebasingKeyPath);
Assert.Equal(psbt.GlobalXPubs.Single().Value, rebasingKeyPath);
psbt.ToString();
psbt = PSBT.Parse(psbt.ToHex(), psbt.Network);
Assert.Equal(psbt.GlobalXPubs.Single().Value, rebasingKeyPath);
Assert.Equal(new KeyPath("0'/0'/0'").Derive(0 | hardenedFlag), psbt.Inputs[0].HDKeyPaths[accountExtKey.Derive(0 | hardenedFlag).GetPublicKey()].KeyPath);
Assert.Equal(new KeyPath("0'/0'/0'").Derive(1 | hardenedFlag), psbt.Inputs[1].HDKeyPaths[accountExtKey.Derive(1 | hardenedFlag).GetPublicKey()].KeyPath);
Assert.Equal(masterExtkey.GetPublicKey().GetHDFingerPrint(), psbt.Inputs[0].HDKeyPaths[accountExtKey.Derive(0 | hardenedFlag).GetPublicKey()].MasterFingerprint);
Assert.Equal(masterExtkey.GetPublicKey().GetHDFingerPrint(), psbt.Inputs[1].HDKeyPaths[accountExtKey.Derive(1 | hardenedFlag).GetPublicKey()].MasterFingerprint);
Assert.NotEqual(Money.Zero, psbt.GetBalance(ScriptPubKeyType.Legacy, masterExtkey));
Assert.Equal(psbt.GetBalance(ScriptPubKeyType.Legacy, masterExtkey), psbt.GetBalance(ScriptPubKeyType.Legacy, accountExtKey, accountRootedKeyPath));
if (hardenedFlag != 0) // If hardened, we can't get the balance from the account pubkey
{
Assert.Equal(Money.Zero, psbt.GetBalance(ScriptPubKeyType.Legacy, accountExtKey.Neuter(), accountRootedKeyPath));
}
else
{
Assert.Equal(psbt.GetBalance(ScriptPubKeyType.Legacy, masterExtkey), psbt.GetBalance(ScriptPubKeyType.Legacy, accountExtKey.Neuter(), accountRootedKeyPath));
}
Assert.Equal(Money.Zero, psbt.GetBalance(ScriptPubKeyType.Legacy, masterExtkey.Derive(new KeyPath("0'/0'/1'")), new KeyPath("0'/0'/1'").ToRootedKeyPath(masterFP)));
Assert.Equal(Money.Zero, psbt.GetBalance(ScriptPubKeyType.Legacy, masterExtkey.Neuter())); // Can't derive!
if (hardenedFlag != 0)
{
hardenedFlag = 0;
goto retry;
}
}
public void CanTrackSeveralTransactions()
{
using (var tester = ServerTester.Create())
{
var key = new BitcoinExtKey(new ExtKey(), tester.Network);
var pubkey = CreateDerivationStrategy(key.Neuter());
tester.Client.Track(pubkey);
var utxo = tester.Client.Sync(pubkey, null, null, true); //Track things do not wait
var addresses = new HashSet <Script>();
tester.RPC.ImportPrivKey(PrivateKeyOf(key, "0/0"));
var id = tester.RPC.SendToAddress(AddressOf(key, "0/0"), Money.Coins(1.0m));
addresses.Add(AddressOf(key, "0/0").ScriptPubKey);
utxo = tester.Client.Sync(pubkey, utxo);
Assert.True(utxo.HasChanges);
var coins = Money.Coins(1.0m);
int i = 0;
for (i = 0; i < 20; i++)
{
LockTestCoins(tester.RPC, addresses);
var spendable = tester.RPC.ListUnspent(0, 0);
coins = coins - Money.Coins(0.001m);
var destination = AddressOf(key, $"0/{i + 1}");
tester.RPC.ImportPrivKey(PrivateKeyOf(key, $"0/{i + 1}"));
tester.RPC.SendToAddress(destination, coins);
addresses.Add(destination.ScriptPubKey);
}
while (true)
{
utxo = tester.Client.Sync(pubkey, utxo);
if (!utxo.HasChanges)
{
Assert.False(true, "should have changes");
}
Assert.False(utxo.Confirmed.Reset);
Assert.True(utxo.Unconfirmed.HasChanges);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
if (new KeyPath($"0/{i}").Equals(utxo.Unconfirmed.UTXOs[0].KeyPath))
{
break;
}
}
tester.RPC.Generate(1);
utxo = tester.Client.Sync(pubkey, utxo);
Assert.Equal(1, utxo.Confirmed.UTXOs.Count);
Assert.True(utxo.Confirmed.HasChanges);
Assert.Equal(0, utxo.Confirmed.SpentOutpoints.Count);
}
}
public void CanTrack4()
{
using (var tester = ServerTester.Create())
{
var bob = new BitcoinExtKey(new ExtKey(), tester.Network);
var alice = new BitcoinExtKey(new ExtKey(), tester.Network);
var bobPubKey = CreateDerivationStrategy(bob.Neuter());
var alicePubKey = CreateDerivationStrategy(alice.Neuter());
tester.Client.Track(alicePubKey);
var utxoAlice = tester.Client.Sync(alicePubKey, uint256.Zero, uint256.Zero, true); //Track things do not wait
tester.Client.Track(bobPubKey);
var utxoBob = tester.Client.Sync(bobPubKey, null, null, true); //Track things do not wait
Assert.False(utxoAlice.Confirmed.Reset);
Assert.False(utxoAlice.Unconfirmed.Reset);
var id = tester.RPC.SendToAddress(AddressOf(alice, "0/1"), Money.Coins(1.0m));
id = tester.RPC.SendToAddress(AddressOf(bob, "0/2"), Money.Coins(0.1m));
utxoAlice = tester.Client.Sync(alicePubKey, utxoAlice);
utxoBob = tester.Client.Sync(bobPubKey, utxoBob);
Assert.False(utxoAlice.Unconfirmed.Reset);
tester.RPC.Generate(1);
utxoAlice = tester.Client.Sync(alicePubKey, utxoAlice);
utxoBob = tester.Client.Sync(bobPubKey, utxoBob);
Assert.False(utxoAlice.Confirmed.Reset);
LockTestCoins(tester.RPC);
tester.RPC.ImportPrivKey(PrivateKeyOf(alice, "0/1"));
tester.RPC.SendToAddress(AddressOf(bob, "0/3"), Money.Coins(0.6m));
utxoAlice = tester.Client.Sync(alicePubKey, utxoAlice);
utxoBob = tester.Client.Sync(bobPubKey, utxoBob);
Assert.False(utxoAlice.Unconfirmed.Reset);
utxoAlice = tester.Client.Sync(alicePubKey, utxoAlice, true);
Assert.False(utxoAlice.Unconfirmed.Reset);
tester.RPC.Generate(1);
utxoAlice = tester.Client.Sync(alicePubKey, utxoAlice);
utxoBob = tester.Client.Sync(bobPubKey, utxoBob);
Assert.False(utxoAlice.Confirmed.Reset);
Assert.Equal(1, utxoAlice.Confirmed.SpentOutpoints.Count);
Assert.Equal(0, utxoAlice.Confirmed.UTXOs.Count);
Assert.Equal(0, utxoBob.Confirmed.SpentOutpoints.Count);
Assert.Equal(1, utxoBob.Confirmed.UTXOs.Count);
Assert.Equal("0/3", utxoBob.Confirmed.UTXOs[0].KeyPath.ToString());
}
}
public void CanTrack4()
{
using (var tester = ServerTester.Create())
{
var bob = new BitcoinExtKey(new ExtKey(), tester.Network);
var alice = new BitcoinExtKey(new ExtKey(), tester.Network);
var bobPubKey = CreateDerivationStrategy(bob.Neuter());
var alicePubKey = CreateDerivationStrategy(alice.Neuter());
tester.Client.Track(alicePubKey);
var utxoAlice = tester.Client.GetUTXOs(alicePubKey, Bookmark.Start, Bookmark.Start, true); //Track things do not wait
tester.Client.Track(bobPubKey);
var utxoBob = tester.Client.GetUTXOs(bobPubKey, null, false); //Track things do not wait
Assert.NotNull(utxoAlice.Confirmed.KnownBookmark);
Assert.NotNull(utxoAlice.Unconfirmed.KnownBookmark);
var id = tester.RPC.SendToAddress(AddressOf(alice, "0/1"), Money.Coins(1.0m));
id = tester.RPC.SendToAddress(AddressOf(bob, "0/2"), Money.Coins(0.1m));
utxoAlice = tester.Client.GetUTXOs(alicePubKey, utxoAlice);
utxoBob = tester.Client.GetUTXOs(bobPubKey, utxoBob);
Assert.NotNull(utxoAlice.Unconfirmed.KnownBookmark);
tester.RPC.Generate(1);
utxoAlice = tester.Client.GetUTXOs(alicePubKey, utxoAlice);
utxoBob = tester.Client.GetUTXOs(bobPubKey, utxoBob);
Assert.NotNull(utxoAlice.Confirmed.KnownBookmark);
LockTestCoins(tester.RPC);
tester.RPC.ImportPrivKey(PrivateKeyOf(alice, "0/1"));
tester.RPC.SendToAddress(AddressOf(bob, "0/3"), Money.Coins(0.6m));
utxoAlice = tester.Client.GetUTXOs(alicePubKey, utxoAlice);
utxoBob = tester.Client.GetUTXOs(bobPubKey, utxoBob);
Assert.NotNull(utxoAlice.Unconfirmed.KnownBookmark);
utxoAlice = tester.Client.GetUTXOs(alicePubKey, utxoAlice, false);
Assert.NotNull(utxoAlice.Unconfirmed.KnownBookmark);
tester.RPC.Generate(1);
utxoAlice = tester.Client.GetUTXOs(alicePubKey, utxoAlice);
utxoBob = tester.Client.GetUTXOs(bobPubKey, utxoBob);
Assert.NotNull(utxoAlice.Confirmed.KnownBookmark);
Assert.Single(utxoAlice.Confirmed.SpentOutpoints);
Assert.Empty(utxoAlice.Confirmed.UTXOs);
Assert.Empty(utxoBob.Confirmed.SpentOutpoints);
Assert.Single(utxoBob.Confirmed.UTXOs);
Assert.Equal("0/3", utxoBob.Confirmed.UTXOs[0].KeyPath.ToString());
}
}
public void CanGetTransactionsOfDerivation()
{
using (var tester = ServerTester.Create())
{
tester.Client.WaitServerStarted(Timeout);
var key = new BitcoinExtKey(new ExtKey(), tester.Network);
var pubkey = CreateDerivationStrategy(key.Neuter());
tester.Client.Track(pubkey);
var utxo = tester.Client.GetUTXOs(pubkey, null, false); //Track things do not wait
var txId = tester.RPC.SendToAddress(AddressOf(key, "0/0"), Money.Coins(1.0m));
var result = tester.Client.GetTransactions(pubkey, new[] { Bookmark.Start }, new[] { Bookmark.Start }, new[] { Bookmark.Start });
Assert.True(result.HasChanges());
Assert.Single(result.UnconfirmedTransactions.Transactions);
var height = result.Height;
var timestampUnconf = result.UnconfirmedTransactions.Transactions[0].Timestamp;
Assert.Null(result.UnconfirmedTransactions.Transactions[0].BlockHash);
Assert.Null(result.UnconfirmedTransactions.Transactions[0].Height);
Assert.Equal(0, result.UnconfirmedTransactions.Transactions[0].Confirmations);
Assert.Equal(result.UnconfirmedTransactions.Transactions[0].Transaction.GetHash(), result.UnconfirmedTransactions.Transactions[0].TransactionId);
tester.Client.IncludeTransaction = false;
result = tester.Client.GetTransactions(pubkey, new[] { Bookmark.Start }, new[] { Bookmark.Start }, new[] { Bookmark.Start });
Assert.Null(result.UnconfirmedTransactions.Transactions[0].Transaction);
result = tester.Client.GetTransactions(pubkey, result, false);
Assert.False(result.HasChanges());
tester.RPC.Generate(1);
result = tester.Client.GetTransactions(pubkey, result);
Assert.True(result.HasChanges());
Assert.Null(result.UnconfirmedTransactions.KnownBookmark);
var gotConf = result.ConfirmedTransactions.Bookmark;
var txId2 = tester.RPC.SendToAddress(AddressOf(key, "0"), Money.Coins(1.0m));
result = tester.Client.GetTransactions(pubkey, result);
Assert.True(result.HasChanges());
Assert.Equal(gotConf, result.ConfirmedTransactions.KnownBookmark);
Assert.Single(result.UnconfirmedTransactions.Transactions);
Assert.Equal(txId2, result.UnconfirmedTransactions.Transactions[0].TransactionId);
result = tester.Client.GetTransactions(pubkey, null, null, null, false);
Assert.True(result.HasChanges());
Assert.Single(result.ConfirmedTransactions.Transactions);
Assert.Single(result.UnconfirmedTransactions.Transactions);
Assert.Equal(txId, result.ConfirmedTransactions.Transactions[0].TransactionId);
Assert.Equal(timestampUnconf, result.ConfirmedTransactions.Transactions[0].Timestamp);
Assert.Equal(txId2, result.UnconfirmedTransactions.Transactions[0].TransactionId);
}
}
public void CanTrackDirect()
{
using (var tester = ServerTester.Create())
{
var key = new BitcoinExtKey(new ExtKey(), tester.Network);
var pubkey = CreateDerivationStrategy(key.Neuter());
tester.Client.Track(pubkey);
var utxo = tester.Client.GetUTXOs(pubkey, null, false); //Track things do not wait
var tx1 = tester.RPC.SendToAddress(AddressOf(key, "0"), Money.Coins(1.0m));
utxo = tester.Client.GetUTXOs(pubkey, utxo);
Assert.NotNull(utxo.Confirmed.KnownBookmark);
Assert.Single(utxo.Unconfirmed.UTXOs);
Assert.Equal(tx1, utxo.Unconfirmed.UTXOs[0].Outpoint.Hash);
LockTestCoins(tester.RPC);
tester.RPC.ImportPrivKey(PrivateKeyOf(key, "0"));
var tx2 = tester.RPC.SendToAddress(AddressOf(key, "1"), Money.Coins(0.6m));
var prevUtxo = utxo;
utxo = tester.Client.GetUTXOs(pubkey, utxo);
Assert.NotNull(utxo.Unconfirmed.KnownBookmark);
Assert.Single(utxo.Unconfirmed.UTXOs);
Assert.Equal(tx2, utxo.Unconfirmed.UTXOs[0].Outpoint.Hash); //got the 0.6m
Assert.Equal(Money.Coins(0.6m), utxo.Unconfirmed.UTXOs[0].Value); //got the 0.6m
Assert.Single(utxo.Unconfirmed.SpentOutpoints);
Assert.Equal(tx1, utxo.Unconfirmed.SpentOutpoints[0].Hash); //previous coin is spent
utxo = tester.Client.GetUTXOs(pubkey, prevUtxo.Confirmed.Bookmark, null);
Assert.Null(utxo.Unconfirmed.KnownBookmark);
Assert.Single(utxo.Unconfirmed.UTXOs);
Assert.Empty(utxo.Unconfirmed.SpentOutpoints); //should be skipped as the unconf coin were not known
tester.RPC.SendToAddress(AddressOf(key, "0"), Money.Coins(0.15m));
utxo = tester.Client.GetUTXOs(pubkey, utxo);
Assert.Single(utxo.Unconfirmed.UTXOs);
Assert.IsType <Coin>(utxo.Unconfirmed.UTXOs[0].AsCoin(pubkey));
Assert.Equal(Money.Coins(0.15m), utxo.Unconfirmed.UTXOs[0].Value);
Assert.Empty(utxo.Unconfirmed.SpentOutpoints);
utxo = tester.Client.GetUTXOs(pubkey, null);
Assert.Equal(2, utxo.Unconfirmed.UTXOs.Count); //Should have 0.15 and 0.6
Assert.Equal(Money.Coins(0.75m), utxo.Unconfirmed.UTXOs.Select(c => c.Value).Sum());
Assert.Empty(utxo.Unconfirmed.SpentOutpoints);
}
}
public BtcWallet(ILogger logger, WalletContext db, bool mainnet, Uri nbxplorerAddress, bool useLegacyAddrs = false) : base(logger, db, mainnet)
{
this.nbxplorerAddress = nbxplorerAddress;
// create extended key
var network = GetNetwork();
key = new BitcoinExtKey(new ExtKey(seedHex), network);
var strpubkey = $"{key.Neuter().ToString()}";
if (useLegacyAddrs)
{
strpubkey = strpubkey + "-[legacy]";
}
pubkey = (DirectDerivationStrategy) new DerivationStrategyFactory(network).Parse(strpubkey);
}
public void CanTrack2()
{
using (var tester = ServerTester.Create())
{
var key = new BitcoinExtKey(new ExtKey(), tester.Network);
var pubkey = CreateDerivationStrategy(key.Neuter());
tester.Client.Track(pubkey);
var utxo = tester.Client.Sync(pubkey, null, null, true); //Track things do not wait
var tx1 = tester.RPC.SendToAddress(AddressOf(key, "0/0"), Money.Coins(1.0m));
utxo = tester.Client.Sync(pubkey, utxo);
Assert.False(utxo.Confirmed.Reset);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(tx1, utxo.Unconfirmed.UTXOs[0].Outpoint.Hash);
LockTestCoins(tester.RPC);
tester.RPC.ImportPrivKey(PrivateKeyOf(key, "0/0"));
var tx2 = tester.RPC.SendToAddress(AddressOf(key, "1/0"), Money.Coins(0.6m));
var prevUtxo = utxo;
utxo = tester.Client.Sync(pubkey, utxo);
Assert.False(utxo.Unconfirmed.Reset);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(tx2, utxo.Unconfirmed.UTXOs[0].Outpoint.Hash); //got the 0.6m
Assert.Equal(Money.Coins(0.6m), utxo.Unconfirmed.UTXOs[0].Output.Value); //got the 0.6m
Assert.Equal(1, utxo.Unconfirmed.SpentOutpoints.Count);
Assert.Equal(tx1, utxo.Unconfirmed.SpentOutpoints[0].Hash); //previous coin is spent
utxo = tester.Client.Sync(pubkey, prevUtxo.Confirmed.Hash, null);
Assert.True(utxo.Unconfirmed.Reset);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(0, utxo.Unconfirmed.SpentOutpoints.Count); //should be skipped as the unconf coin were not known
tester.RPC.SendToAddress(AddressOf(key, "0/0"), Money.Coins(0.15m));
utxo = tester.Client.Sync(pubkey, utxo);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(Money.Coins(0.15m), utxo.Unconfirmed.UTXOs[0].Output.Value);
Assert.Equal(0, utxo.Unconfirmed.SpentOutpoints.Count);
utxo = tester.Client.Sync(pubkey, null);
Assert.Equal(2, utxo.Unconfirmed.UTXOs.Count); //Should have 0.15 and 0.6
Assert.Equal(Money.Coins(0.75m), utxo.Unconfirmed.UTXOs.Select(c => c.Output.Value).Sum());
Assert.Equal(0, utxo.Unconfirmed.SpentOutpoints.Count);
}
}
public async Task <StoresController> CreateStoreAsync()
{
ExtKey = new ExtKey().GetWif(parent.Network);
var store = parent.PayTester.GetController <StoresController>(UserId);
await store.CreateStore(new CreateStoreViewModel()
{
Name = "Test Store"
});
StoreId = store.CreatedStoreId;
await store.UpdateStore(StoreId, new StoreViewModel()
{
DerivationScheme = ExtKey.Neuter().ToString() + "-[legacy]",
SpeedPolicy = SpeedPolicy.MediumSpeed
}, "Save");
return(store);
}
public void CanUseWebSockets()
{
using (var tester = ServerTester.Create())
{
tester.Client.WaitServerStarted();
var key = new BitcoinExtKey(new ExtKey(), tester.Network);
var pubkey = CreateDerivationStrategy(key.Neuter());
tester.Client.Track(pubkey);
using (var connected = tester.Client.CreateNotificationSession())
{
connected.ListenNewBlock();
var expectedBlockId = tester.Explorer.CreateRPCClient().Generate(1)[0];
var blockEvent = (Models.NewBlockEvent)connected.NextEvent(Cancel);
Assert.Equal(expectedBlockId, blockEvent.Hash);
Assert.NotEqual(0, blockEvent.Height);
connected.ListenDerivationSchemes(new[] { pubkey });
tester.Explorer.CreateRPCClient().SendToAddress(AddressOf(key, "0/1"), Money.Coins(1.0m));
var txEvent = (Models.NewTransactionEvent)connected.NextEvent(Cancel);
Assert.Equal(txEvent.DerivationStrategy, pubkey);
}
}
}
public WhatIsExtKey(BitcoinExtKey data) : base(data)
{
PrivateKey = Encoders.Hex.EncodeData(data.PrivateKey.ToBytes());
ExtPubKey = data.Neuter().ToString();
}
public void CanTrack()
{
using (var tester = ServerTester.Create())
{
//WaitServerStarted not needed, just a sanity check
tester.Client.WaitServerStarted();
var key = new BitcoinExtKey(new ExtKey(), tester.Network);
var pubkey = CreateDerivationStrategy(key.Neuter());
tester.Client.Track(pubkey);
var utxo = tester.Client.Sync(pubkey, null, null, true); //Track things do not wait
var gettingUTXO = tester.Client.SyncAsync(pubkey, utxo);
var txId = tester.RPC.SendToAddress(AddressOf(key, "0/0"), Money.Coins(1.0m));
utxo = gettingUTXO.GetAwaiter().GetResult();
Assert.Equal(113, utxo.CurrentHeight);
Assert.False(utxo.Confirmed.Reset);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(txId, utxo.Unconfirmed.UTXOs[0].Outpoint.Hash);
Assert.Equal(0, utxo.Unconfirmed.UTXOs[0].Confirmations);
Assert.Equal(0, utxo.Confirmed.UTXOs.Count);
Assert.Equal(uint256.Zero, utxo.Confirmed.Hash);
Assert.NotEqual(uint256.Zero, utxo.Unconfirmed.Hash);
var tx = tester.Client.GetTransaction(utxo.Unconfirmed.UTXOs[0].Outpoint.Hash);
Assert.NotNull(tx);
Assert.Equal(0, tx.Confirmations);
Assert.Equal(utxo.Unconfirmed.UTXOs[0].Outpoint.Hash, tx.Transaction.GetHash());
tester.RPC.Generate(1);
var prevUtxo = utxo;
utxo = tester.Client.Sync(pubkey, prevUtxo);
Assert.True(utxo.Unconfirmed.Reset);
Assert.Equal(0, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(1, utxo.Confirmed.UTXOs.Count);
Assert.Equal(txId, utxo.Confirmed.UTXOs[0].Outpoint.Hash);
Assert.Equal(1, utxo.Confirmed.UTXOs[0].Confirmations);
Assert.NotEqual(uint256.Zero, utxo.Confirmed.Hash);
var prevConfHash = utxo.Confirmed.Hash;
txId = tester.RPC.SendToAddress(AddressOf(key, "0/1"), Money.Coins(1.0m));
var txId1 = txId;
prevUtxo = utxo;
utxo = tester.Client.Sync(pubkey, utxo);
Assert.Equal(0, utxo.Confirmed.UTXOs.Count);
Assert.False(utxo.Confirmed.Reset);
Assert.True(utxo.HasChanges);
Assert.False(utxo.Unconfirmed.Reset);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(txId, utxo.Unconfirmed.UTXOs[0].Outpoint.Hash);
utxo = tester.Client.Sync(pubkey, null, null, true);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(new KeyPath("0/1"), utxo.Unconfirmed.UTXOs[0].KeyPath);
Assert.Equal(1, utxo.Confirmed.UTXOs.Count);
Assert.Equal(new KeyPath("0/0"), utxo.Confirmed.UTXOs[0].KeyPath);
Assert.Equal(prevConfHash, utxo.Confirmed.Hash);
utxo = tester.Client.Sync(pubkey, utxo.Confirmed.Hash, null, true);
Assert.False(utxo.Confirmed.Reset);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(0, utxo.Confirmed.UTXOs.Count);
utxo = tester.Client.Sync(pubkey, null, utxo.Unconfirmed.Hash, true);
Assert.True(utxo.Confirmed.Reset);
Assert.Equal(0, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(1, utxo.Confirmed.UTXOs.Count);
Assert.Equal(1, utxo.Confirmed.UTXOs[0].Confirmations);
Assert.Null(tester.Client.GetTransaction(uint256.One));
tx = tester.Client.GetTransaction(utxo.Confirmed.UTXOs[0].Outpoint.Hash);
Assert.NotNull(tx);
Assert.Equal(1, tx.Confirmations);
Assert.Equal(utxo.Confirmed.UTXOs[0].Outpoint.Hash, tx.Transaction.GetHash());
tester.RPC.Generate(1);
utxo = tester.Client.Sync(pubkey, utxo);
Assert.Equal(1, utxo.Confirmed.UTXOs.Count);
Assert.Equal(new KeyPath("0/1"), utxo.Confirmed.UTXOs[0].KeyPath);
var outpoint01 = utxo.Confirmed.UTXOs[0].Outpoint;
txId = tester.RPC.SendToAddress(AddressOf(key, "0/2"), Money.Coins(1.0m));
utxo = tester.Client.Sync(pubkey, utxo);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(0, utxo.Confirmed.UTXOs.Count);
Assert.Equal(new KeyPath("0/2"), utxo.Unconfirmed.UTXOs[0].KeyPath);
tester.RPC.Generate(1);
utxo = tester.Client.Sync(pubkey, utxo);
Assert.Equal(1, utxo.Confirmed.UTXOs.Count);
Assert.Equal(new KeyPath("0/2"), utxo.Confirmed.UTXOs[0].KeyPath);
utxo = tester.Client.Sync(pubkey, utxo, true);
Assert.True(!utxo.HasChanges);
var before01Spend = utxo.Confirmed.Hash;
LockTestCoins(tester.RPC);
tester.RPC.ImportPrivKey(PrivateKeyOf(key, "0/1"));
txId = tester.RPC.SendToAddress(AddressOf(key, "0/3"), Money.Coins(0.5m));
utxo = tester.Client.Sync(pubkey, utxo);
Assert.Equal(1, utxo.Unconfirmed.UTXOs.Count);
Assert.Equal(new KeyPath("0/3"), utxo.Unconfirmed.UTXOs[0].KeyPath);
Assert.Equal(1, utxo.Unconfirmed.SpentOutpoints.Count); // "0/1" should be spent
Assert.Equal(txId1, utxo.Unconfirmed.SpentOutpoints[0].Hash); // "0/1" should be spent
utxo = tester.Client.Sync(pubkey, utxo, true);
Assert.False(utxo.HasChanges);
tester.RPC.Generate(1);
utxo = tester.Client.Sync(pubkey, before01Spend, utxo.Unconfirmed.Hash);
Assert.True(utxo.Unconfirmed.HasChanges);
Assert.Equal(1, utxo.Confirmed.UTXOs.Count);
Assert.Equal(new KeyPath("0/3"), utxo.Confirmed.UTXOs[0].KeyPath);
Assert.Equal(1, utxo.Confirmed.SpentOutpoints.Count);
Assert.Equal(outpoint01, utxo.Confirmed.SpentOutpoints[0]);
utxo = tester.Client.Sync(pubkey, utxo, true);
Assert.False(utxo.HasChanges);
}
}