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