public static Profile Deserialize(byte[] serializedProfile)
{
if (serializedProfile == null)
{
return(null);
}
try
{
var profile = new Profile();
var ser = PocoSerializer.GetDeserializer(serializedProfile);
profile.Id = ser.MakeString(0);
profile.Name = ser.MakeString(1);
profile.PublicKey = ser.MakeByteArray(2);
profile.PrivateKey = ser.MakeByteArray(3);
profile.IsIdentityPublished = ser.MakeBoolean(4);
profile.PictureBytes = ser.MakeByteArray(5);
profile.ChatId = ser.MakeString(6);
profile.MasterKey = ser.MakeByteArray(7);
profile.DefaultAddressPrivateKey = ser.MakeByteArray(8);
profile.DefaultAddressPublicKey = ser.MakeByteArray(9);
profile.DefaultAddressHash = ser.MakeByteArray(10);
profile.DefaultAddress = ser.MakeString(11);
profile.DefaultAddressScriptPubKey = ser.MakeByteArray(12);
profile.DefaultAddressKeyPath = ser.MakeString(13);
return(profile);
}
catch (Exception)
{
return(null);
}
}
public static Peer Deserialize(byte[] serializedMessage)
{
if (serializedMessage == null)
{
return(null);
}
var ser = PocoSerializer.GetDeserializer(serializedMessage);
var peer = new Peer();
peer.Id = ser.MakeString(0);
peer.PeerServices = (PeerServices)ser.MakeUInt64(1);
peer.LastSeen = ser.MakeDateTime(2);
peer.LastError = ser.MakeDateTime(3);
peer.BytesSent = ser.MakeUInt64(4);
peer.BytesReceived = ser.MakeUInt64(5);
peer.Priority = ser.MakeInt32(6);
var address = peer.Id.ToAddress();
peer.IPAddress = address.ipAddress;
peer.ProtocolPort = address.port;
return(peer);
}
public static byte[] SerializeCore(Message m)
{
byte[] serialized = PocoSerializer.Begin()
// XMessage members
.Append(m.Id)
.Append(m.SenderId)
.Append(m.RecipientId)
.Append((byte)m.MessageType)
.Append(m.SenderLocalMessageId)
.Append(m.TextCipher)
.Append(m.ImageCipher)
.Append(m.DynamicPublicKey)
.Append(m.DynamicPublicKeyId)
.Append(m.PrivateKeyHint)
// Message members
.Append(m.NetworkPayloadHash)
.Append((byte)m.Side)
.Append((byte)m.PrevSide)
.Append((byte)m.SendMessageState)
.Append((byte)m.LocalMessageState)
.Append(m.EncryptedE2EEncryptionKey)
// some members are ignored!
.Append(m.ImageImportPath)
.Finish();
return(serialized);
}
public static Identity Deserialize(byte[] serializedIdentity)
{
if (serializedIdentity == null)
{
return(null);
}
try
{
var identity = new Identity();
var ser = PocoSerializer.GetDeserializer(serializedIdentity);
identity.Id = ser.MakeString(0);
identity.UnverifiedId = ser.MakeString(1);
identity.Name = ser.MakeString(2);
identity.Image = ser.MakeByteArray(3);
identity.LastSeenUtc = ser.MakeDateTime(4);
identity.FirstSeenUtc = ser.MakeDateTime(5);
identity.StaticPublicKey = ser.MakeByteArray(6);
identity.ContactState = (ContactState)ser.MakeByte(7);
identity.CryptographicInformation = ser.MakeByteArray(8);
return(identity);
}
catch (Exception)
{
return(null);
}
}
public static byte[] Serialize(this XResendRequest r)
{
byte[] serialized = PocoSerializer.Begin()
.Append(r.Id)
.Append(r.RecipientId)
.Finish();
return(serialized);
}
public static byte[] SerializeCore(this XMessageMetaData m)
{
byte[] serialized = PocoSerializer.Begin()
.Append((byte)m.MessageType)
.Append(m.SenderLocalMessageId)
.Append(m.SenderPublicKey)
.Finish();
return(serialized);
}
public static XResendRequest DeserializeResendRequest(this byte[] resendRequest)
{
var r = new XResendRequest();
var ser = PocoSerializer.GetDeserializer(resendRequest);
r.Id = ser.MakeString(0);
r.RecipientId = ser.MakeString(1);
return(r);
}
public static byte[] Serialize(MessageRelayRecord messageRelayRecord)
{
byte[] serialized = PocoSerializer.Begin()
.Append(messageRelayRecord.Id)
.Append(messageRelayRecord.LastSeenUtc)
.Append(messageRelayRecord.LastErrorUtc)
.Append(messageRelayRecord.ErrorScore)
.Finish();
return(serialized);
}
public void Serialize <T>(T instance, TextWriter writer)
{
if (!typeof(T).IsInstanceOfType((typeof(BaseDocument))))
{
PocoSerializer.Serialize(writer, instance);
}
else
{
DocumentSerializer.Serialize(writer, instance);
}
}
public static byte[] Serialize(E2EUser u)
{
byte[] serialized = PocoSerializer.Begin()
//.Append(m.UserId) // Ignore
//.Append(m.StaticPublicKey) // Ignore
.Append(u.LatestDynamicPublicKey)
.Append(u.LatestDynamicPublicKeyId)
.Append(u.AuthSecret)
.Append(u.DynamicPrivateDecryptionKeys)
.Finish();
return(serialized);
}
public static XMessageMetaData DeserializeMessageMetadata(this byte[] messageMetadata)
{
var m = new XMessageMetaData();
var ser = PocoSerializer.GetDeserializer(messageMetadata);
m.MessageType = (MessageType)ser.MakeByte(0);
m.SenderLocalMessageId = ser.MakeInt32(1);
m.SenderPublicKey = ser.MakeByteArray(2);
return(m);
}
public static byte[] SerializeCore(Peer peer)
{
byte[] serialized = PocoSerializer.Begin()
.Append(peer.Id)
.Append((ulong)peer.PeerServices)
.Append(peer.LastSeen)
.Append(peer.LastError)
.Append(peer.BytesSent)
.Append(peer.BytesReceived)
.Append(peer.Priority)
.Finish();
return(serialized);
}
public static byte[] SerializeCore(this IPhotonOutput o)
{
byte[] serialized = PocoSerializer.Begin()
.Append(o.HashTx)
.Append((ushort)o.Index)
.Append(o.BlockHeight)
.Append(o.Satoshis)
.Append((byte)o.UtxoType)
.Append(o.SpendingTx)
.Append(o.SpendingN)
.Append(o.SpendingHeight)
.Finish();
return(serialized);
}
public static byte[] SerializeCore(Identity identity)
{
byte[] serialized = PocoSerializer.Begin()
.Append(identity.Id)
.Append(identity.UnverifiedId)
.Append(identity.Name)
.Append(identity.Image)
.Append(identity.LastSeenUtc)
.Append(identity.FirstSeenUtc)
.Append(identity.StaticPublicKey)
.Append((byte)identity.ContactState)
.Append(identity.CryptographicInformation)
.Finish();
return(serialized);
}
public static PhotonOutput DeserializePhotonOutput(this byte[] photonOutput)
{
var output = new PhotonOutput();
var ser = PocoSerializer.GetDeserializer(photonOutput);
output.HashTx = ser.MakeByteArray(0);
output.Index = ser.MakeUInt16(1);
output.BlockHeight = ser.MakeInt32(2);
output.Satoshis = ser.MakeInt64(3);
output.UtxoType = (UtxoType)ser.MakeByte(4);
output.SpendingTx = ser.MakeByteArray(5);
output.SpendingN = ser.MakeUInt16(6);
output.SpendingHeight = ser.MakeInt32(7);
return(output);
}
public static byte[] SerializeCore(Profile profile)
{
byte[] serialized = PocoSerializer.Begin()
.Append(profile.Id)
.Append(profile.Name)
.Append(profile.PublicKey)
.Append(profile.PrivateKey)
.Append(profile.IsIdentityPublished)
.Append(profile.PictureBytes)
.Append(profile.ChatId)
.Append(profile.MasterKey)
.Append(profile.DefaultAddressPrivateKey)
.Append(profile.DefaultAddressPublicKey)
.Append(profile.DefaultAddressHash)
.Append(profile.DefaultAddress)
.Append(profile.DefaultAddressScriptPubKey)
.Append(profile.DefaultAddressKeyPath)
.Finish();
return(serialized);
}
public static Message Deserialize(byte[] serializedMessage)
{
if (serializedMessage == null)
{
return(null);
}
var m = new Message();
try
{
var ser = PocoSerializer.GetDeserializer(serializedMessage);
// XMessage members
m.Id = ser.MakeString(0);
m.SenderId = ser.MakeString(1);
m.RecipientId = ser.MakeString(2);
m.MessageType = (MessageType)ser.MakeByte(3);
m.SenderLocalMessageId = ser.MakeString(4);
m.TextCipher = ser.MakeByteArray(5);
m.ImageCipher = ser.MakeByteArray(6);
m.DynamicPublicKey = ser.MakeByteArray(7);
m.DynamicPublicKeyId = ser.MakeInt64(8);
m.PrivateKeyHint = ser.MakeInt64(9);
// Message members
m.NetworkPayloadHash = ser.MakeString(10);
m.Side = (MessageSide)ser.MakeByte(11);
m.PrevSide = (MessageSide)ser.MakeByte(12);
m.SendMessageState = (SendMessageState)ser.MakeByte(13);
m.LocalMessageState = (LocalMessageState)ser.MakeByte(14);
m.EncryptedE2EEncryptionKey = ser.MakeByteArray(15);
m.ImageImportPath = ser.MakeString(16);
return(m);
}
catch (Exception e)
{
return(m);
}
}
public static MessageRelayRecord Deserialize(byte[] serializedMessageNodeRecord)
{
if (serializedMessageNodeRecord == null)
{
return(null);
}
var ser = PocoSerializer.GetDeserializer(serializedMessageNodeRecord);
var messageNodeRecord = new MessageRelayRecord
{
Id = ser.MakeString(0),
LastSeenUtc = ser.MakeDateTime(1),
LastErrorUtc = ser.MakeDateTime(2),
ErrorScore = ser.MakeInt32(3)
};
var(ipAddress, port) = messageNodeRecord.Id.ToAddress();
messageNodeRecord.IpAddress = ipAddress;
messageNodeRecord.MessagingPort = port;
return(messageNodeRecord);
}
public static E2EUser Deserialize(byte[] serializedE2EUser)
{
if (serializedE2EUser == null)
{
return(null);
}
try
{
var u = new E2EUser();
var ser = PocoSerializer.GetDeserializer(serializedE2EUser);
// not setting UserId, StaticPublicKey here!
u.LatestDynamicPublicKey = ser.MakeByteArray(0);
u.LatestDynamicPublicKeyId = ser.MakeInt64(1);
u.AuthSecret = ser.MakeByteArray(2);
u.DynamicPrivateDecryptionKeys = ser.MakeDictLongByteArray(3);
return(u);
}
catch (Exception)
{
return(null);
}
}
