public SmartContractPosPowBlockDefinition(
IBlockBufferGenerator blockBufferGenerator,
ICoinView coinView,
IConsensusLoop consensusLoop,
IDateTimeProvider dateTimeProvider,
ISmartContractExecutorFactory executorFactory,
ILoggerFactory loggerFactory,
ITxMempool mempool,
MempoolSchedulerLock mempoolLock,
MinerSettings minerSettings,
Network network,
ISenderRetriever senderRetriever,
IStakeChain stakeChain,
IStakeValidator stakeValidator,
IContractStateRoot stateRoot)
: base(consensusLoop, dateTimeProvider, loggerFactory, mempool, mempoolLock, minerSettings, network)
{
this.coinView = coinView;
this.executorFactory = executorFactory;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.senderRetriever = senderRetriever;
this.stakeChain = stakeChain;
this.stakeValidator = stakeValidator;
this.stateRoot = stateRoot;
// When building smart contract blocks, we will be generating and adding both transactions to the block and txouts to the coinbase.
// At the moment, these generated objects aren't accounted for in the block size and weight accounting.
// This means that if blocks started getting full, this miner could start generating blocks greater than the max consensus block size.
// To avoid this without significantly overhauling the BlockDefinition, for now we just lower the block size by a percentage buffer.
// If in the future blocks are being built over the size limit and you need an easy fix, just increase the size of this buffer.
this.Options = blockBufferGenerator.GetOptionsWithBuffer(this.Options);
}
public State(
IContractPrimitiveSerializer serializer,
InternalTransactionExecutorFactory internalTransactionExecutorFactory,
ISmartContractVirtualMachine vm,
IContractStateRoot repository,
IBlock block,
Network network,
ulong txAmount,
uint256 transactionHash,
IAddressGenerator addressGenerator,
Gas gasLimit)
{
this.intermediateState = repository;
this.LogHolder = new ContractLogHolder(network);
this.internalTransfers = new List <TransferInfo>();
this.BalanceState = new BalanceState(this.intermediateState, txAmount, this.InternalTransfers);
this.Network = network;
this.Nonce = 0;
this.Block = block;
this.TransactionHash = transactionHash;
this.AddressGenerator = addressGenerator;
this.InternalTransactionExecutorFactory = internalTransactionExecutorFactory;
this.Vm = vm;
this.GasRemaining = gasLimit;
this.Serializer = serializer;
}
/// <inheritdoc/>
public override BlockTemplate Build(ChainedHeader chainTip, Script scriptPubKey)
{
this.logger.LogTrace("()");
GetSenderResult getSenderResult = this.senderRetriever.GetAddressFromScript(scriptPubKey);
if (!getSenderResult.Success)
{
throw new ConsensusErrorException(new ConsensusError("sc-block-assembler-createnewblock", getSenderResult.Error));
}
this.coinbaseAddress = getSenderResult.Sender;
this.stateSnapshot = this.stateRoot.GetSnapshotTo(((SmartContractBlockHeader)this.ConsensusLoop.Tip.Header).HashStateRoot.ToBytes());
this.refundOutputs.Clear();
this.receipts.Clear();
base.OnBuild(chainTip, scriptPubKey);
this.coinbase.Outputs.AddRange(this.refundOutputs);
this.logger.LogTrace("(-)");
return(this.BlockTemplate);
}
public SmartContractsController(IBroadcasterManager broadcasterManager,
IBlockStoreCache blockStoreCache,
ConcurrentChain chain,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
Network network,
IContractStateRoot stateRoot,
IWalletManager walletManager,
IWalletTransactionHandler walletTransactionHandler,
IAddressGenerator addressGenerator,
IContractPrimitiveSerializer contractPrimitiveSerializer,
IReceiptRepository receiptRepository)
{
this.stateRoot = stateRoot;
this.walletTransactionHandler = walletTransactionHandler;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.network = network;
this.coinType = (CoinType)network.Consensus.CoinType;
this.chain = chain;
this.blockStoreCache = blockStoreCache;
this.walletManager = walletManager;
this.broadcasterManager = broadcasterManager;
this.addressGenerator = addressGenerator;
this.contractPrimitiveSerializer = contractPrimitiveSerializer;
this.receiptRepository = receiptRepository;
}
/// <summary>
/// Initialize a smart contract executor for the block assembler or consensus validator.
/// <para>
/// After the contract has been executed, it will process any fees and/or refunds.
/// </para>
/// </summary>
public ISmartContractExecutor CreateExecutor(
IContractStateRoot stateRepository,
ISmartContractTransactionContext transactionContext)
{
return(new Executor(this.loggerFactory, this.serializer,
stateRepository, this.refundProcessor, this.transferProcessor, this.network, this.stateFactory));
}
public SmartContractFeature(IConsensusLoop consensusLoop, ILoggerFactory loggerFactory, Network network, IContractStateRoot stateRoot)
{
this.consensusLoop = consensusLoop;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.network = network;
this.stateRoot = stateRoot;
}
public IState Create(IContractStateRoot stateRoot, IBlock block, ulong txOutValue, uint256 transactionHash, Gas gasLimit)
{
return(new State(
this.contractPrimitiveSerializer,
this.internalTransactionExecutorFactory,
this.vm,
stateRoot,
block,
this.network,
txOutValue,
transactionHash,
this.addressGenerator,
gasLimit));
}
public Executor(ILoggerFactory loggerFactory,
ICallDataSerializer serializer,
IContractStateRoot stateRoot,
ISmartContractResultRefundProcessor refundProcessor,
ISmartContractResultTransferProcessor transferProcessor,
Network network,
IStateFactory stateFactory)
{
this.logger = loggerFactory.CreateLogger(this.GetType());
this.stateRoot = stateRoot;
this.refundProcessor = refundProcessor;
this.transferProcessor = transferProcessor;
this.serializer = serializer;
this.network = network;
this.stateFactory = stateFactory;
}
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(this.Password, this.WalletName, this.Passphrase);
this.MinerAddress = this.CoreNode.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(this.WalletName, this.AccountName));
Wallet wallet = this.CoreNode.FullNode.WalletManager().GetWalletByName(this.WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(this.Password, this.MinerAddress).PrivateKey;
this.CoreNode.SetDummyMinerSecret(new BitcoinSecret(key, this.CoreNode.FullNode.Network));
// Set up services for later
this.smartContractWalletController = this.CoreNode.FullNode.NodeService <SmartContractWalletController>();
this.smartContractsController = this.CoreNode.FullNode.NodeService <SmartContractsController>();
this.stateRoot = this.CoreNode.FullNode.NodeService <IContractStateRoot>();
this.blockStore = this.CoreNode.FullNode.NodeService <IBlockStore>();
}
public SmartContractPowConsensusRuleEngine(
ConcurrentChain chain,
ICheckpoints checkpoints,
ConsensusSettings consensusSettings,
IDateTimeProvider dateTimeProvider,
ISmartContractExecutorFactory executorFactory,
ILoggerFactory loggerFactory,
Network network,
NodeDeployments nodeDeployments,
IContractStateRoot originalStateRoot,
ILookaheadBlockPuller puller,
IReceiptRepository receiptRepository,
ISenderRetriever senderRetriever,
ICoinView utxoSet)
: base(network, loggerFactory, dateTimeProvider, chain, nodeDeployments, consensusSettings, checkpoints, utxoSet, puller)
{
this.ExecutorFactory = executorFactory;
this.OriginalStateRoot = originalStateRoot;
this.ReceiptRepository = receiptRepository;
this.SenderRetriever = senderRetriever;
}
public GasInjectorTests()
{
// Only take from context what these tests require.
var context = new ContractExecutorTestContext();
this.vm = context.Vm;
this.repository = context.State;
this.network = context.Network;
this.moduleReader = new ContractModuleDefinitionReader();
this.assemblyLoader = new ContractAssemblyLoader();
this.gasMeter = new GasMeter((Gas)5000000);
this.state = new SmartContractState(
new Block(1, TestAddress),
new Message(TestAddress, TestAddress, 0),
new PersistentState(new MeteredPersistenceStrategy(this.repository, this.gasMeter, new BasicKeyEncodingStrategy()),
context.ContractPrimitiveSerializer, TestAddress.ToUint160(this.network)),
context.ContractPrimitiveSerializer,
this.gasMeter,
new ContractLogHolder(this.network),
Mock.Of <IInternalTransactionExecutor>(),
new InternalHashHelper(),
() => 1000);
}
public SmartContractPosConsensusRuleEngine(
ConcurrentChain chain,
ICheckpoints checkpoints,
ConsensusSettings consensusSettings,
IDateTimeProvider dateTimeProvider,
ISmartContractExecutorFactory executorFactory,
ILoggerFactory loggerFactory,
Network network,
NodeDeployments nodeDeployments,
IContractStateRoot originalStateRoot,
IReceiptRepository receiptRepository,
ISenderRetriever senderRetriever,
IStakeChain stakeChain,
IStakeValidator stakeValidator,
ICoinView utxoSet,
IChainState chainState,
IInvalidBlockHashStore invalidBlockHashStore)
: base(network, loggerFactory, dateTimeProvider, chain, nodeDeployments, consensusSettings, checkpoints, utxoSet, stakeChain, stakeValidator, chainState, invalidBlockHashStore)
{
this.ExecutorFactory = executorFactory;
this.OriginalStateRoot = originalStateRoot;
this.ReceiptRepository = receiptRepository;
this.SenderRetriever = senderRetriever;
}
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, 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));
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.
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);
// Create a token contract.
ulong gasPrice = 1;
int vmVersion = 1;
Gas gasLimit = (Gas)5000;
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 to 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 both nodes have the contract.
IContractStateRoot senderState = scSender.FullNode.NodeService <IContractStateRoot>();
IContractStateRoot receiverState = scReceiver.FullNode.NodeService <IContractStateRoot>();
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 both nodes have the contract.
senderState = scSender.FullNode.NodeService <IContractStateRoot>();
receiverState = scReceiver.FullNode.NodeService <IContractStateRoot>();
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 SendAndReceiveSmartContractTransactionsOnPosNetwork()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPosNode();
CoreNode scReceiver = builder.CreateSmartContractPosNode();
builder.StartAll();
scSender.NotInIBD();
scReceiver.NotInIBD();
scSender.FullNode.WalletManager().CreateWallet(Password, WalletName, Passphrase);
scReceiver.FullNode.WalletManager().CreateWallet(Password, WalletName, Passphrase);
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
HdAddress senderAddress = TestHelper.MineBlocks(scSender, WalletName, Password, AccountName, maturity + 5).AddressUsed;
// 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 * 6 * 50, total);
// Create a token contract
ulong gasPrice = 1;
int vmVersion = 1;
Gas gasLimit = (Gas)5000;
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/TransferTestPos.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),
ChangeAddress = senderAddress,
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
// Build the transfer contract transaction
var transferContractTransaction = BuildTransferContractTransaction(scSender, txBuildContext);
// Add the smart contract transaction to the mempool to be mined.
scSender.AddToStratisMempool(transferContractTransaction);
// Ensure the smart contract transaction is in 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
IContractStateRoot senderState = scSender.FullNode.NodeService <IContractStateRoot>();
IContractStateRoot receiverState = scReceiver.FullNode.NodeService <IContractStateRoot>();
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/TransferTestPos.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),
ChangeAddress = senderAddress,
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
// Build the transfer contract transaction
transferContractTransaction = BuildTransferContractTransaction(scSender, txBuildContext);
// Add the smart contract transaction to the mempool to be mined.
scSender.AddToStratisMempool(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));
tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0); // nonce is 0 for user contract creation.
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),
ChangeAddress = senderAddress,
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 1000, ScriptPubKey = contractCallScript
} }.ToList()
};
// Build the transfer contract transaction
var callContractTransaction = BuildTransferContractTransaction(scSender, txBuildContext);
// Add the smart contract transaction to the mempool to be mined.
scSender.AddToStratisMempool(callContractTransaction);
// Wait for the token transaction to be picked up by the mempool
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
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));
}
}
