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