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