public AuctionTests()
{
var network = new SmartContractsRegTest();
this.TestAddress = "0x0000000000000000000000000000000000000001".HexToAddress();
var block = new TestBlock
{
Coinbase = this.TestAddress,
Number = 1
};
var message = new TestMessage
{
ContractAddress = this.TestAddress,
Sender = this.TestAddress,
Value = Value
};
var getBalance = new Func <ulong>(() => Balance);
var persistentState = new TestPersistentState();
var serializer = new Serializer(new ContractPrimitiveSerializer(network));
this.smartContractState = new TestSmartContractState(
block,
message,
persistentState,
serializer,
null,
null,
getBalance,
null,
null
);
}
public void Buffer_50Kb_For_1MB_BlockSize()
{
var network = new SmartContractsRegTest();
var optionsFromNetwork = new BlockDefinitionOptions(network.Consensus.Options.MaxBlockWeight, network.Consensus.Options.MaxBlockBaseSize);
BlockDefinitionOptions newOptions = new BlockBufferGenerator().GetOptionsWithBuffer(optionsFromNetwork);
Assert.Equal((uint)950_000, newOptions.BlockMaxWeight);
Assert.Equal((uint)950_000, newOptions.BlockMaxSize);
}
public void Deserialize_Logs_With_Different_Addresses_From_Cache()
{
var network = new SmartContractsRegTest();
var primitiveSerializer = new ContractPrimitiveSerializer(network);
var testStruct0 = new TestLog
{
Name = "Test",
Value128 = 123,
Value256 = 456
};
var testStruct1 = new TestLog
{
Name = "Test 2",
Value128 = 789,
Value256 = 101112
};
var testBytes = primitiveSerializer.Serialize(testStruct0);
var logs = new Log[]
{
new Log(uint160.Zero, new List <byte[]> {
Encoding.UTF8.GetBytes("TestLog")
}, primitiveSerializer.Serialize(testStruct0)),
new Log(uint160.One, new List <byte[]> {
Encoding.UTF8.GetBytes("TestLog")
}, primitiveSerializer.Serialize(testStruct1)),
};
var stateRoot = new Mock <IStateRepositoryRoot>();
stateRoot.Setup(r => r.GetCodeHash(It.IsAny <uint160>())).Returns(uint256.Zero.ToBytes());
var assemblyCache = new Mock <IContractAssemblyCache>();
var contractAssembly = new Mock <IContractAssembly>();
// Return this assembly as it will contain the TestLog type.
contractAssembly.Setup(s => s.Assembly).Returns(Assembly.GetExecutingAssembly());
assemblyCache.Setup(s => s.Retrieve(It.IsAny <uint256>())).Returns(new CachedAssemblyPackage(contractAssembly.Object));
var serializer = new ApiLogDeserializer(primitiveSerializer, network, stateRoot.Object, assemblyCache.Object);
var responses = serializer.MapLogResponses(logs);
// Verify that we deserialized the logs correctly.
Assert.Equal(testStruct0.Name, ((dynamic)responses[0].Log).Name);
Assert.Equal(testStruct1.Name, ((dynamic)responses[1].Log).Name);
// Verify that we got the code for both log assemblies.
stateRoot.Verify(s => s.GetCodeHash(logs[0].Address), Times.Once);
stateRoot.Verify(s => s.GetCodeHash(logs[1].Address), Times.Once);
}
public void MockChain_AuctionTest()
{
var network = new SmartContractsRegTest(); // ew hack. TODO: Expose from MockChain or MockChainNode.
using (MockChain chain = new MockChain(2))
{
MockChainNode sender = chain.Nodes[0];
MockChainNode receiver = chain.Nodes[1];
TestHelper.MineBlocks(sender.CoreNode, sender.WalletName, sender.Password, sender.AccountName, 1);
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/Auction.cs");
Assert.True(compilationResult.Success);
// Create contract and ensure code exists
BuildCreateContractTransactionResponse response = sender.SendCreateContractTransaction(compilationResult.Compilation, 0, new string[] { "10#20" });
receiver.WaitMempoolCount(1);
receiver.MineBlocks(1);
Assert.NotNull(receiver.GetCode(response.NewContractAddress));
Assert.NotNull(sender.GetCode(response.NewContractAddress));
// Test that the contract address, event name, and logging values are available in the bloom.
var scBlockHeader = receiver.GetLastBlock().Header as SmartContractBlockHeader;
Assert.True(scBlockHeader.LogsBloom.Test(new Address(response.NewContractAddress).ToUint160(network).ToBytes()));
Assert.True(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes("Created")));
Assert.True(scBlockHeader.LogsBloom.Test(BitConverter.GetBytes((ulong)20)));
// And sanity test that a non-indexed field and random value is not available in bloom.
Assert.False(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes(sender.MinerAddress.Address)));
Assert.False(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes("RandomValue")));
// Test that the event can be searched for...
var receiptsFromSearch = sender.GetReceipts(response.NewContractAddress, "Created");
Assert.Single(receiptsFromSearch);
// Call contract and ensure owner is now highest bidder
BuildCallContractTransactionResponse callResponse = sender.SendCallContractTransaction("Bid", response.NewContractAddress, 2);
receiver.WaitMempoolCount(1);
TestHelper.MineBlocks(receiver.CoreNode, receiver.WalletName, receiver.Password, receiver.AccountName, 1);
Assert.Equal(sender.GetStorageValue(response.NewContractAddress, "Owner"), sender.GetStorageValue(response.NewContractAddress, "HighestBidder"));
// Wait 20 blocks and end auction and check for transaction to victor
TestHelper.MineBlocks(sender.CoreNode, sender.WalletName, sender.Password, sender.AccountName, 20);
sender.SendCallContractTransaction("AuctionEnd", response.NewContractAddress, 0);
sender.WaitMempoolCount(1);
TestHelper.MineBlocks(sender.CoreNode, sender.WalletName, sender.Password, sender.AccountName, 1);
NBitcoin.Block block = sender.GetLastBlock();
Assert.Equal(3, block.Transactions.Count);
}
}
public EventDutchAuctionTests()
{
var network = new SmartContractsRegTest();
this.TestAddress = "0x0000000000000000000000000000000000000001".HexToAddress();
this.ta2 = "0x0000000000000000000000000000000000000002".HexToAddress();
this.ta3 = "0x0000000000000000000000000000000000000003".HexToAddress();
this.ta4 = "0x0000000000000000000000000000000000000004".HexToAddress();
this.ta5 = "0x0000000000000000000000000000000000000005".HexToAddress();
var block = new TestBlock
{
Coinbase = this.TestAddress,
Number = 1
};
var message = new TestMessage
{
ContractAddress = this.TestAddress,
Sender = this.TestAddress,
Value = Value
};
var getBalance = new Func <ulong>(() => Balance);
var persistentState = new TestPersistentState();
var serializer = new Serializer(new ContractPrimitiveSerializer(network));
var log = new TestContractLogger();
this.smartContractState = new TestSmartContractState(
block,
message,
persistentState,
serializer,
null,
null,
getBalance,
null,
log
);
ulong totalSupply = 1000_000;
ulong ticketsAmount = 3;
string name = "New Event";
string symbol = "ENT";
ulong auctiontBlockDuration = 5000;
ulong maxPrice = 2000000000;
ulong minPrice = 1000;
this.contract = new EventDutchAuction(this.smartContractState, ticketsAmount, name, symbol, auctiontBlockDuration, maxPrice, minPrice);
}
public ObserverTests()
{
var context = new ContractExecutorTestContext();
this.network = context.Network;
this.TestAddress = "0x0000000000000000000000000000000000000001".HexToAddress();
this.repository = context.State;
this.moduleReader = new ContractModuleDefinitionReader();
this.assemblyLoader = new ContractAssemblyLoader();
this.gasMeter = new GasMeter((Gas)5000000);
var block = new TestBlock
{
Coinbase = this.TestAddress,
Number = 1
};
var message = new TestMessage
{
ContractAddress = this.TestAddress,
GasLimit = (Gas)GasLimit,
Sender = this.TestAddress,
Value = Value
};
var getBalance = new Func <ulong>(() => Balance);
var persistentState = new TestPersistentState();
var network = new SmartContractsRegTest();
var serializer = new ContractPrimitiveSerializer(network);
this.state = new SmartContractState(
new Stratis.SmartContracts.Block(1, this.TestAddress),
new Message(this.TestAddress, this.TestAddress, 0),
new PersistentState(new MeteredPersistenceStrategy(this.repository, this.gasMeter, new BasicKeyEncodingStrategy()),
context.Serializer, this.TestAddress.ToUint160()),
context.Serializer,
this.gasMeter,
new ContractLogHolder(),
Mock.Of <IInternalTransactionExecutor>(),
new InternalHashHelper(),
() => 1000);
this.rewriter = new ObserverRewriter(new Observer(this.gasMeter, ReflectionVirtualMachine.MemoryUnitLimit));
}
public StandardTokenTests()
{
var network = new SmartContractsRegTest();
this.TestAddress = "0x0000000000000000000000000000000000000001".HexToAddress();
this.ta2 = "0x0000000000000000000000000000000000000002".HexToAddress();
this.ta3 = "0x0000000000000000000000000000000000000003".HexToAddress();
this.ta4 = "0x0000000000000000000000000000000000000004".HexToAddress();
this.ta5 = "0x0000000000000000000000000000000000000005".HexToAddress();
var block = new TestBlock
{
Coinbase = this.TestAddress,
Number = 1
};
var message = new TestMessage
{
ContractAddress = this.TestAddress,
Sender = this.TestAddress,
Value = Value
};
var getBalance = new Func <ulong>(() => Balance);
var persistentState = new TestPersistentState();
var serializer = new Serializer(new ContractPrimitiveSerializer(network));
this.smartContractState = new TestSmartContractState(
block,
message,
persistentState,
serializer,
null,
null,
getBalance,
null,
null
);
ulong totalSupply = 1000_000; string name = "TestToken"; string symbol = "TST";
this.contract = new StandardToken(this.smartContractState, totalSupply, name, symbol);
}
public CoreNode CreateSmartContractPowNode()
{
Network network = new SmartContractsRegTest();
return(CreateNode(new StratisSmartContractNode(this.GetNextDataFolderName(), network), "stratis.conf"));
}
public void Create_Contract_Success()
{
var network = new SmartContractsRegTest();
uint160 newContractAddress = uint160.One;
var gasConsumed = (Gas)100;
var code = new byte[] { 0xAA, 0xBB, 0xCC };
var contractTxData = new ContractTxData(1, 1, (Gas)1000, code);
var refund = new Money(0);
const ulong mempoolFee = 2UL; // MOQ doesn't like it when you use a type with implicit conversions (Money)
ISmartContractTransactionContext context = Mock.Of <ISmartContractTransactionContext>(c =>
c.Data == code &&
c.MempoolFee == mempoolFee &&
c.Sender == uint160.One &&
c.CoinbaseAddress == uint160.Zero);
var logger = new Mock <ILogger>();
ILoggerFactory loggerFactory = Mock.Of <ILoggerFactory>
(l => l.CreateLogger(It.IsAny <string>()) == logger.Object);
var callDataSerializer = new Mock <ICallDataSerializer>();
callDataSerializer
.Setup(s => s.Deserialize(It.IsAny <byte[]>()))
.Returns(Result.Ok(contractTxData));
var vmExecutionResult = VmExecutionResult.Success(null, null);
var contractStateRoot = new Mock <IContractStateRoot>();
var transferProcessor = new Mock <ISmartContractResultTransferProcessor>();
(Money refund, TxOut)refundResult = (refund, null);
var refundProcessor = new Mock <ISmartContractResultRefundProcessor>();
refundProcessor
.Setup(r => r.Process(
contractTxData,
mempoolFee,
context.Sender,
It.IsAny <Gas>(),
false))
.Returns(refundResult);
var stateTransitionResult = StateTransitionResult.Ok(gasConsumed, newContractAddress, vmExecutionResult.Result);
var internalTransfers = new List <TransferInfo>().AsReadOnly();
var stateMock = new Mock <IState>();
stateMock.Setup(s => s.Apply(It.IsAny <ExternalCreateMessage>()))
.Returns(stateTransitionResult);
stateMock.SetupGet(p => p.InternalTransfers).Returns(internalTransfers);
var stateFactory = new Mock <IStateFactory>();
stateFactory.Setup(sf => sf.Create(
contractStateRoot.Object,
It.IsAny <IBlock>(),
context.TxOutValue,
context.TransactionHash,
contractTxData.GasLimit))
.Returns(stateMock.Object);
var sut = new Executor(
loggerFactory,
callDataSerializer.Object,
contractStateRoot.Object,
refundProcessor.Object,
transferProcessor.Object,
network,
stateFactory.Object);
sut.Execute(context);
callDataSerializer.Verify(s => s.Deserialize(code), Times.Once);
stateFactory.Verify(sf => sf
.Create(
contractStateRoot.Object,
It.IsAny <IBlock>(),
context.TxOutValue,
context.TransactionHash,
contractTxData.GasLimit),
Times.Once);
stateMock.Verify(sm => sm
.Apply(It.IsAny <ExternalCreateMessage>()), Times.Once);
transferProcessor.Verify(t => t
.Process(
contractStateRoot.Object,
newContractAddress,
context,
internalTransfers,
false),
Times.Once);
refundProcessor.Verify(t => t
.Process(
contractTxData,
mempoolFee,
context.Sender,
It.IsAny <Gas>(),
false),
Times.Once);
}
