private uint[] Convert8To11(FastStream stream)
{
using Sha256 sha = new Sha256();
byte[] hash = sha.ComputeHash(stream.ToByteArray());
int bitSize = stream.GetSize() * 8;
int cs = 11 - (bitSize % 11);
if (cs < 4)
{
cs += 11;
}
Debug.Assert(cs >= 4 && cs <= 14);
stream.Write(hash, 0, cs > 8 ? 2 : 1);
bitSize += cs;
int wordCount = bitSize / 11;
Debug.Assert(bitSize % 11 == 0);
byte[] ba = stream.ToByteArray();
uint[] bits = new uint[(int)Math.Ceiling((double)bitSize / 32)];
for (int i = 0, j = 0; j < bits.Length; i += 4, j++)
{
bits[j] = (uint)(ba[i + 3] | (ba[i + 2] << 8) | (ba[i + 1] << 16) | (ba[i] << 24));
}
int itemIndex = 0;
int bitIndex = 0;
// Number of bits in a word
int toTake = 11;
// UInt32 is 32 bit!
int maxBits = 32;
uint[] wordIndexes = new uint[wordCount];
for (int i = 0; i < wordIndexes.Length; i++)
{
if (bitIndex + toTake <= maxBits)
{
wordIndexes[i] = (bits[itemIndex] << bitIndex) >> (maxBits - toTake);
}
else
{
wordIndexes[i] = ((bits[itemIndex] << bitIndex) >> (maxBits - toTake)) |
(bits[itemIndex + 1] >> (maxBits - toTake + maxBits - bitIndex));
}
bitIndex += toTake;
if (bitIndex >= maxBits)
{
bitIndex -= maxBits;
itemIndex++;
}
}
return(wordIndexes);
}
public void SerializeTest()
{
var blk = new Block()
{
Header = BlockHeaderTests.GetSampleBlockHeader(),
TransactionList = new ITransaction[]
{
new MockSerializableTx(new byte[] { 1, 2, 3 }),
new MockSerializableTx(new byte[] { 10, 20, 30 }),
new MockSerializableTx(new byte[] { 255, 255 })
}
};
var stream = new FastStream(90);
blk.Serialize(stream);
byte[] expected = new byte[80 + 1 + (3 + 3 + 2)];
Buffer.BlockCopy(BlockHeaderTests.GetSampleBlockHeaderBytes(), 0, expected, 0, Constants.BlockHeaderSize);
expected[80] = 3; // Tx count
expected[81] = 1;
expected[82] = 2;
expected[83] = 3;
expected[84] = 10;
expected[85] = 20;
expected[86] = 30;
expected[87] = 255;
expected[88] = 255;
Assert.Equal(expected, stream.ToByteArray());
Assert.Equal(expected, blk.Serialize());
}
/// <summary>
/// Initializes a new instance of <see cref="ReturnOp"/> using the given <see cref="IScript"/>.
/// </summary>
/// <exception cref="ArgumentNullException"/>
/// <param name="scr">Script to use</param>
/// <param name="usePushOp">
/// [Default value = true]
/// If true, the data will be included after <see cref="OP.RETURN"/> using <see cref="PushDataOp"/> scheme.
/// </param>
public ReturnOp(IScript scr, bool usePushOp = true)
{
if (scr == null)
{
throw new ArgumentNullException(nameof(scr), "Script can not be null.");
}
byte[] temp = scr.Data;
if (usePushOp)
{
StackInt size = new StackInt(temp.Length);
FastStream stream = new FastStream(temp.Length + 2);
stream.Write((byte)OP.RETURN);
size.WriteToStream(stream);
stream.Write(temp);
data = stream.ToByteArray();
}
else
{
data = new byte[temp.Length + 1];
data[0] = (byte)OP.RETURN;
Buffer.BlockCopy(temp, 0, data, 1, temp.Length);
}
}
public void CheckVersionTest(MockNodeStatus ns, IClientSettings cs, IBlockchain bc, Message msg, Message[] expected)
{
var rep = new ReplyManager(ns, bc, cs)
{
rng = new MockNonceRng(0x0158a8e8ba5f3ed3)
};
Message[] actual = rep.GetReply(msg);
if (expected is null)
{
Assert.Null(actual);
}
else
{
Assert.NotNull(actual);
Assert.Equal(expected.Length, actual.Length);
for (int i = 0; i < expected.Length; i++)
{
var actualStream = new FastStream(Constants.MessageHeaderSize + actual[i].PayloadData.Length);
var expectedStream = new FastStream(Constants.MessageHeaderSize + expected[i].PayloadData.Length);
actual[i].Serialize(actualStream);
expected[i].Serialize(expectedStream);
Assert.Equal(expectedStream.ToByteArray(), actualStream.ToByteArray());
}
}
// Mock will change the following bool to false if it were called.
Assert.False(ns.updateTime, "UpdateTime() was never called");
// Mock either doesn't have any h.s. to set or if it did set h.s. it was checked and then turned to null
Assert.Null(ns._handShakeToSet);
}
/// <summary>
/// Converts this instance to its byte array representation.
/// </summary>
/// <returns>An array of bytes</returns>
public virtual byte[] Serialize()
{
FastStream stream = new FastStream();
Serialize(stream);
return(stream.ToByteArray());
}
/// <summary>
/// Sets <see cref="SocketAsyncEventArgs"/>'s buffer for a send operation
/// (caller must check <see cref="HasDataToSend"/> before calling this)
/// </summary>
/// <param name="sendEventArgs">Socket arg to use</param>
public void SetSendBuffer(SocketAsyncEventArgs sendEventArgs)
{
if (DataToSend == null)
{
if (!toSendQueue.TryDequeue(out Message msg))
{
sendEventArgs.SetBuffer(sendEventArgs.Offset, 0);
return;
}
FastStream stream = new FastStream(Constants.MessageHeaderSize + msg.PayloadData.Length);
msg.Serialize(stream);
DataToSend = stream.ToByteArray();
}
if (DataToSend.Length <= buffLen)
{
Buffer.BlockCopy(DataToSend, 0, sendEventArgs.Buffer, sendEventArgs.Offset, DataToSend.Length);
sendEventArgs.SetBuffer(sendEventArgs.Offset, DataToSend.Length);
DataToSend = null;
}
else // (DataToSend.Length > buffLen)
{
Buffer.BlockCopy(DataToSend, 0, sendEventArgs.Buffer, sendEventArgs.Offset, buffLen);
sendEventArgs.SetBuffer(sendEventArgs.Offset, buffLen);
byte[] rem = new byte[DataToSend.Length - buffLen];
Buffer.BlockCopy(DataToSend, buffLen, rem, 0, rem.Length);
DataToSend = rem;
}
}
public void GetVersionMsgTest()
{
var ns = new MockNodeStatus();
var cs = new MockClientSettings()
{
_protoVer = 123,
_services = NodeServiceFlags.All,
_time = 456,
_port = 789,
_ua = "foo",
_relay = true,
_netType = NetworkType.TestNet
};
var bc = new MockBlockchain()
{
_height = 12345
};
var rep = new ReplyManager(ns, bc, cs)
{
rng = new MockNonceRng(0x0158a8e8ba5f3ed3)
};
Message msg = rep.GetVersionMsg();
FastStream actual = new FastStream();
msg.Serialize(actual);
byte[] expected = Helper.HexToBytes("0b11090776657273696f6e0000000000590000000ba371327b0000001f04000000000000c8010000000000001f0400000000000000000000000000000000ffff7f00000103151f0400000000000000000000000000000000ffff7f0000010315d33e5fbae8a8580103666f6f3930000001");
Assert.Equal(expected, actual.ToByteArray());
}
/// <summary>
/// Returns base58-encoded string representation of this instance.
/// </summary>
/// <exception cref="ObjectDisposedException"/>
/// <exception cref="ArgumentNullException"/>
/// <param name="xType">Extended key type to return</param>
/// <returns>Base58-encoded extended key</returns>
public string ToBase58(XType xType)
{
if (isDisposed)
{
throw new ObjectDisposedException(nameof(BIP0032), "Instance was disposed.");
}
bool isPub = IsPublic(xType);
if (!isPub && PrvKey is null)
{
throw new ArgumentNullException(nameof(PrvKey), "Can not get extended private key from public key.");
}
FastStream stream = new FastStream(ExtendedKeyLength);
stream.WriteBigEndian((uint)xType);
stream.Write(ExtendedKeyDepth);
stream.Write(ParentFingerPrint);
stream.Write(ChildNumber);
stream.Write(ChainCode);
if (isPub)
{
stream.Write(PubKey.ToByteArray(true));
}
else
{
stream.Write((byte)0);
stream.Write(PrvKey.ToBytes());
}
return(Base58.EncodeWithChecksum(stream.ToByteArray()));
}
public static string BuildErrorStr(ITransaction tx, string error)
{
var stream = new FastStream();
tx.Serialize(stream);
return($"Error message: {error}{Environment.NewLine}Tx: {stream.ToByteArray().ToBase16()}");
}
public static PubkeyScript GetPubScr(string scr)
{
var stream = new FastStream(scr.Length / 2 /*A good estimate of size*/);
foreach (var item in scr.Split(' ', StringSplitOptions.RemoveEmptyEntries))
{
// Handle any hex
if (item.StartsWith("0x"))
{
stream.Write(Helper.HexToBytes(item.Substring(2)));
}
// All integers such as numbers in multi-sig 1, 2,...
else if (long.TryParse(item, out long val))
{
new PushDataOp(val).WriteToStream(stream);
}
// All OP codes that sometime are written as OP_XX and sometimes as XX without OP_
else if (Enum.TryParse(item.StartsWith("OP") ? item.Remove(0, 3) : item, true, out OP op))
{
stream.Write((byte)op);
}
// Handles any OP code that fell through because the name starts with 1 (1DUP instead of DUP1)
else if (Enum.TryParse(item.StartsWith("1") ? $"{item.Substring(1)}1" : item, true, out OP op2))
{
stream.Write((byte)op2);
}
// Catch any script that is written badly and is not caught and parsed here
else
{
Assert.True(false, item);
}
}
return(new PubkeyScript(stream.ToByteArray()));
}
public void GetReplyTest(MockNodeStatus ns, IClientSettings cs, IBlockchain bc, Message msg, Message[] expected)
{
var rep = new ReplyManager(ns, bc, cs);
Message[] actual = rep.GetReply(msg);
if (expected is null)
{
Assert.Null(actual);
}
else
{
Assert.NotNull(actual);
Assert.Equal(expected.Length, actual.Length);
for (int i = 0; i < expected.Length; i++)
{
var actualStream = new FastStream(Constants.MessageHeaderSize + actual[i].PayloadData.Length);
var expectedStream = new FastStream(Constants.MessageHeaderSize + expected[i].PayloadData.Length);
actual[i].Serialize(actualStream);
expected[i].Serialize(expectedStream);
Assert.Equal(expectedStream.ToByteArray(), actualStream.ToByteArray());
}
}
// Mock will change the following bools to false if it were called.
Assert.False(ns.updateTime, "UpdateTime() was never called");
Assert.False(ns.smallViolation, "AddSmallViolation() was never called");
Assert.False(ns.mediumViolation, "AddMediumViolation() was never called");
Assert.False(ns.bigViolation, "AddBigViolation() was never called");
}
public void SerializeTest()
{
Data = new byte[] { 1, 2, 3 };
FastStream stream = new FastStream(3);
Serialize(stream);
Assert.Equal(new byte[] { 3, 1, 2, 3 }, stream.ToByteArray());
}
/// <summary>
/// Sets <see cref="SocketAsyncEventArgs"/>'s buffer for a send operation using the given <see cref="Message"/>.
/// </summary>
/// <param name="sendSAEA">Socket arg to use</param>
/// <param name="msg">Message to send</param>
public void SetSendBuffer(SocketAsyncEventArgs sendSAEA, Message msg)
{
var stream = new FastStream();
msg.Serialize(stream);
DataToSend = stream.ToByteArray();
SetSendBuffer(sendSAEA);
}
public void WriteToStreamTest(byte[] expected, uint value)
{
LockTime lt = new LockTime(value);
FastStream stream = new FastStream();
lt.WriteToStream(stream);
Assert.Equal(expected, stream.ToByteArray());
}
public void SerializeTest(InventoryType t, byte[] hash, byte[] expected)
{
var inv = new Inventory(t, hash);
var stream = new FastStream(Inventory.Size);
inv.Serialize(stream);
byte[] actual = stream.ToByteArray();
Assert.Equal(expected, actual);
}
public void WriteToStreamTest()
{
var stream = new FastStream(4);
var tar = new Target(0x171f0d9b);
tar.WriteToStream(stream);
Assert.Equal(new byte[] { 0x9b, 0x0d, 0x1f, 0x17 }, stream.ToByteArray());
}
public void SerializeTest(Inventory[] items, byte[] expected)
{
var pl = new InvPayload(items);
var stream = new FastStream((items.Length * Inventory.Size) + 2);
pl.Serialize(stream);
byte[] actual = stream.ToByteArray();
Assert.Equal(expected, actual);
}
public void ToByteArrayTest()
{
var stream = new FastStream();
byte[] ba1 = stream.ToByteArray();
stream.Write((byte)1);
byte[] ba2 = stream.ToByteArray();
stream.Write(2);
byte[] ba3 = stream.ToByteArray();
Assert.Equal(Array.Empty <byte>(), ba1);
Assert.Equal(new byte[1] {
1
}, ba2);
Assert.Equal(new byte[5] {
1, 2, 0, 0, 0
}, ba3);
}
public void WriteWithCompactIntLength(byte[] data, byte[] expBuffer, int expPos)
{
var stream = new FastStream(expPos);
stream.WriteWithCompactIntLength(data);
Assert.Equal(expBuffer, stream.ToByteArray());
Helper.ComparePrivateField(stream, "position", expPos);
}
public void WriteToStreamTest(byte[] ba, byte[] expected)
{
ReturnOp op = new ReturnOp(ba, false);
FastStream stream = new FastStream();
op.WriteToStream(stream);
byte[] actual = stream.ToByteArray();
Assert.Equal(expected, actual);
}
public void ConstructorTest()
{
FastStream stream = new FastStream();
byte[] expected = new byte[Capacity];
Helper.ComparePrivateField(stream, "buffer", expected);
Helper.ComparePrivateField(stream, "position", 0);
Assert.Equal(new byte[0], stream.ToByteArray());
}
public void WriteToStreamWithRecId_NochangeTest()
{
Signature sig = new Signature(1, 2, 164);
FastStream stream = new FastStream();
sig.WriteToStreamWithRecId(stream);
byte[] expected = Helper.HexToBytes("a4" + "0000000000000000000000000000000000000000000000000000000000000001" +
"0000000000000000000000000000000000000000000000000000000000000002");
Assert.Equal(expected, stream.ToByteArray());
}
public void ConstructorTest()
{
var stream = new FastStream();
byte[] expected = new byte[FastStream.DefaultCapacity];
Helper.ComparePrivateField(stream, "buffer", expected);
Helper.ComparePrivateField(stream, "position", 0);
Assert.Equal(Array.Empty <byte>(), stream.ToByteArray());
}
public void Constructor_CapactiyTest(int cap, int expLen)
{
var stream = new FastStream(cap);
byte[] expBuffer = new byte[expLen];
Helper.ComparePrivateField(stream, "buffer", expBuffer);
Helper.ComparePrivateField(stream, "position", 0);
Assert.Equal(Array.Empty <byte>(), stream.ToByteArray());
}
public void Write_bytesFromIndex_ZeroCount_test()
{
var stream = new FastStream(10);
byte[] data = new byte[] { 1, 2, 3, 4, 5 };
stream.Write(data, 1, 0);
Assert.Equal(Array.Empty <byte>(), stream.ToByteArray());
Helper.ComparePrivateField(stream, "position", 0);
}
public void PayloadTest(IMessagePayload payload, PayloadType expPlType)
{
var stream = new FastStream();
payload.Serialize(stream);
Assert.Empty(stream.ToByteArray());
Assert.Equal(expPlType, payload.PayloadType);
Assert.Equal(new byte[] { 0x5d, 0xf6, 0xe0, 0xe2 }, payload.GetChecksum());
}
public void Write_bytesFromIndex_test()
{
var stream = new FastStream(10);
byte[] data = new byte[] { 1, 2, 3, 4, 5 };
stream.Write(data, 1, 3);
byte[] expBuffer = new byte[] { 2, 3, 4 };
Assert.Equal(expBuffer, stream.ToByteArray());
Helper.ComparePrivateField(stream, "position", expBuffer.Length);
}
public void SerializeTest()
{
PingPayload ping = new PingPayload(1);
FastStream stream = new FastStream(8);
ping.Serialize(stream);
Assert.Equal(new byte[8] {
1, 0, 0, 0, 0, 0, 0, 0
}, stream.ToByteArray());
}
public void WriteToStreamWithRecIdTest(BigInteger r, BigInteger s, byte v, bool isComp, byte[] expected)
{
Signature sig = new Signature(r, s, v);
FastStream stream = new FastStream();
sig.WriteToStreamWithRecId(stream, isComp);
byte[] actual = stream.ToByteArray();
Assert.Equal(expected, actual);
}
public void SerializeTest()
{
FeeFilterPayload pl = new FeeFilterPayload(48_508);
FastStream stream = new FastStream(8);
pl.Serialize(stream);
byte[] actual = stream.ToByteArray();
byte[] expected = Helper.HexToBytes("7cbd000000000000");
Assert.Equal(expected, actual);
}
