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