public static Message Create(MessageCommand command, ISerializable payload = null)
{
Message message = new Message
{
Flags = MessageFlags.None,
Command = command,
Payload = payload,
_payload_compressed = payload?.ToArray() ?? Array.Empty <byte>()
};
bool tryCompression =
command == MessageCommand.Block ||
command == MessageCommand.Consensus ||
command == MessageCommand.Extensible ||
command == MessageCommand.Transaction ||
command == MessageCommand.Headers ||
command == MessageCommand.Addr ||
command == MessageCommand.MerkleBlock ||
command == MessageCommand.FilterLoad ||
command == MessageCommand.FilterAdd;
// Try compression
if (tryCompression && message._payload_compressed.Length > CompressionMinSize)
{
var compressed = message._payload_compressed.CompressLz4();
if (compressed.Length < message._payload_compressed.Length - CompressionThreshold)
{
message._payload_compressed = compressed;
message.Flags |= MessageFlags.Compressed;
}
}
return(message);
}
protected internal StackItem Convert(object value)
{
return(value switch
{
null => StackItem.Null,
bool b => b,
sbyte i => i,
byte i => (BigInteger)i,
short i => i,
ushort i => (BigInteger)i,
int i => i,
uint i => i,
long i => i,
ulong i => i,
Enum e => Convert(System.Convert.ChangeType(e, e.GetTypeCode())),
byte[] data => data,
string s => s,
BigInteger i => i,
IInteroperable interoperable => interoperable.ToStackItem(ReferenceCounter),
ISerializable i => i.ToArray(),
StackItem item => item,
(object a, object b) => new Struct(ReferenceCounter)
{
Convert(a), Convert(b)
},
Array array => new VMArray(ReferenceCounter, array.OfType <object>().Select(p => Convert(p))),
_ => StackItem.FromInterface(value)
});
public static StorageKey CreateStorageKey(this NativeContract contract, byte prefix, ISerializable key)
{
return(new StorageKey
{
Id = contract.Id,
Key = key.ToArray().Prepend(prefix).ToArray()
});
}
public static Message Create(MessageCommand command, ISerializable payload = null)
{
Message message = new Message
{
Flags = MessageFlags.None,
Command = command,
Payload = payload,
_payload_compressed = payload?.ToArray() ?? new byte[0]
};
// Try compression
if (message._payload_compressed.Length > CompressionMinSize)
{
var compressed = message._payload_compressed.CompressLz4();
if (compressed.Length < message._payload_compressed.Length - CompressionThreshold)
{
message._payload_compressed = compressed;
message.Flags |= MessageFlags.Compressed;
}
}
return(message);
}
public static ScriptBuilder EmitPush(this ScriptBuilder sb, ISerializable data)
{
return(sb.EmitPush(data.ToArray()));
}
public static Message Create(string command, ISerializable payload = null)
{
return(Create(command, payload == null ? new byte[0] : payload.ToArray()));
}
public static void Put(this WriteBatch batch, byte prefix, ISerializable key, ISerializable value)
{
batch.Put(SliceBuilder.Begin(prefix).Add(key), value.ToArray());
}
private static byte[] CreateKey(byte prefix, ISerializable key)
{
return(CreateKey(prefix, key.ToArray()));
}
public SliceBuilder Add(ISerializable value)
{
data.AddRange(value.ToArray());
return(this);
}
internal protected StorageKey CreateStorageKey(byte prefix, ISerializable key)
{
return(CreateStorageKey(prefix, key.ToArray()));
}
private void Put(byte prefix, ISerializable key, ISerializable value)
{
_writeBatch.Put(Key(prefix, key), value.ToArray());
}
public SliceBuilder Add(ISerializable value)
{
TR.Enter();
data.AddRange(value.ToArray());
return(TR.Exit(this));
}
public static ScriptBuilder EmitPush(this ScriptBuilder sb, ISerializable data)
{
TR.Enter();
return(TR.Exit(sb.EmitPush(data.ToArray())));
}
public static Message Create(string command, ISerializable payload = null)
{
return Create(command, payload == null ? new byte[0] : payload.ToArray());
}
