public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[2];
PDTs[0] = (ProtocolPackager.Pack(senderTime, 0));
PDTs[1] = (ProtocolPackager.Pack(responderTime, 1));
return ProtocolPackager.PackRaw(PDTs);
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[transactions.Count];
int i = 0;
foreach (Hash transaction in transactions)
{
PDTs[i] = ProtocolPackager.Pack(transaction, 0);
i++;
}
return ProtocolPackager.PackRaw(PDTs);
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[knownPeers.Count];
int i = 0;
foreach (KeyValuePair<Hash, PeerData> peer in knownPeers)
{
PDTs[i] = ProtocolPackager.Pack(peer.Value.Serialize(), 0);
i++;
}
return ProtocolPackager.PackRaw(PDTs);
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[2];
int cnt = 0;
PDTs[cnt++] = (ProtocolPackager.PackVarint(Index, 0));
PDTs[cnt++] = (ProtocolPackager.Pack(Vector, 1));
if (cnt != PDTs.Length) throw new Exception("Invalid pack entries");
return ProtocolPackager.PackRaw(PDTs);
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[2];
int cnt = 0;
PDTs[cnt++] = (ProtocolPackager.Pack(StartSequenceNumber, 0));
PDTs[cnt++] = (ProtocolPackager.Pack(Length, 1));
if (cnt != PDTs.Length) throw new Exception("Invalid pack entries");
return ProtocolPackager.PackRaw(PDTs);
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[TransactionContents.Count];
int cnt = 0;
foreach (TransactionContentSet ts in TransactionContents)
{
PDTs[cnt++] = (ProtocolPackager.Pack(ts.Serialize(), 0));
}
if (cnt != PDTs.Length) throw new Exception("Invalid pack entries");
return ProtocolPackager.PackRaw(PDTs);
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[5];
int cnt = 0;
PDTs[cnt++] = (ProtocolPackager.Pack(SequenceNumber, 0));
PDTs[cnt++] = (ProtocolPackager.Pack(LedgerHash, 1));
PDTs[cnt++] = (ProtocolPackager.Pack(Transactions, 2));
PDTs[cnt++] = (ProtocolPackager.Pack(TotalTransactions, 3));
PDTs[cnt++] = (ProtocolPackager.Pack(CloseTime, 4));
if (cnt != PDTs.Length) throw new Exception("Invalid pack entries");
return ProtocolPackager.PackRaw(PDTs);
}
public static bool UnpackInt64(ProtocolDataType packedData, byte nameType, ref long Data)
{
if (packedData.Data.Length == 8 && (nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_INT64))
{
Data = Conversions.VectorToInt64(packedData.Data);
return true;
}
else return false;
}
/// <summary>
/// Unpacks a packed set of data packets.
/// TODO: Modify the format to support decoding with pre-allocation for faster decoding and less allocations.
/// </summary>
/// <param name="packedData"></param>
/// <returns></returns>
public static List<ProtocolDataType> UnPackRaw(byte[] packedData)
{
List<ProtocolDataType> packets = new List<ProtocolDataType>();
int index = 0;
while (true)
{
if (packedData.Length - index >= 3)
{
byte NameType = packedData[index + 0];
byte DataType = packedData[index + 1];
int readDelta;
long Length = Varint2.Decode(packedData, index + 2, out readDelta);
index += readDelta;
if (packedData.Length - index - Length >= 2)
{
byte[] Data = new byte[Length];
for (int i = 0; i < Length; i++)
{
Data[i] = packedData[index + 2 + i];
}
ProtocolDataType packet = new ProtocolDataType();
packet.NameType = NameType;
packet.DataType = (PDataType)DataType;
packet.Data = Data;
packets.Add(packet);
}
else
{
break;
}
index += (int)(Length + 2);
}
else
{
break;
}
}
return packets;
}
public static bool UnpackFloat(ProtocolDataType packedData, byte nameType, ref float Data)
{
if (packedData.Data.Length == 4 && (nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_FLOAT)) // Floats have 4 bytes
{
Data = Conversions.VectorToFloat(packedData.Data);
return true;
}
else return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////
public static bool UnpackHash(ProtocolDataType packedData, byte nameType, out Hash Data)
{
if ((nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_BYTE_VECTOR))
{
Data = new Hash(packedData.Data);
return true;
}
else
{
Data = new Hash();
return false;
}
}
public static bool UnpackByteVector_s(ProtocolDataType packedData, byte nameType, int ExpectedSize, ref byte[] Data)
{
if (packedData.Data.Length == ExpectedSize && (nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_BYTE_VECTOR))
{
Data = packedData.Data;
return true;
}
else return false;
}
public static bool UnpackDouble(ProtocolDataType packedData, byte nameType, ref double Data)
{
if (packedData.Data.Length == 8 && (nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_DOUBLE)) // Doubles have 8 bytes
{
Data = Conversions.VectorToDouble(packedData.Data);
return true;
}
else return false;
}
public static bool UnpackByte(ProtocolDataType packedData, byte nameType, ref byte Data)
{
if ((packedData.Data.Length == 1) && (nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_BYTE))
{
Data = packedData.Data[0];
return true;
}
else return false;
}
public static bool UnpackByteVector(ProtocolDataType packedData, byte nameType, ref byte[] Data)
{
if ((nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_BYTE_VECTOR))
{
Data = packedData.Data;
return true;
}
else return false;
}
//static byte[] IntToBytes(int paramInt)
//{
// byte[] arrayOfByte = new byte[3];
// arrayOfByte[0] = (byte)(paramInt);
// arrayOfByte[1] = (byte)(paramInt >> 8);
// arrayOfByte[2] = (byte)(paramInt >> 16);
// return arrayOfByte;
//}
//static int BytesToInt(List<byte> paramInt)
//{
// int val = (int)paramInt[0];
// val |= ((int)paramInt[1]) << 8;
// val |= ((int)paramInt[2]) << 16;
// return val;
//}
static ProtocolDataType GenericPack(PDataType DataType, byte nameType)
{
ProtocolDataType PDType = new ProtocolDataType();
PDType.DataType = DataType;
PDType.NameType = nameType;
return PDType;
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[3];
PDTs[0] = (ProtocolPackager.Pack(PublicKey, 0));
PDTs[1] = (ProtocolPackager.Pack(Name, 1));
PDTs[2] = (ProtocolPackager.Pack(AddressData.AddressString, 2));
return ProtocolPackager.PackRaw(PDTs);
}
public static bool UnpackString(ProtocolDataType packedData, byte nameType, ref string Data)
{
if (packedData.Data.Length >= 0 && (nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_STRING))
{
Data = Encoding.GetEncoding(28591).GetString(packedData.Data);
return true;
}
else return false;
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[1];
PDTs[0] = ProtocolPackager.PackVarint(LedgerCloseSequence, 0);
return ProtocolPackager.PackRaw(PDTs);
}
///////////////////////////////////////////////////////////
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[4 + Sources.Count + Destinations.Count + Signatures.Count];
int cnt = 0;
PDTs[cnt++] = (ProtocolPackager.Pack(versionData, 0));
PDTs[cnt++] = (ProtocolPackager.Pack(executionData, 1));
PDTs[cnt++] = (ProtocolPackager.Pack(timeStamp, 2));
foreach (TransactionEntity ts in Sources)
{
PDTs[cnt++] = (ProtocolPackager.Pack(ts.Serialize(), 3));
}
foreach (TransactionEntity td in Destinations)
{
PDTs[cnt++] = (ProtocolPackager.Pack(td.Serialize(), 4));
}
PDTs[cnt++] = (ProtocolPackager.Pack(transactionFee, 5));
foreach (Hash te in Signatures)
{
PDTs[cnt++] = (ProtocolPackager.Pack(te, 6));
}
if (cnt != PDTs.Length) throw new Exception("Invalid pack entries");
return ProtocolPackager.PackRaw(PDTs);
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[6];
PDTs[0] = (ProtocolPackager.Pack(Name, 0));
PDTs[1] = (ProtocolPackager.Pack(PubKey, 1));
PDTs[2] = (ProtocolPackager.Pack(IP, 2));
PDTs[3] = (ProtocolPackager.PackVarint(ListenPort, 3));
PDTs[4] = (ProtocolPackager.PackVarint(TimeStamp, 4));
PDTs[5] = (ProtocolPackager.Pack(Signature, 5));
return ProtocolPackager.PackRaw(PDTs);
}
public byte[] Serialize()
{
ProtocolDataType[] PDTs = new ProtocolDataType[4];
PDTs[0] = (ProtocolPackager.Pack(publicKey, 0));
PDTs[1] = (ProtocolPackager.Pack(_value, 1));
PDTs[2] = (ProtocolPackager.Pack(name, 2));
PDTs[3] = (ProtocolPackager.Pack(address, 3));
return ProtocolPackager.PackRaw(PDTs);
}
public static bool UnpackVarint(ProtocolDataType packedData, byte nameType, ref int Data)
{
if (packedData.Data.Length > 0 && packedData.Data.Length <= 9 && (nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_VARINT)) // PD_VARINT has 1-9 bytes
{
try
{
Data = (int) Varint2.Decode(packedData.Data);
}
catch { return false; }
return true;
}
else return false;
}
public static byte[] PackRaw(ProtocolDataType[] packets)
{
List<byte> pack = new List<byte>();
foreach (ProtocolDataType packet in packets)
{
byte[] F = PackSingle(packet);
pack.AddRange(F);
}
return pack.ToArray();
}
// Make Variable Size Encoding Decoding
static byte[] PackSingle(ProtocolDataType data)
{
List<byte> pack = new List<byte>();
pack.Add(data.NameType);
pack.Add((byte)data.DataType);
byte[] vLen = Varint2.Encode(data.Data.Length);
pack.AddRange(vLen);
pack.AddRange(data.Data);
return pack.ToArray();
}
public static bool UnpackBool(ProtocolDataType packedData, byte nameType, ref bool Data)
{
if (packedData.Data.Length == 1 && (nameType == packedData.NameType) && (packedData.DataType == PDataType.PD_BOOL))
{
Data = (packedData.Data[0] == 0) ? false : true;
return true;
}
else return false;
}
