public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION) { BitcoinStream s = new BitcoinStream(stream, serializing) { ProtocolVersion = version }; serializable.ReadWrite(s); }
public int GetSize(IBitcoinSerializable data, TransactionOptions options) { var bms = new BitcoinStream(Stream.Null, true); bms.TransactionOptions = options; data.ReadWrite(bms); return((int)bms.Counter.WrittenBytes); }
public static int GetSerializedSize(this IBitcoinSerializable serializable, TransactionOptions options) { var bms = new BitcoinStream(Stream.Null, true); bms.TransactionOptions = options; serializable.ReadWrite(bms); return((int)bms.Counter.WrittenBytes); }
public static void FromBytes(this IBitcoinSerializable serializable, byte[] bytes) { using (var ms = new MemoryStream(bytes)) { var bitcoinStream = new BitcoinStream(ms, false); serializable.ReadWrite(bitcoinStream); } }
public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, ProtocolVersion protocolVersion = ProtocolVersion.PROTOCOL_VERSION) { serializable.ReadWrite(new BitcoinStream(stream, serializing) { ProtocolVersion = protocolVersion, ConsensusFactory = new DefaultConsensusFactory() }); }
public static byte[] ToBytes(this IBitcoinSerializable serializable, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION) { MemoryStream ms = new MemoryStream(); serializable.ReadWrite(new BitcoinStream(ms, true) { ProtocolVersion = version }); return ToArrayEfficient(ms); }
/// <summary> /// Gets serialized size of <paramref name="data"/> in bytes. /// </summary> /// <param name="data">Data that we calculate serialized size of.</param> /// <param name="options">Serialization options.</param> /// <returns>Serialized size of <paramref name="data"/> in bytes.</returns> /// TODO: this is a duplicate of the same method in BlockSizeRule <see cref="BlockSizeRule.GetSize"/> private int GetSize(IBitcoinSerializable data, TransactionOptions options) { var bms = new BitcoinStream(Stream.Null, true); bms.TransactionOptions = options; bms.ConsensusFactory = this.Parent.Network.Consensus.ConsensusFactory; data.ReadWrite(bms); return((int)bms.Counter.WrittenBytes); }
public static void FromBytes(this IBitcoinSerializable serializable, byte[] bytes, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION) { var bitcoinStream = new BitcoinStream(bytes) { ProtocolVersion = version }; serializable.ReadWrite(bitcoinStream); }
public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, uint?version = null) { BitcoinStream s = new BitcoinStream(stream, serializing) { ProtocolVersion = version }; serializable.ReadWrite(s); }
/// <summary> /// Gets serialized size of <paramref name="data"/> in bytes. /// </summary> /// <param name="network">The blockchain network.</param> /// <param name="data">Data that we calculate serialized size of.</param> /// <param name="options">Serialization options.</param> /// <returns>Serialized size of <paramref name="data"/> in bytes.</returns> public static int GetSize(Network network, IBitcoinSerializable data, NetworkOptions options) { var bms = new BitcoinStream(Stream.Null, true); bms.TransactionOptions = options; bms.ConsensusFactory = network.Consensus.ConsensusFactory; data.ReadWrite(bms); return((int)bms.Counter.WrittenBytes); }
public static byte[] ToBytes(this IBitcoinSerializable serializable, uint?version = null) { MemoryStream ms = new MemoryStream(); serializable.ReadWrite(new BitcoinStream(ms, true) { ProtocolVersion = version }); return(ToArrayEfficient(ms)); }
public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION, Network network = null) { network = network ?? Network.Main; serializable.ReadWrite(new BitcoinStream(stream, serializing) { ProtocolVersion = version, ConsensusFactory = network.Consensus.ConsensusFactory }); }
public static void FromBytes(this IBitcoinSerializable serializable, byte[] bytes, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION, NetworkOptions options = null) { var bms = new BitcoinStream(bytes) { ProtocolVersion = version, TransactionOptions = options }; serializable.ReadWrite(bms); }
public static byte[] ToBytes(this IBitcoinSerializable serializable, uint version) { using (var ms = new MemoryStream()) { var bms = new BitcoinStream(ms, true, version); serializable.ReadWrite(bms); return(ToArrayEfficient(ms)); } }
/// <summary> /// Gets serialized size of <paramref name="data"/> in bytes. /// </summary> /// <param name="data">Data that we calculate serialized size of.</param> /// <param name="options">Serialization options.</param> /// <returns>Serialized size of <paramref name="data"/> in bytes.</returns> public static int GetSize(this IBitcoinSerializable data, TransactionOptions options, ConsensusFactory consensusFactory) { var bms = new BitcoinStream(Stream.Null, true, consensusFactory) { TransactionOptions = options, }; data.ReadWrite(bms); return((int)bms.Counter.WrittenBytes); }
public static int GetSerializedSize(this IBitcoinSerializable serializable, TransactionOptions options) { var bitcoinStream = new BitcoinStream(Stream.Null, true) { ConsensusFactory = new DefaultConsensusFactory(), }; bitcoinStream.TransactionOptions = options; serializable.ReadWrite(bitcoinStream); return((int)bitcoinStream.Counter.WrittenBytes); }
public static void ReadWrite(this IBitcoinSerializable serializable, byte[] bytes, ConsensusFactory consensusFactory) { if (consensusFactory == null) { throw new ArgumentException("{0} cannot be null", nameof(consensusFactory)); } using (var stream = new MemoryStream(bytes)) { serializable.ReadWrite(new BitcoinStream(stream, false, consensusFactory)); } }
public static void FromBytes(this IBitcoinSerializable serializable, byte[] bytes, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION, Network network = null) { network = network ?? Network.Main; var bms = new BitcoinStream(bytes) { ProtocolVersion = version, ConsensusFactory = network.Consensus.ConsensusFactory }; serializable.ReadWrite(bms); }
public static byte[] ToBytes(this IBitcoinSerializable serializable, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION) { MemoryStream ms = new MemoryStream(); serializable.ReadWrite(new BitcoinStream(ms, true) { ProtocolVersion = version }); var bytes = ms.GetBuffer(); Array.Resize(ref bytes, (int)ms.Length); return(bytes); }
public static byte[] ToBytes(this IBitcoinSerializable serializable, ConsensusFactory consensusFactory, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION) { using (var ms = new MemoryStream()) { var bms = new BitcoinStream(ms, true) { ProtocolVersion = version, ConsensusFactory = consensusFactory ?? Network.Main.Consensus.ConsensusFactory }; serializable.ReadWrite(bms); return(ToArrayEfficient(ms)); } }
public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, ConsensusFactory consensusFactory, uint?version = null) { BitcoinStream s = new BitcoinStream(stream, serializing) { ProtocolVersion = version }; if (consensusFactory != null) { s.ConsensusFactory = consensusFactory; } serializable.ReadWrite(s); }
public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, ConsensusFactory consensusFactory, ProtocolVersion protocolVersion = ProtocolVersion.PROTOCOL_VERSION) { if (consensusFactory == null) { throw new ArgumentException("{0} cannot be null", nameof(consensusFactory)); } serializable.ReadWrite(new BitcoinStream(stream, serializing) { ProtocolVersion = protocolVersion, ConsensusFactory = consensusFactory }); }
public static byte[] ToBytes(this IBitcoinSerializable serializable, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION, NetworkOptions options = null) { using (MemoryStream ms = new MemoryStream()) { var bms = new BitcoinStream(ms, true) { ProtocolVersion = version, // If no options have been provided then take the options from the serializable (or default) TransactionOptions = options ?? ((serializable as IHaveNetworkOptions)?.GetNetworkOptions() ?? NetworkOptions.TemporaryOptions) }; serializable.ReadWrite(bms); return(ToArrayEfficient(ms)); } }
public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION, NetworkOptions options = null) { // If no options have been provided then take the options from the serializable if (options == null && serializing && serializable is IHaveNetworkOptions) { options = (serializable as IHaveNetworkOptions).GetNetworkOptions(); } serializable.ReadWrite(new BitcoinStream(stream, serializing) { ProtocolVersion = version, TransactionOptions = options }); }
public static void FromBytes(this IBitcoinSerializable serializable, byte[] bytes, ConsensusFactory consensusFactory, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION) { if (consensusFactory == null) { throw new ArgumentException("{0} cannot be null", nameof(consensusFactory)); } var bitcoinStream = new BitcoinStream(bytes) { ProtocolVersion = version, ConsensusFactory = consensusFactory }; serializable.ReadWrite(bitcoinStream); }
public static byte[] ToBytes(this IBitcoinSerializable serializable, ConsensusFactory consensusFactory) { if (consensusFactory == null) { throw new ArgumentException("{0} cannot be null", nameof(consensusFactory)); } using (var ms = new MemoryStream()) { var bms = new BitcoinStream(ms, true, consensusFactory); serializable.ReadWrite(bms); return(ToArrayEfficient(ms)); } }
public static byte[] ToBytes(this IBitcoinSerializable serializable, ConsensusFactory consensusFactory, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION) { if (consensusFactory == null) { throw new ArgumentException("{0} cannot be null", nameof(consensusFactory)); } using (var ms = new MemoryStream()) { var bms = new BitcoinStream(ms, true) { ProtocolVersion = version, ConsensusFactory = consensusFactory }; serializable.ReadWrite(bms); return(ToArrayEfficient(ms)); } }
public static void ReadWrite(this IBitcoinSerializable serializable, Stream stream, bool serializing, Network network, uint?version = null) { serializable.ReadWrite(stream, serializing, network?.Consensus?.ConsensusFactory, version); }
// We use this for big blocks, because the default array pool would allocate a new array. We do not need lot's of bucket such arrays are short lived. //readonly static Lazy<ArrayPool<byte>> BigArrayPool = new Lazy<ArrayPool<byte>>(() => ArrayPool<byte>.Create(0x02000000, 5), false); //ArrayPool<byte> GetArrayPool(int size) => size < 1_048_576 ? ArrayPool<byte>.Shared : BigArrayPool.Value; public void ReadWrite(BitcoinStream stream) { if (Payload == null && stream.Serializing) { throw new InvalidOperationException("Payload not affected"); } if (stream.Serializing || (!stream.Serializing && !_SkipMagic)) { stream.ReadWrite(ref magic); } stream.ReadWrite(ref command); if (stream.Serializing) { // We can optimize by calculating the length at the same time we calculate the checksum if (stream.ProtocolCapabilities.SupportCheckSum) { var hashStream = stream.ProtocolCapabilities.GetChecksumHashStream(); var bsStream = new BitcoinStream(hashStream, true); bsStream.CopyParameters(stream); Payload.ReadWrite(bsStream); var length = (int)bsStream.Counter.WrittenBytes; var checksum = hashStream.GetHash().GetLow32(); stream.ReadWrite(ref length); stream.ReadWrite(ref checksum); } else { var bitcoinStream = new BitcoinStream(Stream.Null, true); bitcoinStream.CopyParameters(stream); Payload.ReadWrite(bitcoinStream); var length = (int)bitcoinStream.Counter.WrittenBytes; stream.ReadWrite(ref length); } stream.ReadWrite(Payload); } else { int length = 0; stream.ReadWrite(ref length); if (length < 0 || length > 0x02000000) //MAX_SIZE 0x02000000 Serialize.h { throw new FormatException("Message payload too big ( > 0x02000000 bytes)"); } //var arrayPool = GetArrayPool(length); var payloadBytes = new byte[length]; // arrayPool.Rent(length); try { uint expectedChecksum = 0; if (stream.ProtocolCapabilities.SupportCheckSum) { stream.ReadWrite(ref expectedChecksum); } stream.ReadWrite(ref payloadBytes, 0, length); // We do not verify the checksum anymore because for 1000 blocks, it takes 80 seconds. BitcoinStream payloadStream = new BitcoinStream(new MemoryStream(payloadBytes, 0, length, false), false); payloadStream.CopyParameters(stream); var payloadType = PayloadAttribute.GetCommandType(Command); var unknown = payloadType == typeof(UnknowPayload); if (unknown) { Logs.NodeServer.LogWarning("Unknown command received {command}", Command); } IBitcoinSerializable payload = null; if (!stream.ConsensusFactory.TryCreateNew(payloadType, out payload)) { payload = (IBitcoinSerializable)Activator.CreateInstance(payloadType); } payload.ReadWrite(payloadStream); if (unknown) { ((UnknowPayload)payload)._Command = Command; } Payload = (Payload)payload; } finally { payloadBytes = null; // arrayPool.Return(payloadBytes); } } }