public static AddressManager LoadPeerFile(string filePath, ProtocolData expectedNetwork = null)
{
var addrman = new AddressManager();
byte[] data, hash;
using (var fs = File.Open(filePath, FileMode.Open, FileAccess.Read))
{
data = new byte[fs.Length - 32];
fs.Read(data, 0, data.Length);
hash = new byte[32];
fs.Read(hash, 0, 32);
}
var actual = Hashes.Hash256(data);
var expected = new uint256(hash);
if (expected != actual)
{
throw new FormatException("Invalid address manager file");
}
CoinStream stream = new CoinStream(data);
stream.Type = SerializationType.Disk;
uint magic = 0;
stream.ReadWrite(ref magic);
if (expectedNetwork != null && expectedNetwork.Magic != magic)
{
throw new FormatException("This file is not for the expected network");
}
addrman.ReadWrite(stream);
return(addrman);
}
public static void StaticWrite(CoinStream bs, ulong length)
{
if (!bs.Serializing)
{
throw new InvalidOperationException("Stream should be serializing");
}
var stream = bs.Inner;
bs.Counter.AddWritten(1);
if (length < 0xFD)
{
stream.WriteByte((byte)length);
}
else if (length <= 0xffff)
{
var value = (ushort)length;
stream.WriteByte((byte)0xFD);
bs.ReadWrite(ref value);
}
else if (length <= 0xffff)
{
var value = (uint)length;
stream.WriteByte((byte)0xFE);
bs.ReadWrite(ref value);
}
else if (length <= 0xffffffff)
{
var value = length;
stream.WriteByte((byte)0xFF);
bs.ReadWrite(ref value);
}
}
public void ReadWrite(CoinStream stream)
{
stream.ReadWrite(ref _chainHeight);
stream.ReadWrite(ref _chainTipHash);
stream.ReadWrite(ref _bitmap);
stream.ReadWrite(ref _outputs);
}
public void ReadWrite(CoinStream stream)
{
using (stream.SerializationTypeScope(SerializationType.Network))
{
ReadWriteCore(stream);
}
}
public void SavePeerFile(string filePath, ProtocolData network)
{
if (network == null)
{
throw new ArgumentNullException(nameof(network));
}
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
MemoryStream ms = new MemoryStream();
CoinStream stream = new CoinStream(ms, true);
stream.Type = SerializationType.Disk;
stream.ReadWrite(network.Magic);
stream.ReadWrite(this);
var hash = Hashes.Hash256(ms.ToArray());
stream.ReadWrite(hash.AsCoinSerializable());
string dirPath = Path.GetDirectoryName(filePath);
if (!string.IsNullOrWhiteSpace(dirPath))
{
Directory.CreateDirectory(dirPath);
}
File.WriteAllBytes(filePath, ms.ToArray());
}
public void ReadWrite(CoinStream stream)
{
stream.ReadWrite(ref _Address);
stream.ReadWrite(ref source);
stream.ReadWrite(ref nLastSuccess);
stream.ReadWrite(ref nAttempts);
}
public override void ReadWriteCore(CoinStream stream)
{
var old = stream.MaxArraySize;
stream.MaxArraySize = 5000;
stream.ReadWrite(ref _Inventory);
stream.MaxArraySize = old;
}
public override void ReadWriteCore(CoinStream stream)
{
if (!stream.Serializing)
{
_Object = default(T);
}
stream.ReadWrite(ref _Object);
}
public void ReadWrite(CoinStream stream)
{
stream.ReadWrite(ref _Header);
VarInt txCount = new VarInt(0);
stream.ReadWrite(ref txCount);
}
private void UpdatePayload(CoinStream stream)
{
MemoryStream ms = new MemoryStream();
var seria = new CoinStream(ms, true);
seria.CopyParameters(stream);
ReadWritePayloadFields(seria);
payload = new VarString(ms.ToArray());
}
public static void ReadWrite(this ICoinSerializable serializable, Stream stream, bool serializing, uint version = 70012)
{
CoinStream s = new CoinStream(stream, serializing)
{
ProtocolVersion = version
};
serializable.ReadWrite(s);
}
public static void ReadWrite(this CoinStream serializable, ref HDFingerprint lFingerprint)
{
var bytes = lFingerprint.ToBytes();
serializable.ReadWrite(ref bytes);
if (!serializable.Serializing)
{
lFingerprint = new HDFingerprint(bytes);
}
}
public override void ReadWriteCore(CoinStream stream)
{
stream.ReadWrite(ref _Message);
stream.ReadWrite(ref _Code);
stream.ReadWrite(ref _Reason);
if (Message == "tx" || Message == "block")
{
stream.ReadWrite(ref _Hash);
}
}
public static int GetSerializedSize(this ICoinSerializable serializable, TransactionOptions options)
{
CoinStream bms = new CoinStream(Stream.Null, true)
{
TransactionOptions = options
};
serializable.ReadWrite(bms);
return((int)bms.Counter.WrittenBytes);
}
public static int GetSerializedSize(this ICoinSerializable serializable, uint version, SerializationType serializationType)
{
CoinStream s = new CoinStream(Stream.Null, true)
{
Type = serializationType
};
s.ReadWrite(serializable);
return((int)s.Counter.WrittenBytes);
}
internal static void StaticRead(CoinStream bs, ref byte[] bytes)
{
var len = VarInt.StaticRead(bs);
if (len > (uint)bs.MaxArraySize)
{
throw new ArgumentOutOfRangeException("Array size too big");
}
bytes = new byte[len];
bs.ReadWrite(ref bytes);
}
public void ReadWrite(CoinStream stream)
{
if (stream.Serializing)
{
StaticWrite(stream, _Value);
}
else
{
_Value = StaticRead(stream);
}
}
private void UpdateShortTxIDSelector()
{
MemoryStream ms = new MemoryStream();
CoinStream stream = new CoinStream(ms, true);
stream.ReadWrite(ref _Header);
stream.ReadWrite(ref _Nonce);
uint256 shorttxidhash = new uint256(Hashes.SHA256(ms.ToArrayEfficient()));
_ShortTxidk0 = Hashes.SipHasher.GetULong(shorttxidhash, 0);
_ShortTxidk1 = Hashes.SipHasher.GetULong(shorttxidhash, 1);
}
public override void ReadWriteCore(CoinStream stream)
{
stream.ReadWrite(ref payload);
if (!stream.Serializing)
{
var payloadStream = new CoinStream(payload.GetString());
payloadStream.CopyParameters(stream);
ReadWritePayloadFields(payloadStream);
}
stream.ReadWrite(ref signature);
}
public void ReadWrite(CoinStream stream)
{
using (stream.BigEndianScope())
{
stream.ReadWrite(ref nDepth);
stream.ReadWrite(ref parentFingerprint);
stream.ReadWrite(ref nChild);
stream.ReadWrite(ref vchChainCode);
byte b = 0;
stream.ReadWrite(ref b);
stream.ReadWrite(ref key);
}
}
public void ReadWrite(CoinStream stream)
{
if (stream.Serializing)
{
ulong n = _Value;
#if HAS_SPAN
Span <byte> tmp = stackalloc byte[(_Size * 8 + 6) / 7];
#else
byte[] tmp = new byte[(_Size * 8 + 6) / 7];
#endif
int len = 0;
while (true)
{
byte a = (byte)(n & 0x7F);
byte b = (byte)(len != 0 ? 0x80 : 0x00);
tmp[len] = (byte)(a | b);
if (n <= 0x7F)
{
break;
}
n = (n >> 7) - 1;
len++;
}
do
{
byte b = tmp[len];
stream.ReadWrite(ref b);
} while (len-- != 0);
}
else
{
ulong n = 0;
while (true)
{
byte chData = 0;
stream.ReadWrite(ref chData);
ulong a = (n << 7);
byte b = (byte)(chData & 0x7F);
n = (a | b);
if ((chData & 0x80) != 0)
{
n++;
}
else
{
break;
}
}
_Value = n;
}
}
internal static void StaticWrite(CoinStream bs, byte[] bytes)
{
var len = bytes == null ? 0 : (ulong)bytes.Length;
if (len > (uint)bs.MaxArraySize)
{
throw new ArgumentOutOfRangeException("Array size too big");
}
VarInt.StaticWrite(bs, len);
if (bytes != null)
{
bs.ReadWrite(ref bytes);
}
}
internal ExtPubKey(CoinStream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
stream.ReadWrite(ref nDepth);
stream.ReadWrite(ref parentFingerprint);
stream.ReadWrite(ref nChild);
stream.ReadWrite(ref vchChainCode);
var pubkeyBytes = new byte[33];
stream.ReadWrite(ref pubkeyBytes);
pubkey = new PubKey(pubkeyBytes);
}
public override void ReadWriteCore(CoinStream stream)
{
if (stream.Serializing)
{
List <BlockHeaderWithTxCount> heardersOff = headers.Select(h => new BlockHeaderWithTxCount(h)).ToList();
stream.ReadWrite(ref heardersOff);
}
else
{
headers.Clear();
List <BlockHeaderWithTxCount> headersOff = new List <BlockHeaderWithTxCount>();
stream.ReadWrite(ref headersOff);
headers.AddRange(headersOff.Select(h => h._Header));
}
}
private void ReadWritePayloadFields(CoinStream payloadStream)
{
payloadStream.ReadWrite(ref version);
payloadStream.ReadWrite(ref relayUntil);
payloadStream.ReadWrite(ref expiration);
payloadStream.ReadWrite(ref id);
payloadStream.ReadWrite(ref cancel);
payloadStream.ReadWrite(ref setCancel);
payloadStream.ReadWrite(ref minVer);
payloadStream.ReadWrite(ref maxVer);
payloadStream.ReadWrite(ref setSubVer);
payloadStream.ReadWrite(ref priority);
payloadStream.ReadWrite(ref comment);
payloadStream.ReadWrite(ref statusBar);
payloadStream.ReadWrite(ref reserved);
}
public override void ReadWriteCore(CoinStream stream)
{
stream.ReadWrite(ref _BlockId);
ulong indexes_size = (ulong)_Indices.Count;
stream.ReadWriteAsVarInt(ref indexes_size);
if (!stream.Serializing)
{
ulong i = 0;
ulong indicesCount = 0;
while ((ulong)_Indices.Count < indexes_size)
{
indicesCount = Math.Min(1000UL + (ulong)indicesCount, (ulong)indexes_size);
for (; i < indicesCount; i++)
{
ulong index = 0;
stream.ReadWriteAsVarInt(ref index);
if (index > Int32.MaxValue)
{
throw new FormatException("indexes overflowed 31-bits");
}
_Indices.Add((int)index);
}
}
int offset = 0;
for (var ii = 0; ii < _Indices.Count; ii++)
{
if ((ulong)(_Indices[ii]) + (ulong)(offset) > Int32.MaxValue)
{
throw new FormatException("indexes overflowed 31-bits");
}
_Indices[ii] = _Indices[ii] + offset;
offset = _Indices[ii] + 1;
}
}
else
{
for (var i = 0; i < _Indices.Count; i++)
{
int index = _Indices[i] - (i == 0 ? 0 : (_Indices[i - 1] + 1));
stream.ReadWrite(ref index);
}
}
}
public void ReadWrite(CoinStream stream)
{
if (stream.Type == SerializationType.Disk)
{
stream.ReadWrite(ref version);
}
if (
stream.Type == SerializationType.Disk ||
(stream.ProtocolCapabilities.SupportTimeAddress && stream.Type != SerializationType.Hash))
{
stream.ReadWrite(ref ntime);
}
stream.ReadWrite(ref service);
stream.ReadWrite(ref ip);
using (stream.BigEndianScope())
{
stream.ReadWrite(ref port);
}
}
public void ReadWrite(CoinStream stream)
{
using (stream.BigEndianScope())
{
stream.ReadWrite(ref nDepth);
stream.ReadWrite(ref parentFingerprint);
stream.ReadWrite(ref nChild);
stream.ReadWrite(ref vchChainCode);
if (pubkey is null)
{
var pubkeyBytes = new byte[33];
stream.ReadWrite(ref pubkeyBytes);
if (!stream.Serializing)
{
pubkey = new PubKey(pubkeyBytes);
}
}
else
{
stream.ReadWrite(ref pubkey);
}
}
}
public static ulong StaticRead(CoinStream bs)
{
if (bs.Serializing)
{
throw new InvalidOperationException("Stream should not be serializing");
}
var prefix = bs.Inner.ReadByte();
bs.Counter.AddReaden(1);
if (prefix == -1)
{
throw new EndOfStreamException("No more byte to read");
}
if (prefix < 0xFD)
{
return((byte)prefix);
}
else if (prefix == 0xFD)
{
var value = (ushort)0;
bs.ReadWrite(ref value);
return(value);
}
else if (prefix == 0xFE)
{
var value = (uint)0;
bs.ReadWrite(ref value);
return(value);
}
else
{
var value = (ulong)0;
bs.ReadWrite(ref value);
return(value);
}
}
public override void ReadWriteCore(CoinStream stream)
{
stream.ReadWriteAsVarString(ref _Data);
}
