/// <inheritdoc/>
public override void Serialize(FastStream stream)
{
CompactInt count = new CompactInt(Headers.Length);
count.WriteToStream(stream);
foreach (var hd in Headers)
{
hd.SerializeHeader(stream);
// Block serialization of header doesn't add tx count since there is no need for it.
// However, in a header payload (for unknown reason) one extra byte indicating zero tx count
// is added to each block header.
stream.Write((byte)0);
}
}
public void Write_ushort_ResizeTest()
{
var stream = new FastStream(1);
Helper.ComparePrivateField(stream, "buffer", new byte[1]);
stream.Write((ushort)31534);
byte[] expBuffer = new byte[1 + FastStream.DefaultCapacity];
expBuffer[0] = 0x2e;
expBuffer[1] = 0x7b;
Helper.ComparePrivateField(stream, "buffer", expBuffer);
Helper.ComparePrivateField(stream, "position", sizeof(ushort));
}
public void Constructor_DefaultTest()
{
PushDataOp op = new PushDataOp();
FastStream stream = new FastStream();
op.WriteToStream(stream);
byte[] actual = stream.ToByteArray();
byte[] expected = new byte[1] {
0
};
Assert.Equal(expected, actual);
}
public void SerializeTest()
{
byte[] hd1 = Helper.HexToBytes(Header1);
byte[] hd2 = Helper.HexToBytes(Header2);
GetBlocksPayload pl = new GetBlocksPayload(Version, new byte[][] { hd1, hd2 }, new byte[32]);
FastStream stream = new FastStream(4 + 32 + 32 + 32);
pl.Serialize(stream);
byte[] actual = stream.ToByteArray();
byte[] expected = Helper.HexToBytes(PayloadHex);
Assert.Equal(expected, actual);
}
public void SerializeTest(byte[] data, byte[] start)
{
var scr = new PubkeyScript(data);
var stream = new FastStream(data.Length + start.Length);
scr.Serialize(stream);
byte[] actual = stream.ToByteArray();
byte[] expected = new byte[start.Length + data.Length];
Buffer.BlockCopy(start, 0, expected, 0, start.Length);
Buffer.BlockCopy(data, 0, expected, start.Length, data.Length);
Assert.Equal(expected, actual);
}
private StackFrame ReadFrame(FastStream source)
{
StringBuilder sb = new StringBuilder();
// Address
source.SkipWhiteSpace();
source.ReadAsciiStringUpTo(' ', sb);
string address = sb.ToString();
sb.Clear();
// Trying to get the module and symbol...
source.SkipWhiteSpace();
source.ReadAsciiStringUpToLastBeforeTrue('(', sb, delegate(byte c)
{
if (c != '\n' && !source.EndOfStream)
{
return(true);
}
return(false);
});
string assumedSymbol = sb.ToString();
sb.Clear();
source.ReadAsciiStringUpTo('\n', sb);
string assumedModule = sb.ToString();
sb.Clear();
assumedModule = this.RemoveOuterBrackets(assumedModule.Trim());
string actualModule = assumedModule;
string actualSymbol = this.RemoveOuterBrackets(assumedSymbol.Trim());
if (assumedModule.EndsWith(".map"))
{
string[] moduleSymbol = this.GetSymbolFromMicrosoftMap(assumedSymbol, assumedModule);
actualSymbol = string.IsNullOrEmpty(moduleSymbol[1]) ? assumedModule : moduleSymbol[1];
actualModule = moduleSymbol[0];
}
// Can't use Path.GetFileName Because it throws on illegal Windows characters
actualModule = GetFileName(actualModule);
return(new StackFrame(address, actualModule, actualSymbol));
}
public void SerializeTest()
{
var pl = new SendCmpctPayload(true, 1);
var stream = new FastStream(9);
pl.Serialize(stream);
byte[] actual = stream.ToByteArray();
byte[] expected = new byte[9] {
1, 1, 0, 0, 0, 0, 0, 0, 0
};
Assert.Equal(expected, actual);
}
public void Write_bytes_bigTest()
{
FastStream stream = new FastStream();
byte[] data = Helper.GetBytes(Capacity + 1);
stream.Write(data);
byte[] expBuffer = new byte[Capacity * 2];
Buffer.BlockCopy(data, 0, expBuffer, 0, data.Length);
Assert.Equal(data, stream.ToByteArray());
Helper.ComparePrivateField(stream, "buffer", expBuffer);
Helper.ComparePrivateField(stream, "position", data.Length);
}
public void LongRestoreAndMovePastHistory()
{
FastStream stream = this.GetTestStream();
SkipBOM(stream);
var mp = stream.MarkPosition();
stream.SkipUpTo('a');
stream.RestoreToMark(mp);
StringBuilder sb = new StringBuilder();
stream.ReadAsciiStringUpTo('b', sb);
Assert.Equal("12345\r\n6789a\r\n", sb.ToString());
}
public void WriteToStreamForSigningSegWit_NotExecutedTest()
{
CodeSeparatorOp op = new CodeSeparatorOp()
{
IsExecuted = false
};
FastStream stream = new FastStream(5);
op.WriteToStreamForSigningSegWit(stream);
Assert.Equal(new byte[1] {
(byte)OP.CodeSeparator
}, stream.ToByteArray());
}
public void WriteToStreamForSigning_MultiTest()
{
FastStream stream = new FastStream(5);
CodeSeparatorOp op = new CodeSeparatorOp();
op.WriteToStreamForSigning(stream, new byte[][] { new byte[] { 1, 2 } });
// Execution should not make any difference
op.IsExecuted = true;
op.WriteToStreamForSigning(stream, new byte[][] { new byte[] { 1, 2 } });
Assert.Equal(new byte[0], stream.ToByteArray());
}
public void AddSerializedSizeTest(ulong val, int init, int expected)
{
var ci = new CompactInt(val);
var counter = new SizeCounter(init);
ci.AddSerializedSize(counter);
var stream = new FastStream(10);
ci.WriteToStream(stream);
Assert.Equal(expected, stream.GetSize() + init);
Assert.Equal(expected, counter.Size);
}
public void AddWithStackIntLengthTest(int init, int add)
{
var counter = new SizeCounter(init);
counter.AddWithStackIntLength(add);
var si = new StackInt(add);
var stream = new FastStream(5);
si.WriteToStream(stream);
int expected = stream.GetSize() + add + init;
Assert.Equal(expected, counter.Size);
}
public void AddCompactIntCountTest(int init, int add)
{
var counter = new SizeCounter(init);
counter.AddCompactIntCount(add);
var ci = new CompactInt(add);
var stream = new FastStream(9);
ci.WriteToStream(stream);
int expected = stream.GetSize() + init;
Assert.Equal(expected, counter.Size);
}
private ScheduleSwitch ReadScheduleSwitch(FastStream source)
{
StringBuilder sb = new StringBuilder();
source.SkipUpTo('=');
source.MoveNext();
source.ReadAsciiStringUpTo(' ', sb);
string prevComm = sb.ToString();
sb.Clear();
source.SkipUpTo('=');
source.MoveNext();
int prevTid = source.ReadInt();
source.SkipUpTo('=');
source.MoveNext();
int prevPrio = source.ReadInt();
source.SkipUpTo('=');
source.MoveNext();
char prevState = (char)source.Current;
source.MoveNext();
source.SkipUpTo('n'); // this is to bypass the ==>
source.SkipUpTo('=');
source.MoveNext();
source.ReadAsciiStringUpTo(' ', sb);
string nextComm = sb.ToString();
sb.Clear();
source.SkipUpTo('=');
source.MoveNext();
int nextTid = source.ReadInt();
source.SkipUpTo('=');
source.MoveNext();
int nextPrio = source.ReadInt();
return(new ScheduleSwitch(prevComm, prevTid, prevPrio, prevState, nextComm, nextTid, nextPrio));
}
public void Write_bytes_withPad_ResizeTest()
{
var stream = new FastStream(1);
byte[] data = new byte[] { 1, 2 };
byte[] expBytes = new byte[] { 1, 2, 0 };
stream.Write(data, 3);
byte[] expBuffer = new byte[FastStream.DefaultCapacity + 1];
Buffer.BlockCopy(data, 0, expBuffer, 0, data.Length);
Assert.Equal(expBytes, stream.ToByteArray());
Helper.ComparePrivateField(stream, "buffer", expBuffer);
Helper.ComparePrivateField(stream, "position", expBytes.Length);
}
public void Key_SignTxTest(string wif, ITransaction tx, ITransaction prvTx, SigHashType sht, int[] indexes, byte[] expSer)
{
using PrivateKey key = new(wif, NetworkType.TestNet);
for (int i = 0; i < indexes.Length; i++)
{
key.Sign(tx, prvTx, indexes[i], sht);
}
var stream = new FastStream(expSer.Length);
tx.Serialize(stream);
byte[] actualSer = stream.ToByteArray();
Assert.Equal(expSer, actualSer);
}
public void GetSizeTest()
{
var stream = new FastStream();
int s1 = stream.GetSize();
stream.Write((byte)1);
int s2 = stream.GetSize();
stream.Write(1);
int s3 = stream.GetSize();
Assert.Equal(0, s1);
Assert.Equal(1, s2);
Assert.Equal(5, s3);
}
public void Write_bytes_ResizeTest()
{
var stream = new FastStream(2);
Helper.ComparePrivateField(stream, "buffer", new byte[2]);
stream.Write(new byte[] { 1, 2, 3 });
byte[] expBuffer = new byte[2 + FastStream.DefaultCapacity];
expBuffer[0] = 1;
expBuffer[1] = 2;
expBuffer[2] = 3;
Helper.ComparePrivateField(stream, "buffer", expBuffer);
Helper.ComparePrivateField(stream, "position", 3);
}
public void SerializeForSigningTest(byte[] hash, uint index, uint seq, byte[] spendScr, bool changeSeq, byte[] expected)
{
TxIn tx = new TxIn()
{
TxHash = hash,
Index = index,
Sequence = seq
};
FastStream stream = new FastStream();
tx.SerializeForSigning(stream, spendScr, changeSeq);
byte[] actual = stream.ToByteArray();
Assert.Equal(expected, actual);
}
public void Write_byteTest(byte val)
{
var stream = new FastStream(10);
stream.Write(val);
byte[] expBuffer = new byte[10];
expBuffer[0] = val;
Assert.Equal(new byte[1] {
val
}, stream.ToByteArray());
Helper.ComparePrivateField(stream, "buffer", expBuffer);
Helper.ComparePrivateField(stream, "position", 1);
}
/// <summary>
/// Given a stream that contains PerfInfo commands, parses the stream and stores data in the given dictionary.
/// Key: somedll.ni.dll Value: {some guid}
/// </summary>
public void ParsePerfInfoFile(Stream stream, Dictionary <string, string> guids, Dictionary <string, ulong> baseAddresses)
{
FastStream source = new FastStream(stream);
source.MoveNext();
source.SkipWhiteSpace();
StringBuilder sb = new StringBuilder();
while (!source.EndOfStream)
{
source.ReadAsciiStringUpTo(';', sb);
source.MoveNext();
string command = sb.ToString();
sb.Clear();
if (command == "ImageLoad") // TODO: should be a constant maybe?
{
source.ReadAsciiStringUpTo(';', sb);
string path = sb.ToString();
sb.Clear();
source.MoveNext();
source.ReadAsciiStringUpTo(';', sb);
string guid = sb.ToString().TrimEnd();
sb.Clear();
source.MoveNext();
guids[GetFileName(path)] = guid;
// Check to see if the base address has been appended to the line.
if (source.Current != '\n')
{
sb.Clear();
source.ReadAsciiStringUpTo(';', sb);
string strBaseAddr = sb.ToString().TrimEnd();
if (!string.IsNullOrEmpty(strBaseAddr))
{
ulong baseAddr = ulong.Parse(strBaseAddr, System.Globalization.NumberStyles.HexNumber);
baseAddresses[GetFileName(path)] = baseAddr;
}
}
}
source.SkipUpTo('\n');
source.MoveNext();
}
}
public void Write_int_ResizeTest()
{
var stream = new FastStream(1);
Helper.ComparePrivateField(stream, "buffer", new byte[1]);
stream.Write(184104331);
byte[] expBuffer = new byte[1 + FastStream.DefaultCapacity];
expBuffer[0] = 0x8b;
expBuffer[1] = 0x35;
expBuffer[2] = 0xf9;
expBuffer[3] = 0x0a;
Helper.ComparePrivateField(stream, "buffer", expBuffer);
Helper.ComparePrivateField(stream, "position", sizeof(int));
}
public void TryDeserializeTest(byte[] data, bool ann, ulong ver)
{
var pl = new SendCmpctPayload();
bool success = pl.TryDeserialize(new FastStreamReader(data), out string error);
Assert.True(success, error);
Assert.Null(error);
Assert.Equal(ann, pl.Announce);
Assert.Equal(ver, pl.CmpctVersion);
// Test Serialize here to cover undefined (future) cases for version
var stream = new FastStream(9);
pl.Serialize(stream);
Assert.Equal(data, stream.ToByteArray());
}
/// <inheritdoc/>
public void Serialize(FastStream stream)
{
if (Items == null || Items.Length == 0)
{
stream.Write((byte)0);
}
else
{
CompactInt count = new CompactInt(Items.Length);
count.WriteToStream(stream);
foreach (var item in Items)
{
item.WriteToWitnessStream(stream);
}
}
}
public void Write_uint_ResizeTest()
{
var stream = new FastStream(1);
Helper.ComparePrivateField(stream, "buffer", new byte[1]);
stream.Write(1274051374U);
byte[] expBuffer = new byte[1 + FastStream.DefaultCapacity];
expBuffer[0] = 0x2e;
expBuffer[1] = 0x7b;
expBuffer[2] = 0xf0;
expBuffer[3] = 0x4b;
Helper.ComparePrivateField(stream, "buffer", expBuffer);
Helper.ComparePrivateField(stream, "position", sizeof(uint));
}
public void SerializeTest()
{
BlockPayload pl = new BlockPayload()
{
BlockData = new MockSerializableBlock(new byte[] { 1, 2, 3 })
};
FastStream stream = new FastStream(3);
pl.Serialize(stream);
byte[] actual = pl.Serialize();
byte[] expected = new byte[] { 1, 2, 3 };
Assert.Equal(expected, stream.ToByteArray());
Assert.Equal(expected, actual);
}
public void SerializeTest()
{
byte[] mockBlkHash = Helper.GetBytes(32);
var tx1 = new MockSerializableTx(new byte[] { 5, 6 });
var tx2 = new MockSerializableTx(new byte[] { 7, 8, 9, 10 });
var pl = new BlockTxnPayload(mockBlkHash, new ITransaction[] { tx1, tx2 });
var stream = new FastStream(32 + 1 + 2 + 4);
pl.Serialize(stream);
byte[] actual = stream.ToByteArray();
byte[] expected = Helper.HexToBytes($"{Helper.GetBytesHex(32)}0205060708090a");
Assert.Equal(expected, actual);
Assert.Equal(PayloadType.BlockTxn, pl.PayloadType);
}
/// <inheritdoc/>
public void SetToP2WSH_MultiSig(Signature[] sigs, RedeemScript redeem)
{
Items = new PushDataOp[sigs.Length + 2]; // OP_0 | Sig1 | sig2 | .... | sig(n) | redeemScript
Items[0] = new PushDataOp(OP._0);
for (int i = 1; i <= sigs.Length; i++)
{
Items[i] = new PushDataOp(sigs[i].ToByteArray());
}
FastStream stream = new FastStream();
PushDataOp temp = new PushDataOp(redeem.Data);
temp.WriteToStream(stream);
Items[^ 1] = new PushDataOp(stream.ToByteArray());
public void Resize_bigTest()
{
var stream = new FastStream();
int dataLen = FastStream.DefaultCapacity + (FastStream.DefaultCapacity + 5);
byte[] data = Helper.GetBytes(dataLen);
stream.Write(data);
int actualSize = stream.GetSize();
int expectedSize = dataLen;
byte[] expBuffer = new byte[dataLen];
Buffer.BlockCopy(data, 0, expBuffer, 0, data.Length);
Assert.Equal(expectedSize, actualSize);
Helper.ComparePrivateField(stream, "buffer", expBuffer);
}
