public void Throws_on_theoretical_contract_crash() { var contractAddress = Address.OfContract(_senderPublicKey.ToKvmAddress(), 0); _stateProvider.CreateAccount(contractAddress, 1000.Kat()); var codeHash = _stateProvider.UpdateCode(Bytes.FromHexString("0x01")); _stateProvider.UpdateCodeHash(contractAddress, codeHash, _specProvider.GenesisSpec); _stateProvider.Commit(_specProvider.GenesisSpec); var delta = EntryUtils.PrepareSingleContractEntryDelta(null, _senderPublicKey, 0, "0x60016000526001601FF300"); delta.PublicEntries[0].GasLimit = 1_000_000L; delta.PublicEntries[0].ReceiverAddress = ByteString.Empty; delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); tracer.Received().MarkAsFailed(contractAddress, 1_000_000L, Arg.Any <byte[]>(), null); }
public void TestCopyRecursively() { POIFSFileSystem fsD = new POIFSFileSystem(); POIFSFileSystem fs = new POIFSFileSystem(); DirectoryEntry dirA = fs.CreateDirectory("DirA"); DirectoryEntry dirB = fs.CreateDirectory("DirB"); DocumentEntry entryR = fs.CreateDocument(new ByteArrayInputStream(dataSmallA), "EntryRoot"); DocumentEntry entryA1 = dirA.CreateDocument("EntryA1", new ByteArrayInputStream(dataSmallA)); DocumentEntry entryA2 = dirA.CreateDocument("EntryA2", new ByteArrayInputStream(dataSmallB)); // Copy docs Assert.AreEqual(0, fsD.Root.EntryCount); EntryUtils.CopyNodeRecursively(entryR, fsD.Root); Assert.AreEqual(1, fsD.Root.EntryCount); Assert.IsNotNull(fsD.Root.GetEntry("EntryRoot")); EntryUtils.CopyNodeRecursively(entryA1, fsD.Root); Assert.AreEqual(2, fsD.Root.EntryCount); Assert.IsNotNull(fsD.Root.GetEntry("EntryRoot")); Assert.IsNotNull(fsD.Root.GetEntry("EntryA1")); EntryUtils.CopyNodeRecursively(entryA2, fsD.Root); Assert.AreEqual(3, fsD.Root.EntryCount); Assert.IsNotNull(fsD.Root.GetEntry("EntryRoot")); Assert.IsNotNull(fsD.Root.GetEntry("EntryA1")); Assert.IsNotNull(fsD.Root.GetEntry("EntryA2")); // Copy directories fsD = new POIFSFileSystem(); Assert.AreEqual(0, fsD.Root.EntryCount); EntryUtils.CopyNodeRecursively(dirB, fsD.Root); Assert.AreEqual(1, fsD.Root.EntryCount); Assert.IsNotNull(fsD.Root.GetEntry("DirB")); Assert.AreEqual(0, ((DirectoryEntry)fsD.Root.GetEntry("DirB")).EntryCount); EntryUtils.CopyNodeRecursively(dirA, fsD.Root); Assert.AreEqual(2, fsD.Root.EntryCount); Assert.IsNotNull(fsD.Root.GetEntry("DirB")); Assert.AreEqual(0, ((DirectoryEntry)fsD.Root.GetEntry("DirB")).EntryCount); Assert.IsNotNull(fsD.Root.GetEntry("DirA")); Assert.AreEqual(2, ((DirectoryEntry)fsD.Root.GetEntry("DirA")).EntryCount); // Copy the whole lot fsD = new POIFSFileSystem(); Assert.AreEqual(0, fsD.Root.EntryCount); EntryUtils.CopyNodes(fs, fsD, new List <String>()); Assert.AreEqual(3, fsD.Root.EntryCount); Assert.IsNotNull(fsD.Root.GetEntry(dirA.Name)); Assert.IsNotNull(fsD.Root.GetEntry(dirB.Name)); Assert.IsNotNull(fsD.Root.GetEntry(entryR.Name)); Assert.AreEqual(0, ((DirectoryEntry)fsD.Root.GetEntry("DirB")).EntryCount); Assert.AreEqual(2, ((DirectoryEntry)fsD.Root.GetEntry("DirA")).EntryCount); }
private IEnumerable <PublicEntry> GenerateSamplePublicTransactions(int sampleSize) { for (var i = 0; i < sampleSize; i++) { var sender = _cryptoContext.GeneratePrivateKey(); var recipient = _cryptoContext.GeneratePrivateKey().GetPublicKey(); var publicEntry = EntryUtils.PreparePublicEntry(recipient, sender.GetPublicKey(), 10); publicEntry.Signature = publicEntry.GenerateSignature(_cryptoContext, sender, _signingContext); yield return(publicEntry); } }
private void Write(NPOIFSFileSystem fs) { // For tracking what we've written out, so far List <String> excepts = new List <String>(1); // Write out our HPFS properties, with any changes WriteProperties(fs, excepts); // Copy over everything else unchanged EntryUtils.CopyNodes(directory, fs.Root, excepts); // Caller will save the resultant POIFSFileSystem to the stream/file }
public void Fails_on_wrong_nonce() { var delta = EntryUtils.PrepareSingleContractEntryDelta(_recipient, _senderPublicKey, 0, "0x", 1); delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); tracer.Received().MarkAsFailed(_recipient.ToKvmAddress(), 21000, Bytes.Empty, "invalid"); }
public void Can_execute_transfers_from_public_entries() { var delta = EntryUtils.PrepareSinglePublicEntryDelta(_recipient, _senderPublicKey, 0); delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); tracer.Received().MarkAsSuccess(_recipient.ToKvmAddress(), 21000, Bytes.Empty, Arg.Any <LogEntry[]>()); }
public void Fails_when_tx_beyond_delta_gas_limit() { var delta = EntryUtils.PrepareSingleContractEntryDelta(_recipient, _senderPublicKey, 0); delta.PublicEntries[0].GasLimit = 10_000_000; delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); tracer.Received().MarkAsFailed(_recipient.ToKvmAddress(), 10_000_000, Bytes.Empty, "invalid"); }
public void Fails_when_gas_limit_below_data_intrinsic_cost() { var delta = EntryUtils.PrepareSingleContractEntryDelta(_recipient, _senderPublicKey, 0, "0x0102"); delta.PublicEntries[0].GasLimit = 21001; // just above 21000 but not paying for data delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); tracer.Received().MarkAsFailed(_recipient.ToKvmAddress(), 21001, Bytes.Empty, "invalid"); }
/** * Write out, with any properties changes, but nothing else */ public override void Write(Stream out1) { POIFSFileSystem fs = new POIFSFileSystem(); // For tracking what we've written out, so far List <String> excepts = new List <String>(1); // Write out our HPFS properties, with any changes WriteProperties(fs, excepts); // Copy over everything else unchanged EntryUtils.CopyNodes(directory, fs.Root, excepts); // Save the resultant POIFSFileSystem to the output stream fs.WriteFileSystem(out1); }
public void Can_add_gas_to_existing_balance() { var delta = EntryUtils.PrepareSingleContractEntryDelta(_recipient, _senderPublicKey, 0); delta.PublicEntries[0].GasPrice = 1.ToUint256ByteString(); delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); tracer.Received().MarkAsSuccess(_recipient.ToKvmAddress(), 21000, Bytes.Empty, Arg.Any <LogEntry[]>()); }
public void TestAreDocumentsIdentical() { POIFSFileSystem fs = new POIFSFileSystem(); DirectoryEntry dirA = fs.CreateDirectory("DirA"); DirectoryEntry dirB = fs.CreateDirectory("DirB"); DocumentEntry entryA1 = dirA.CreateDocument("Entry1", new ByteArrayInputStream(dataSmallA)); DocumentEntry entryA1b = dirA.CreateDocument("Entry1b", new ByteArrayInputStream(dataSmallA)); DocumentEntry entryA2 = dirA.CreateDocument("Entry2", new ByteArrayInputStream(dataSmallB)); DocumentEntry entryB1 = dirB.CreateDocument("Entry1", new ByteArrayInputStream(dataSmallA)); // Names must match Assert.AreEqual(false, entryA1.Name.Equals(entryA1b.Name)); Assert.AreEqual(false, EntryUtils.AreDocumentsIdentical(entryA1, entryA1b)); // Contents must match Assert.AreEqual(false, EntryUtils.AreDocumentsIdentical(entryA1, entryA2)); // Parents don't matter if contents + names are the same Assert.AreEqual(false, entryA1.Parent.Equals(entryB1.Parent)); Assert.AreEqual(true, EntryUtils.AreDocumentsIdentical(entryA1, entryB1)); // Can work with NPOIFS + POIFS //ByteArrayOutputStream tmpO = new ByteArrayOutputStream(); MemoryStream tmpO = new MemoryStream(); fs.WriteFileSystem(tmpO); ByteArrayInputStream tmpI = new ByteArrayInputStream(tmpO.ToArray()); NPOIFSFileSystem nfs = new NPOIFSFileSystem(tmpI); DirectoryEntry dN1 = (DirectoryEntry)nfs.Root.GetEntry("DirA"); DirectoryEntry dN2 = (DirectoryEntry)nfs.Root.GetEntry("DirB"); DocumentEntry eNA1 = (DocumentEntry)dN1.GetEntry(entryA1.Name); DocumentEntry eNA2 = (DocumentEntry)dN1.GetEntry(entryA2.Name); DocumentEntry eNB1 = (DocumentEntry)dN2.GetEntry(entryB1.Name); Assert.AreEqual(false, EntryUtils.AreDocumentsIdentical(eNA1, eNA2)); Assert.AreEqual(true, EntryUtils.AreDocumentsIdentical(eNA1, eNB1)); Assert.AreEqual(false, EntryUtils.AreDocumentsIdentical(eNA1, entryA1b)); Assert.AreEqual(false, EntryUtils.AreDocumentsIdentical(eNA1, entryA2)); Assert.AreEqual(true, EntryUtils.AreDocumentsIdentical(eNA1, entryA1)); Assert.AreEqual(true, EntryUtils.AreDocumentsIdentical(eNA1, entryB1)); }
public void Fails_on_insufficient_balance() { var delta = EntryUtils.PrepareSingleContractEntryDelta(_recipient, _poorSender, 0); // when gas price is non-zero then sender needs to have a non-zero balance to pay for the gas cost delta.PublicEntries[0].GasPrice = 1.ToUint256ByteString(); delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); tracer.Received().MarkAsFailed(_recipient.ToKvmAddress(), 21000, Bytes.Empty, "invalid"); }
public void Fails_when_not_enough_gas_for_code_deposit() { var delta = EntryUtils.PrepareSingleContractEntryDelta(null, _senderPublicKey, 0, "0x60016000526001601FF300"); delta.PublicEntries[0].GasLimit = 53369; delta.PublicEntries[0].ReceiverAddress = ByteString.Empty; delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); var contractAddress = Address.OfContract(_senderPublicKey.ToKvmAddress(), 0); tracer.Received().MarkAsFailed(contractAddress, 53369, Arg.Any <byte[]>(), null); }
public void Can_self_destruct() { var delta = EntryUtils.PrepareSingleContractEntryDelta(null, _senderPublicKey, 0, "0x730001020304050607080910111213141516171819ff"); delta.PublicEntries[0].GasLimit = 1_000_000L; delta.PublicEntries[0].ReceiverAddress = ByteString.Empty; delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); var contractAddress = Address.OfContract(_senderPublicKey.ToKvmAddress(), 0); tracer.Received().MarkAsSuccess(contractAddress, 34343, Arg.Any <byte[]>(), Arg.Any <LogEntry[]>()); }
public void Does_not_crash_on_kvm_error() { // here we test a case when we deploy a contract where constructor throws invalid opcode EVM error // 0xfe is a bad opcode that immediately causes an EVM error var delta = EntryUtils.PrepareSingleContractEntryDelta(null, _senderPublicKey, 0, "0xfe"); delta.PublicEntries[0].GasLimit = 1_000_000L; delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); var contractAddress = Address.OfContract(_senderPublicKey.ToKvmAddress(), 0); tracer.Received().MarkAsFailed(contractAddress, 1_000_000L, Arg.Any <byte[]>(), "Error"); }
public void Can_deploy_code_read_only() { var delta = EntryUtils.PrepareSingleContractEntryDelta(null, _senderPublicKey, 0, "0x60016000526001601FF300"); delta.PublicEntries[0].GasLimit = 1_000_000L; delta.PublicEntries[0].ReceiverAddress = ByteString.Empty; delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.CallAndRestore(delta, tracer); var contractAddress = Address.OfContract(_senderPublicKey.ToKvmAddress(), 0); tracer.Received().MarkAsSuccess(contractAddress, 53370, Arg.Any <byte[]>(), Arg.Any <LogEntry[]>()); }
public void Does_not_crash_on_kvm_exception() { // here we test a case when we deploy a contract where constructor throws StackUnderflowException // 0x01 is the ADD opcode which requires two items on the stack and stack is empty here // added here for full coverage as the errors (EVM) are handled differently in some cases (via .NET exceptions) var delta = EntryUtils.PrepareSingleContractEntryDelta(null, _senderPublicKey, 0, "0x01"); delta.PublicEntries[0].GasLimit = 1_000_000L; delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); var contractAddress = Address.OfContract(_senderPublicKey.ToKvmAddress(), 0); tracer.Received().MarkAsFailed(contractAddress, 1_000_000L, Arg.Any <byte[]>(), "Error"); }
public void TestHeavilyNestedReWrite() { foreach (DirectoryNode root in openSSSample("ex42570-20305.xls", false)) { // Record the structure Dictionary <String, int> entries = new Dictionary <String, int>(); fetchSizes("/", root, entries); // Prepare to copy DirectoryNode dest; if (root.NFileSystem != null) { dest = (new NPOIFSFileSystem()).Root; } else { dest = (new OPOIFSFileSystem()).Root; } // Copy over EntryUtils.CopyNodes(root, dest); // Re-load, always as NPOIFS MemoryStream baos = new MemoryStream(); if (root.NFileSystem != null) { root.NFileSystem.WriteFileSystem(baos); } else { root.OFileSystem.WriteFileSystem(baos); } NPOIFSFileSystem read = new NPOIFSFileSystem( new MemoryStream(baos.ToArray())); // Check the structure matches CheckSizes("/", read.Root, entries); } }
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm) { IEntryModel[] entryModel; try { entryModel = await pm.GetValueAsEntryModelArrayAsync(EntryKey); } catch { return(ResultCommand.Error(new ArgumentException(EntryKey + " is not found or not a directory IEntryModel or IEntryModel[]"))); } string masks = pm.ReplaceVariableInsideBracketed(MaskKey); var filter = createFilter(ListOptions, masks); IEntryModel[] listItems = (await EntryUtils.ListAsync(entryModel, pm.CancellationToken, filter, false)).ToArray(); logger.Debug(String.Format("{0} = IEntryModel[{1}]", DestinationKey, listItems.Length)); pm.SetValue(DestinationKey, listItems); return(NextCommand); }
public void NPOIFSReadCopyWritePOIFSRead() { FileStream testFile = POIDataSamples.GetSpreadSheetInstance().GetFile("Simple.xls"); NPOIFSFileSystem src = new NPOIFSFileSystem(testFile); byte[] wbDataExp = IOUtils.ToByteArray(src.CreateDocumentInputStream("Workbook")); NPOIFSFileSystem nfs = new NPOIFSFileSystem(); EntryUtils.CopyNodes(src.Root, nfs.Root); src.Close(); MemoryStream bos = new MemoryStream(); nfs.WriteFileSystem(bos); nfs.Close(); POIFSFileSystem pfs = new POIFSFileSystem(new MemoryStream(bos.ToArray())); byte[] wbDataAct = IOUtils.ToByteArray(pfs.CreateDocumentInputStream("Workbook")); Assert.That(wbDataExp, new EqualConstraint(wbDataAct)); }
public void Update_storage_root_on_contract_clash() { var contractAddress = Address.OfContract(_senderPublicKey.ToKvmAddress(), 0); _stateProvider.CreateAccount(contractAddress, 1000.Kat()); _stateProvider.Commit(_specProvider.GenesisSpec); var delta = EntryUtils.PrepareSingleContractEntryDelta(null, _senderPublicKey, 0, "0x60016000526001601FF300"); delta.PublicEntries[0].GasLimit = 1_000_000L; delta.PublicEntries[0].ReceiverAddress = ByteString.Empty; delta.PublicEntries[0].Signature = delta.PublicEntries[0] .GenerateSignature(_cryptoContext, _senderPrivateKey, _signingContext); var tracer = Substitute.For <ITxTracer>(); tracer.IsTracingReceipt.Returns(true); _executor.Execute(delta, tracer); tracer.Received().MarkAsSuccess(contractAddress, 53370, Arg.Any <byte[]>(), Arg.Any <LogEntry[]>()); }
protected void CopyNodes(POIFSFileSystem source, POIFSFileSystem target, List <string> excepts) { EntryUtils.CopyNodes(source, target, excepts); }
public void TestAreDirectoriesIdentical() { POIFSFileSystem fs = new POIFSFileSystem(); DirectoryEntry dirA = fs.CreateDirectory("DirA"); DirectoryEntry dirB = fs.CreateDirectory("DirB"); // Names must match Assert.AreEqual(false, EntryUtils.AreDirectoriesIdentical(dirA, dirB)); // Empty dirs are fine DirectoryEntry dirA1 = dirA.CreateDirectory("TheDir"); DirectoryEntry dirB1 = dirB.CreateDirectory("TheDir"); Assert.AreEqual(0, dirA1.EntryCount); Assert.AreEqual(0, dirB1.EntryCount); Assert.AreEqual(true, EntryUtils.AreDirectoriesIdentical(dirA1, dirB1)); // Otherwise children must match dirA1.CreateDocument("Entry1", new ByteArrayInputStream(dataSmallA)); Assert.AreEqual(false, EntryUtils.AreDirectoriesIdentical(dirA1, dirB1)); dirB1.CreateDocument("Entry1", new ByteArrayInputStream(dataSmallA)); Assert.AreEqual(true, EntryUtils.AreDirectoriesIdentical(dirA1, dirB1)); dirA1.CreateDirectory("DD"); Assert.AreEqual(false, EntryUtils.AreDirectoriesIdentical(dirA1, dirB1)); dirB1.CreateDirectory("DD"); Assert.AreEqual(true, EntryUtils.AreDirectoriesIdentical(dirA1, dirB1)); // Excludes support List <String> excl = new List <string>(new String[] { "Ignore1", "IgnDir/Ign2" }); FilteringDirectoryNode fdA = new FilteringDirectoryNode(dirA1, excl); FilteringDirectoryNode fdB = new FilteringDirectoryNode(dirB1, excl); Assert.AreEqual(true, EntryUtils.AreDirectoriesIdentical(fdA, fdB)); // Add an ignored doc, no notice is taken fdA.CreateDocument("Ignore1", new ByteArrayInputStream(dataSmallA)); Assert.AreEqual(true, EntryUtils.AreDirectoriesIdentical(fdA, fdB)); // Add a directory with filtered contents, not the same DirectoryEntry dirAI = dirA1.CreateDirectory("IgnDir"); Assert.AreEqual(false, EntryUtils.AreDirectoriesIdentical(fdA, fdB)); DirectoryEntry dirBI = dirB1.CreateDirectory("IgnDir"); Assert.AreEqual(true, EntryUtils.AreDirectoriesIdentical(fdA, fdB)); // Add something to the filtered subdir that gets ignored dirAI.CreateDocument("Ign2", new ByteArrayInputStream(dataSmallA)); Assert.AreEqual(true, EntryUtils.AreDirectoriesIdentical(fdA, fdB)); // And something that doesn't dirAI.CreateDocument("IgnZZ", new ByteArrayInputStream(dataSmallA)); Assert.AreEqual(false, EntryUtils.AreDirectoriesIdentical(fdA, fdB)); dirBI.CreateDocument("IgnZZ", new ByteArrayInputStream(dataSmallA)); Assert.AreEqual(true, EntryUtils.AreDirectoriesIdentical(fdA, fdB)); }
protected void CopyNodes(DirectoryNode sourceRoot, DirectoryNode targetRoot, List <string> excepts) { EntryUtils.CopyNodes(sourceRoot, targetRoot, excepts); }
private void CopyNodeRecursively(Entry entry, DirectoryEntry target) { //System.err.println("copyNodeRecursively called with "+entry.Name+ // ","+target.Name); EntryUtils.CopyNodeRecursively(entry, target); }