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