public void WalletCanCatchupWithBestChain()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode stratisminer = builder.CreateStratisPowNode(this.network);
builder.StartAll();
stratisminer.NotInIBD();
// get a key from the wallet
Mnemonic mnemonic = stratisminer.FullNode.WalletManager().CreateWallet("123456", "mywallet");
Assert.Equal(12, mnemonic.Words.Length);
HdAddress addr = stratisminer.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference("mywallet", "account 0"));
Features.Wallet.Wallet wallet = stratisminer.FullNode.WalletManager().GetWalletByName("mywallet");
Key key = wallet.GetExtendedPrivateKeyForAddress("123456", addr).PrivateKey;
stratisminer.SetDummyMinerSecret(key.GetBitcoinSecret(stratisminer.FullNode.Network));
stratisminer.GenerateStratisWithMiner(10);
// wait for block repo for block sync to work
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisminer));
// push the wallet back
stratisminer.FullNode.Services.ServiceProvider.GetService <IWalletSyncManager>().SyncFromHeight(5);
stratisminer.GenerateStratisWithMiner(5);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisminer));
}
}
public void WalletCanRecoverOnStartup()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode stratisNodeSync = builder.CreateStratisPowNode(this.network);
builder.StartAll();
stratisNodeSync.NotInIBD();
// get a key from the wallet
Mnemonic mnemonic = stratisNodeSync.FullNode.WalletManager().CreateWallet("123456", "mywallet");
Assert.Equal(12, mnemonic.Words.Length);
HdAddress addr = stratisNodeSync.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference("mywallet", "account 0"));
Features.Wallet.Wallet wallet = stratisNodeSync.FullNode.WalletManager().GetWalletByName("mywallet");
Key key = wallet.GetExtendedPrivateKeyForAddress("123456", addr).PrivateKey;
stratisNodeSync.SetDummyMinerSecret(key.GetBitcoinSecret(stratisNodeSync.FullNode.Network));
stratisNodeSync.GenerateStratisWithMiner(10);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisNodeSync));
// set the tip of best chain some blocks in the apst
stratisNodeSync.FullNode.Chain.SetTip(stratisNodeSync.FullNode.Chain.GetBlock(stratisNodeSync.FullNode.Chain.Height - 5));
// stop the node it will persist the chain with the reset tip
stratisNodeSync.FullNode.Dispose();
CoreNode newNodeInstance = builder.CloneStratisNode(stratisNodeSync);
// load the node, this should hit the block store recover code
newNodeInstance.Start();
// check that store recovered to be the same as the best chain.
Assert.Equal(newNodeInstance.FullNode.Chain.Tip.HashBlock, newNodeInstance.FullNode.WalletManager().WalletTipHash);
}
}
public void Create_WithFunds_Via_Controller()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode();
CoreNode scReceiver = builder.CreateSmartContractPowNode();
builder.StartAll();
scSender.NotInIBD();
scReceiver.NotInIBD();
scSender.FullNode.Network.Consensus.CoinbaseMaturity = 1L;
scReceiver.FullNode.Network.Consensus.CoinbaseMaturity = 1L;
int maturity = (int)scReceiver.FullNode.Network.Consensus.CoinbaseMaturity;
scSender.FullNode.WalletManager().CreateWallet(Password, WalletName, Passphrase);
scReceiver.FullNode.WalletManager().CreateWallet(Password, WalletName, Passphrase);
HdAddress addr = scSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = scSender.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, addr).PrivateKey;
scSender.SetDummyMinerSecret(new BitcoinSecret(key, scSender.FullNode.Network));
scReceiver.SetDummyMinerSecret(new BitcoinSecret(key, scReceiver.FullNode.Network));
scSender.GenerateStratisWithMiner(2);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * (maturity + 1) * 50, total);
SmartContractsController senderSmartContractsController = scSender.FullNode.NodeService <SmartContractsController>();
SmartContractWalletController senderWalletController = scSender.FullNode.NodeService <SmartContractWalletController>();
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/StorageDemo.cs");
Assert.True(compilationResult.Success);
var buildRequest = new BuildCreateContractTransactionRequest
{
AccountName = AccountName,
Amount = "30",
GasLimit = "10000",
GasPrice = "1",
ContractCode = compilationResult.Compilation.ToHexString(),
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
JsonResult result = (JsonResult)senderSmartContractsController.BuildCreateSmartContractTransaction(buildRequest);
var response = (BuildCreateContractTransactionResponse)result.Value;
scSender.CreateRPCClient().AddNode(scReceiver.Endpoint, true);
SmartContractSharedSteps.SendTransactionAndMine(scSender, scReceiver, senderWalletController, response.Hex);
ContractStateRepositoryRoot senderState = scSender.FullNode.NodeService <ContractStateRepositoryRoot>();
Assert.Equal((ulong)30 * 100_000_000, senderState.GetCurrentBalance(new Address(response.NewContractAddress).ToUint160(new SmartContractsRegTest())));
}
}
public void SyncWithProofWorkNode()
{
this.posReceiverAddress = this.nodes[this.PosStaker].FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(this.PosWallet, this.WalletAccount));
Features.Wallet.Wallet wallet = this.nodes[this.PosStaker].FullNode.WalletManager().GetWalletByName(this.PosWallet);
this.posReceiverPrivateKey = wallet.GetExtendedPrivateKeyForAddress(this.PosWalletPassword, this.posReceiverAddress).PrivateKey;
this.nodes[this.PosStaker].SetDummyMinerSecret(new BitcoinSecret(this.posReceiverPrivateKey, this.nodes[this.PosStaker].FullNode.Network));
this.nodeGroupBuilder.WithConnections().Connect(this.PowMiner, this.PosStaker);
}
public void ProofOfWorkNodeWithWallet()
{
this.nodes = this.nodeGroupBuilder
.CreateStratisPowMiningNode(this.PowMiner)
.Start()
.NotInIBD()
.WithWallet(this.PowWallet, this.PowWalletPassword)
.Build();
this.powSenderAddress = this.nodes[this.PowMiner].FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(this.PowWallet, this.WalletAccount));
Features.Wallet.Wallet wallet = this.nodes[this.PowMiner].FullNode.WalletManager().GetWalletByName(this.PowWallet);
this.powSenderPrivateKey = wallet.GetExtendedPrivateKeyForAddress(this.PowWalletPassword, this.powSenderAddress).PrivateKey;
}
public void SmartContractsController_Builds_Transaction_With_Minimum_Inputs()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode();
builder.StartAll();
scSender.NotInIBD();
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
scSender.FullNode.WalletManager().CreateWallet(Password, WalletName, Passphrase);
HdAddress addr = scSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = scSender.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, addr).PrivateKey;
scSender.SetDummyMinerSecret(new BitcoinSecret(key, scSender.FullNode.Network));
scSender.GenerateStratisWithMiner(maturity + 5);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
int spendableBlocks = GetSpendableBlocks(maturity + 5, maturity);
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * spendableBlocks * 50, total);
SmartContractsController senderSmartContractsController = scSender.FullNode.NodeService <SmartContractsController>();
SmartContractWalletController senderWalletController = scSender.FullNode.NodeService <SmartContractWalletController>();
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/StorageDemo.cs");
Assert.True(compilationResult.Success);
var buildRequest = new BuildCreateContractTransactionRequest
{
AccountName = AccountName,
GasLimit = "10000",
GasPrice = "1",
ContractCode = compilationResult.Compilation.ToHexString(),
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
JsonResult result = (JsonResult)senderSmartContractsController.BuildCreateSmartContractTransaction(buildRequest);
var response = (BuildCreateContractTransactionResponse)result.Value;
var transaction = scSender.FullNode.Network.CreateTransaction(response.Hex);
Assert.Single(transaction.Inputs);
}
}
public MockChainNode(CoreNode coreNode, MockChain chain)
{
this.CoreNode = coreNode;
this.chain = chain;
// Set up address and mining
this.CoreNode.NotInIBD();
this.CoreNode.FullNode.WalletManager().CreateWallet(Password, WalletName);
this.MinerAddress = this.CoreNode.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = this.CoreNode.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, this.MinerAddress).PrivateKey;
this.CoreNode.SetDummyMinerSecret(new BitcoinSecret(key, this.CoreNode.FullNode.Network));
// Set up services for later
this.smartContractsController = this.CoreNode.FullNode.NodeService <SmartContractsController>();
this.stateRoot = this.CoreNode.FullNode.NodeService <ContractStateRepositoryRoot>();
this.blockStore = this.CoreNode.FullNode.NodeService <IBlockStoreCache>();
}
public void WalletCanReceiveAndSendCorrectly()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode stratisSender = builder.CreateStratisPowNode(this.network);
CoreNode stratisReceiver = builder.CreateStratisPowNode(this.network);
builder.StartAll();
stratisSender.NotInIBD();
stratisReceiver.NotInIBD();
// get a key from the wallet
Mnemonic mnemonic1 = stratisSender.FullNode.WalletManager().CreateWallet("123456", "mywallet");
Mnemonic mnemonic2 = stratisReceiver.FullNode.WalletManager().CreateWallet("123456", "mywallet");
Assert.Equal(12, mnemonic1.Words.Length);
Assert.Equal(12, mnemonic2.Words.Length);
HdAddress addr = stratisSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference("mywallet", "account 0"));
Features.Wallet.Wallet wallet = stratisSender.FullNode.WalletManager().GetWalletByName("mywallet");
Key key = wallet.GetExtendedPrivateKeyForAddress("123456", addr).PrivateKey;
stratisSender.SetDummyMinerSecret(new BitcoinSecret(key, stratisSender.FullNode.Network));
int maturity = (int)stratisSender.FullNode.Network.Consensus.CoinbaseMaturity;
stratisSender.GenerateStratisWithMiner(maturity + 5);
// wait for block repo for block sync to work
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisSender));
// the mining should add coins to the wallet
long total = stratisSender.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * 105 * 50, total);
// sync both nodes
stratisSender.CreateRPCClient().AddNode(stratisReceiver.Endpoint, true);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisSender));
// send coins to the receiver
HdAddress sendto = stratisReceiver.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference("mywallet", "account 0"));
Transaction trx = stratisSender.FullNode.WalletTransactionHandler().BuildTransaction(CreateContext(stratisSender.FullNode.Network,
new WalletAccountReference("mywallet", "account 0"), "123456", sendto.ScriptPubKey, Money.COIN * 100, FeeType.Medium, 101));
// broadcast to the other node
stratisSender.FullNode.NodeService <WalletController>().SendTransaction(new SendTransactionRequest(trx.ToHex()));
// wait for the trx to arrive
TestHelper.WaitLoop(() => stratisReceiver.CreateRPCClient().GetRawMempool().Length > 0);
TestHelper.WaitLoop(() => stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Any());
long receivetotal = stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * 100, receivetotal);
Assert.Null(stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").First().Transaction.BlockHeight);
// generate two new blocks do the trx is confirmed
stratisSender.GenerateBlockManually(new List <Transaction>(new[] { stratisSender.FullNode.Network.CreateTransaction(trx.ToBytes()) }));
stratisSender.GenerateStratisWithMiner(1);
// wait for block repo for block sync to work
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisSender));
TestHelper.WaitLoop(() => maturity + 6 == stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").First().Transaction.BlockHeight);
}
}
public void WalletCanReorg()
{
// this test has 4 parts:
// send first transaction from one wallet to another and wait for it to be confirmed
// send a second transaction and wait for it to be confirmed
// connected to a longer chain that couse a reorg back so the second trasnaction is undone
// mine the second transaction back in to the main chain
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode stratisSender = builder.CreateStratisPowNode(this.network);
CoreNode stratisReceiver = builder.CreateStratisPowNode(this.network);
CoreNode stratisReorg = builder.CreateStratisPowNode(this.network);
builder.StartAll();
stratisSender.NotInIBD();
stratisReceiver.NotInIBD();
stratisReorg.NotInIBD();
// get a key from the wallet
Mnemonic mnemonic1 = stratisSender.FullNode.WalletManager().CreateWallet("123456", "mywallet");
Mnemonic mnemonic2 = stratisReceiver.FullNode.WalletManager().CreateWallet("123456", "mywallet");
Assert.Equal(12, mnemonic1.Words.Length);
Assert.Equal(12, mnemonic2.Words.Length);
HdAddress addr = stratisSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference("mywallet", "account 0"));
Features.Wallet.Wallet wallet = stratisSender.FullNode.WalletManager().GetWalletByName("mywallet");
Key key = wallet.GetExtendedPrivateKeyForAddress("123456", addr).PrivateKey;
stratisSender.SetDummyMinerSecret(new BitcoinSecret(key, stratisSender.FullNode.Network));
stratisReorg.SetDummyMinerSecret(new BitcoinSecret(key, stratisSender.FullNode.Network));
int maturity = (int)stratisSender.FullNode.Network.Consensus.CoinbaseMaturity;
stratisSender.GenerateStratisWithMiner(maturity + 15);
int currentBestHeight = maturity + 15;
// wait for block repo for block sync to work
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisSender));
// the mining should add coins to the wallet
long total = stratisSender.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * currentBestHeight * 50, total);
// sync all nodes
stratisReceiver.CreateRPCClient().AddNode(stratisSender.Endpoint, true);
stratisReceiver.CreateRPCClient().AddNode(stratisReorg.Endpoint, true);
stratisSender.CreateRPCClient().AddNode(stratisReorg.Endpoint, true);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisReorg));
// Build Transaction 1
// ====================
// send coins to the receiver
HdAddress sendto = stratisReceiver.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference("mywallet", "account 0"));
Transaction transaction1 = stratisSender.FullNode.WalletTransactionHandler().BuildTransaction(CreateContext(stratisSender.FullNode.Network, new WalletAccountReference("mywallet", "account 0"), "123456", sendto.ScriptPubKey, Money.COIN * 100, FeeType.Medium, 101));
// broadcast to the other node
stratisSender.FullNode.NodeService <WalletController>().SendTransaction(new SendTransactionRequest(transaction1.ToHex()));
// wait for the trx to arrive
TestHelper.WaitLoop(() => stratisReceiver.CreateRPCClient().GetRawMempool().Length > 0);
Assert.NotNull(stratisReceiver.CreateRPCClient().GetRawTransaction(transaction1.GetHash(), false));
TestHelper.WaitLoop(() => stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Any());
long receivetotal = stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * 100, receivetotal);
Assert.Null(stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").First().Transaction.BlockHeight);
// generate two new blocks so the trx is confirmed
stratisSender.GenerateStratisWithMiner(1);
int transaction1MinedHeight = currentBestHeight + 1;
stratisSender.GenerateStratisWithMiner(1);
currentBestHeight = currentBestHeight + 2;
// wait for block repo for block sync to work
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisReorg));
Assert.Equal(currentBestHeight, stratisReceiver.FullNode.Chain.Tip.Height);
TestHelper.WaitLoop(() => transaction1MinedHeight == stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").First().Transaction.BlockHeight);
// Build Transaction 2
// ====================
// remove the reorg node
stratisReceiver.CreateRPCClient().RemoveNode(stratisReorg.Endpoint);
stratisSender.CreateRPCClient().RemoveNode(stratisReorg.Endpoint);
TestHelper.WaitLoop(() => !TestHelper.IsNodeConnected(stratisReorg));
ChainedHeader forkblock = stratisReceiver.FullNode.Chain.Tip;
// send more coins to the wallet
sendto = stratisReceiver.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference("mywallet", "account 0"));
Transaction transaction2 = stratisSender.FullNode.WalletTransactionHandler().BuildTransaction(CreateContext(stratisSender.FullNode.Network, new WalletAccountReference("mywallet", "account 0"), "123456", sendto.ScriptPubKey, Money.COIN * 10, FeeType.Medium, 101));
stratisSender.FullNode.NodeService <WalletController>().SendTransaction(new SendTransactionRequest(transaction2.ToHex()));
// wait for the trx to arrive
TestHelper.WaitLoop(() => stratisReceiver.CreateRPCClient().GetRawMempool().Length > 0);
Assert.NotNull(stratisReceiver.CreateRPCClient().GetRawTransaction(transaction2.GetHash(), false));
TestHelper.WaitLoop(() => stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Any());
long newamount = stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * 110, newamount);
Assert.Contains(stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet"), b => b.Transaction.BlockHeight == null);
// mine more blocks so its included in the chain
stratisSender.GenerateStratisWithMiner(1);
int transaction2MinedHeight = currentBestHeight + 1;
stratisSender.GenerateStratisWithMiner(1);
currentBestHeight = currentBestHeight + 2;
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisSender));
Assert.Equal(currentBestHeight, stratisReceiver.FullNode.Chain.Tip.Height);
TestHelper.WaitLoop(() => stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Any(b => b.Transaction.BlockHeight == transaction2MinedHeight));
// create a reorg by mining on two different chains
// ================================================
// advance both chains, one chin is longer
stratisSender.GenerateStratisWithMiner(2);
stratisReorg.GenerateStratisWithMiner(10);
currentBestHeight = forkblock.Height + 10;
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisSender));
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisReorg));
// connect the reorg chain
stratisReceiver.CreateRPCClient().AddNode(stratisReorg.Endpoint, true);
stratisSender.CreateRPCClient().AddNode(stratisReorg.Endpoint, true);
// wait for the chains to catch up
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisReorg));
Assert.Equal(currentBestHeight, stratisReceiver.FullNode.Chain.Tip.Height);
// ensure wallet reorg complete
TestHelper.WaitLoop(() => stratisReceiver.FullNode.WalletManager().WalletTipHash == stratisReorg.CreateRPCClient().GetBestBlockHash());
// check the wallet amount was rolled back
long newtotal = stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Sum(s => s.Transaction.Amount);
Assert.Equal(receivetotal, newtotal);
TestHelper.WaitLoop(() => maturity + 16 == stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").First().Transaction.BlockHeight);
// ReBuild Transaction 2
// ====================
// After the reorg transaction2 was returned back to mempool
stratisSender.FullNode.NodeService <WalletController>().SendTransaction(new SendTransactionRequest(transaction2.ToHex()));
TestHelper.WaitLoop(() => stratisReceiver.CreateRPCClient().GetRawMempool().Length > 0);
// mine the transaction again
stratisSender.GenerateStratisWithMiner(1);
transaction2MinedHeight = currentBestHeight + 1;
stratisSender.GenerateStratisWithMiner(1);
currentBestHeight = currentBestHeight + 2;
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(stratisSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(stratisReceiver, stratisReorg));
Assert.Equal(currentBestHeight, stratisReceiver.FullNode.Chain.Tip.Height);
long newsecondamount = stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Sum(s => s.Transaction.Amount);
Assert.Equal(newamount, newsecondamount);
TestHelper.WaitLoop(() => stratisReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet("mywallet").Any(b => b.Transaction.BlockHeight == transaction2MinedHeight));
}
}
public void SendAndReceiveCorrectly()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode();
CoreNode scReceiver = builder.CreateSmartContractPowNode();
builder.StartAll();
scSender.NotInIBD();
scReceiver.NotInIBD();
Mnemonic mnemonic1 = scSender.FullNode.WalletManager().CreateWallet(Password, WalletName);
Mnemonic mnemonic2 = scReceiver.FullNode.WalletManager().CreateWallet(Password, WalletName);
HdAddress addr = scSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = scSender.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, addr).PrivateKey;
scSender.SetDummyMinerSecret(new BitcoinSecret(key, scSender.FullNode.Network));
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
scSender.GenerateStratisWithMiner(maturity + 5);
// wait for block repo for block sync to work
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
// the mining should add coins to the wallet
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * (maturity + 5) * 50, total);
// sync both nodes
scSender.CreateRPCClient().AddNode(scReceiver.Endpoint, true);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// send coins to the receiver
HdAddress sendto = scReceiver.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
var txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
FeeType = FeeType.Medium,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = Money.COIN * 100, ScriptPubKey = sendto.ScriptPubKey
} }.ToList()
};
Transaction trx = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
// broadcast to the other node
scSender.FullNode.NodeService <SmartContractWalletController>().SendTransaction(new SendTransactionRequest(trx.ToHex()));
// wait for the trx to arrive
TestHelper.WaitLoop(() => scReceiver.CreateRPCClient().GetRawMempool().Length > 0);
TestHelper.WaitLoop(() => scReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Any());
var receivetotal = scReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * 100, receivetotal);
Assert.Null(scReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).First().Transaction.BlockHeight);
// generate two new blocks do the trx is confirmed
scSender.AddToStratisMempool(scSender.FullNode.Network.CreateTransaction(trx.ToBytes()));
scSender.GenerateStratisWithMiner(1);
// wait for block repo for block sync to work
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
TestHelper.WaitLoop(() => maturity + 6 == scReceiver.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).First().Transaction.BlockHeight);
}
}
public void SendAndReceiveSmartContractTransactionsUsingController()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode();
CoreNode scReceiver = builder.CreateSmartContractPowNode();
builder.StartAll();
scSender.NotInIBD();
scReceiver.NotInIBD();
scSender.FullNode.WalletManager().CreateWallet(Password, WalletName);
scReceiver.FullNode.WalletManager().CreateWallet(Password, WalletName);
HdAddress addr = scSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = scSender.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, addr).PrivateKey;
scSender.SetDummyMinerSecret(new BitcoinSecret(key, scSender.FullNode.Network));
scReceiver.SetDummyMinerSecret(new BitcoinSecret(key, scReceiver.FullNode.Network));
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
scSender.GenerateStratisWithMiner(maturity + 5);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * (maturity + 5) * 50, total);
SmartContractsController senderSmartContractsController = scSender.FullNode.NodeService <SmartContractsController>();
SmartContractWalletController senderWalletController = scSender.FullNode.NodeService <SmartContractWalletController>();
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/StorageDemo.cs");
Assert.True(compilationResult.Success);
var buildRequest = new BuildCreateContractTransactionRequest
{
AccountName = AccountName,
GasLimit = "10000",
GasPrice = "1",
ContractCode = compilationResult.Compilation.ToHexString(),
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
JsonResult result = (JsonResult)senderSmartContractsController.BuildCreateSmartContractTransaction(buildRequest);
var response = (BuildCreateContractTransactionResponse)result.Value;
scSender.CreateRPCClient().AddNode(scReceiver.Endpoint, true);
SmartContractSharedSteps.SendTransactionAndMine(scSender, scReceiver, senderWalletController, response.Hex);
var receiptStorage = scReceiver.FullNode.NodeService <ISmartContractReceiptStorage>();
Assert.NotNull(receiptStorage.GetReceipt(response.TransactionId));
// Check wallet history is updating correctly
result = (JsonResult)senderWalletController.GetHistory(new WalletHistoryRequest
{
AccountName = AccountName,
WalletName = WalletName
});
var walletHistoryModel = (WalletHistoryModel)result.Value;
Assert.Single(walletHistoryModel.AccountsHistoryModel.First().TransactionsHistory.Where(x => x.Type == TransactionItemType.Send));
string storageRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "TestSave",
DataType = SmartContractDataType.String
})).Value;
Assert.Equal("Hello, smart contract world!", storageRequestResult);
string ownerRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "Owner",
DataType = SmartContractDataType.Address
})).Value;
Assert.NotEmpty(ownerRequestResult);
string counterRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "Counter",
DataType = SmartContractDataType.Int
})).Value;
Assert.Equal("12345", counterRequestResult);
var callRequest = new BuildCallContractTransactionRequest
{
AccountName = AccountName,
GasLimit = "10000",
GasPrice = "1",
Amount = "0",
MethodName = "Increment",
ContractAddress = response.NewContractAddress,
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
result = (JsonResult)senderSmartContractsController.BuildCallSmartContractTransaction(callRequest);
var callResponse = (BuildCallContractTransactionResponse)result.Value;
SmartContractSharedSteps.SendTransactionAndMine(scSender, scReceiver, senderWalletController, callResponse.Hex);
counterRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "Counter",
DataType = SmartContractDataType.Int
})).Value;
Assert.Equal("12346", counterRequestResult);
// Check wallet history again
result = (JsonResult)senderWalletController.GetHistory(new WalletHistoryRequest
{
AccountName = AccountName,
WalletName = WalletName
});
walletHistoryModel = (WalletHistoryModel)result.Value;
Assert.Equal(2, walletHistoryModel.AccountsHistoryModel.First().TransactionsHistory.Where(x => x.Type == TransactionItemType.Send).Count());
// Check receipts
var receiptResponse = (JsonResult)senderSmartContractsController.GetReceipt(callResponse.TransactionId.ToString());
var receiptModel = (ReceiptModel)receiptResponse.Value;
Assert.True(receiptModel.Successful);
}
}
public void SendAndReceiveSmartContractTransactions()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode();
CoreNode scReceiver = builder.CreateSmartContractPowNode();
builder.StartAll();
scSender.NotInIBD();
scReceiver.NotInIBD();
scSender.FullNode.WalletManager().CreateWallet(Password, WalletName);
scReceiver.FullNode.WalletManager().CreateWallet(Password, WalletName);
HdAddress addr = scSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = scSender.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, addr).PrivateKey;
scSender.SetDummyMinerSecret(new BitcoinSecret(key, scSender.FullNode.Network));
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
scSender.GenerateStratisWithMiner(maturity + 5);
// Wait for block repo for block sync to work.
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
// The mining should add coins to the wallet.
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * (maturity + 5) * 50, total);
// Create a token contract
ulong gasPrice = 1;
int vmVersion = 1;
Gas gasLimit = (Gas)2000;
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/TransferTest.cs");
Assert.True(compilationResult.Success);
var contractCarrier = SmartContractCarrier.CreateContract(vmVersion, compilationResult.Compilation, gasPrice, gasLimit);
var contractCreateScript = new Script(contractCarrier.Serialize());
var txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
Transaction transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
// Broadcast the token transaction to the network
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
// Wait for the token transaction to be picked up by the mempool
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
// Mine the token transaction and wait for it sync
scSender.GenerateStratisWithMiner(1);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
// Sync to the receiver node
scSender.CreateRPCClient().AddNode(scReceiver.Endpoint, true);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// Ensure that boths nodes has the contract
ContractStateRepositoryRoot senderState = scSender.FullNode.NodeService <ContractStateRepositoryRoot>();
ContractStateRepositoryRoot receiverState = scReceiver.FullNode.NodeService <ContractStateRepositoryRoot>();
IAddressGenerator addressGenerator = scSender.FullNode.NodeService <IAddressGenerator>();
uint160 tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0);
Assert.NotNull(senderState.GetCode(tokenContractAddress));
Assert.NotNull(receiverState.GetCode(tokenContractAddress));
scSender.FullNode.MempoolManager().Clear();
// Create a transfer token contract
compilationResult = SmartContractCompiler.CompileFile("SmartContracts/TransferTest.cs");
Assert.True(compilationResult.Success);
contractCarrier = SmartContractCarrier.CreateContract(vmVersion, compilationResult.Compilation, gasPrice, gasLimit);
contractCreateScript = new Script(contractCarrier.Serialize());
txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
// Broadcast the token transaction to the network
transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
// Wait for the token transaction to be picked up by the mempool
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
scSender.GenerateStratisWithMiner(1);
// Ensure the node is synced
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
// Ensure both nodes are synced with each other
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// Ensure that boths nodes has the contract
senderState = scSender.FullNode.NodeService <ContractStateRepositoryRoot>();
receiverState = scReceiver.FullNode.NodeService <ContractStateRepositoryRoot>();
tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0);
Assert.NotNull(senderState.GetCode(tokenContractAddress));
Assert.NotNull(receiverState.GetCode(tokenContractAddress));
scSender.FullNode.MempoolManager().Clear();
// Create a call contract transaction which will transfer funds
contractCarrier = SmartContractCarrier.CallContract(1, tokenContractAddress, "Test", gasPrice, gasLimit);
Script contractCallScript = new Script(contractCarrier.Serialize());
txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 1000, ScriptPubKey = contractCallScript
} }.ToList()
};
// Broadcast the token transaction to the network
transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
// Mine the transaction
scSender.GenerateStratisWithMiner(1);
// Ensure the nodes are synced
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// The balance should now reflect the transfer
Assert.Equal((ulong)900, senderState.GetCurrentBalance(tokenContractAddress));
}
}
public void AuctionTest()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractNode();
CoreNode scReceiver = builder.CreateSmartContractNode();
builder.StartAll();
scSender.NotInIBD();
scReceiver.NotInIBD();
scSender.FullNode.WalletManager().CreateWallet(Password, WalletName);
scReceiver.FullNode.WalletManager().CreateWallet(Password, WalletName);
HdAddress addr = scSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = scSender.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, addr).PrivateKey;
scSender.SetDummyMinerSecret(new BitcoinSecret(key, scSender.FullNode.Network));
scReceiver.SetDummyMinerSecret(new BitcoinSecret(key, scReceiver.FullNode.Network));
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
scSender.GenerateStratisWithMiner(maturity + 5);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * (maturity + 5) * 50, total);
SmartContractsController senderSmartContractsController = scSender.FullNode.NodeService <SmartContractsController>();
WalletController senderWalletController = scSender.FullNode.NodeService <WalletController>();
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/Auction.cs");
Assert.True(compilationResult.Success);
var buildRequest = new BuildCreateContractTransactionRequest
{
AccountName = AccountName,
GasLimit = "10000",
GasPrice = "1",
ContractCode = compilationResult.Compilation.ToHexString(),
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address,
Parameters = new string[] { "10#20" }
};
JsonResult result = (JsonResult)senderSmartContractsController.BuildCreateSmartContractTransaction(buildRequest);
var response = (BuildCreateContractTransactionResponse)result.Value;
scSender.CreateRPCClient().AddNode(scReceiver.Endpoint, true);
SmartContractSharedSteps.SendTransactionAndMine(scSender, scReceiver, senderWalletController, response.Hex);
// Contract deployed.
ContractStateRepositoryRoot senderState = scSender.FullNode.NodeService <ContractStateRepositoryRoot>();
string contractAddress = response.NewContractAddress.ToString();
uint160 contractAddressUint160 = new Address(contractAddress).ToUint160(scSender.FullNode.Network);
Assert.NotNull(senderState.GetCode(contractAddressUint160));
var callRequest = new BuildCallContractTransactionRequest
{
AccountName = AccountName,
GasLimit = "10000",
GasPrice = "1",
Amount = "2",
MethodName = "Bid",
ContractAddress = response.NewContractAddress,
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
result = (JsonResult)senderSmartContractsController.BuildCallSmartContractTransaction(callRequest);
var callResponse = (BuildCallContractTransactionResponse)result.Value;
SmartContractSharedSteps.SendTransactionAndMine(scSender, scReceiver, senderWalletController, callResponse.Hex);
// Here, test that Sender and HighestBidder are the same.
var ownerBytes = senderState.GetStorageValue(contractAddressUint160, Encoding.UTF8.GetBytes("Owner"));
var highestBidderBytes = senderState.GetStorageValue(contractAddressUint160, Encoding.UTF8.GetBytes("HighestBidder"));
Assert.Equal(new uint160(ownerBytes), new uint160(highestBidderBytes));
var hasEndedBytes = senderState.GetStorageValue(contractAddressUint160, Encoding.UTF8.GetBytes("HasEnded"));
var endBlockBytes = senderState.GetStorageValue(contractAddressUint160, Encoding.UTF8.GetBytes("EndBlock"));
bool hasEnded = BitConverter.ToBoolean(hasEndedBytes, 0);
ulong endBlock = BitConverter.ToUInt64(endBlockBytes, 0);
// Wait 20 blocks to end auction
scReceiver.GenerateStratisWithMiner(20);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
var endAuctionRequest = new BuildCallContractTransactionRequest
{
AccountName = AccountName,
GasLimit = "10000",
GasPrice = "1",
Amount = "0",
MethodName = "AuctionEnd",
ContractAddress = response.NewContractAddress,
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
var endAuctionResult = (JsonResult)senderSmartContractsController.BuildCallSmartContractTransaction(endAuctionRequest);
var endAuctionResponse = (BuildCallContractTransactionResponse)endAuctionResult.Value;
SmartContractSharedSteps.SendTransactionAndMine(scSender, scReceiver, senderWalletController, endAuctionResponse.Hex);
// Check that transaction did in fact go through with condensing tx as well
var blockStoreCache = scSender.FullNode.NodeService <IBlockStoreCache>();
var secondLastBlock = blockStoreCache.GetBlockAsync(scSender.FullNode.Chain.Tip.Previous.HashBlock).Result;
Assert.Equal(3, secondLastBlock.Transactions.Count);
}
}