static void ReadAnnotsToJson(BinaryReader reader, Utf8JsonWriter writer, int count)
{
writer.WriteStartArray("annots");
while (count-- > 0)
{
var tag = reader.ReadByte();
var cnt = tag & 0x3F;
if (cnt == 0x3F)
{
cnt = reader.Read7BitInt();
}
var str = Utf8.Convert(reader.ReadBytes(cnt));
switch (tag & 0b_1100_0000)
{
case (int)AnnotationType.Field:
writer.WriteStringValue($"{FieldAnnotation.Prefix}{str}");
break;
case (int)AnnotationType.Type:
writer.WriteStringValue($"{TypeAnnotation.Prefix}{str}");
break;
case (int)AnnotationType.Variable:
writer.WriteStringValue($"{VariableAnnotation.Prefix}{str}");
break;
default:
writer.WriteStringValue(str);
break;
}
}
writer.WriteEndArray();
}
static void ReadAnnots(BinaryReader reader, MichelinePrim prim)
{
while (prim.Annots.Count != prim.Annots.Capacity)
{
var tag = reader.ReadByte();
var cnt = tag & 0x3F;
if (cnt == 0x3F)
{
cnt = reader.Read7BitInt();
}
var str = Utf8.Convert(reader.ReadBytes(cnt));
switch (tag & 0b_1100_0000)
{
case (int)AnnotationType.Field:
prim.Annots.Add(new FieldAnnotation(str));
break;
case (int)AnnotationType.Type:
prim.Annots.Add(new TypeAnnotation(str));
break;
case (int)AnnotationType.Variable:
prim.Annots.Add(new VariableAnnotation(str));
break;
default:
prim.Annots.Add(new UnsafeAnnotation(str));
break;
}
}
}
static IAnnotation ReadAnnotation(BinaryReader reader)
{
var tag = reader.ReadByte();
var cnt = tag & 0x3F;
if (cnt == 0x3F)
{
cnt = reader.Read7BitInt();
}
var str = Utf8.Convert(reader.ReadBytes(cnt));
switch (tag & 0b_1100_0000)
{
case (int)AnnotationType.Field:
return(new FieldAnnotation(str));
case (int)AnnotationType.Type:
return(new TypeAnnotation(str));
case (int)AnnotationType.Variable:
return(new VariableAnnotation(str));
default:
return(new UnsafeAnnotation(str));
}
}
public string Humanize(IMicheline value, JsonWriterOptions options = default)
{
using (var mem = new MemoryStream())
using (var writer = new Utf8JsonWriter(mem, options))
{
WriteValue(writer, value);
writer.Flush();
return(Utf8.Convert(mem.ToArray()));
}
}
public string GetJsonSchema(JsonWriterOptions options = default)
{
using (var mem = new MemoryStream())
using (var writer = new Utf8JsonWriter(mem, options))
{
writer.WriteStartObject();
writer.WriteString("$schema", "http://json-schema.org/draft/2019-09/schema#");
WriteJsonSchema(writer);
writer.WriteEndObject();
writer.Flush();
return(Utf8.Convert(mem.ToArray()));
}
}
public string Humanize(JsonWriterOptions options = default)
{
using (var mem = new MemoryStream())
using (var writer = new Utf8JsonWriter(mem, options))
{
writer.WriteStartObject();
writer.WritePropertyName($"schema:{Signature}");
WriteValue(writer);
writer.WriteEndObject();
writer.Flush();
return(Utf8.Convert(mem.ToArray()));
}
}
public string ReadString(int len = 4)
{
var stringLength = ReadInt32(len);
return(Utf8.Convert(ReadBytes(stringLength)));
}
public string Flatten(IMicheline value)
{
if (value is MichelineString micheString)
{
return(micheString.Value);
}
else if (value is MichelineBytes micheBytes)
{
if (micheBytes.Value.Length < 22)
{
return(Hex.Convert(micheBytes.Value));
}
byte[] prefix;
if (micheBytes.Value[0] == 0)
{
if (micheBytes.Value[1] == 0)
{
prefix = Prefix.tz1;
}
else if (micheBytes.Value[1] == 1)
{
prefix = Prefix.tz2;
}
else if (micheBytes.Value[1] == 2)
{
prefix = Prefix.tz3;
}
else
{
return(Hex.Convert(micheBytes.Value));
}
}
else if (micheBytes.Value[0] == 1)
{
if (micheBytes.Value[21] == 0)
{
prefix = Prefix.KT1;
}
else
{
return(Hex.Convert(micheBytes.Value));
}
}
else
{
return(Hex.Convert(micheBytes.Value));
}
var bytes = micheBytes.Value[0] == 0
? micheBytes.Value.GetBytes(2, 20)
: micheBytes.Value.GetBytes(1, 20);
var address = Base58.Convert(bytes, prefix);
var entrypoint = micheBytes.Value.Length > 22
? Utf8.Convert(micheBytes.Value.GetBytes(22, micheBytes.Value.Length - 22))
: string.Empty;
return(entrypoint.Length == 0 ? address : $"{address}%{entrypoint}");
}
else
{
throw FormatException(value);
}
}
static IMicheline ReadFlat(BinaryReader reader)
{
Stack <IMicheline> stack = new();
IMicheline node, top;
MichelinePrim prim;
MichelineArray arr;
int tag, cnt, args, annots;
start:
tag = reader.ReadByte();
if (tag >= 0x80)
{
prim = new() { Prim = (PrimType)reader.ReadByte() };
annots = tag & 0x0F;
if (annots > 0)
{
if (annots == 0x0F)
{
annots = reader.Read7BitInt();
}
prim.Annots = new(annots);
}
args = (tag & 0x70) >> 4;
if (args > 0)
{
if (args == 0x07)
{
args = reader.Read7BitInt();
}
prim.Args = new(args);
stack.Push(prim);
goto start;
}
if (prim.Annots != null)
{
ReadAnnots(reader, prim);
}
node = prim;
}
else
{
cnt = tag & 0x1F;
if (cnt == 0x1F)
{
cnt = reader.Read7BitInt();
}
switch ((MichelineType)(tag & 0xE0))
{
case MichelineType.Array:
node = new MichelineArray(cnt);
if (cnt > 0)
{
stack.Push(node);
goto start;
}
break;
case MichelineType.Bytes:
node = new MichelineBytes(reader.ReadBytes(cnt));
break;
case MichelineType.Int:
node = new MichelineInt(new BigInteger(reader.ReadBytes(cnt)));
break;
case MichelineType.String:
node = new MichelineString(Utf8.Convert(reader.ReadBytes(cnt)));
break;
default:
throw new FormatException("Invalid micheline tag");
}
}
finish:
if (stack.Count == 0)
{
return(node);
}
top = stack.Peek();
if (top is MichelinePrim p)
{
p.Args.Add(node);
if (p.Args.Count < p.Args.Capacity)
{
goto start;
}
if (p.Annots != null)
{
ReadAnnots(reader, p);
}
}
else
{
arr = (MichelineArray)top;
arr.Add(node);
if (arr.Count < arr.Capacity)
{
goto start;
}
}
node = stack.Pop();
goto finish;
}
public static IMicheline Read(BinaryReader reader, int depth = 0)
{
var tag = reader.ReadByte();
if (tag >= 0x80)
{
var prim = new MichelinePrim {
Prim = (PrimType)reader.ReadByte()
};
var args = (tag & 0x70) >> 4;
if (args > 0)
{
if (args == 0x07)
{
args = reader.Read7BitInt();
}
prim.Args = new List <IMicheline>(args);
if (depth < Micheline.MaxRecursionDepth)
{
while (args-- > 0)
{
prim.Args.Add(Read(reader, depth + 1));
}
}
else
{
while (args-- > 0)
{
prim.Args.Add(ReadFlat(reader));
}
}
}
var annots = tag & 0x0F;
if (annots > 0)
{
if (annots == 0x0F)
{
annots = reader.Read7BitInt();
}
prim.Annots = new List <IAnnotation>(annots);
while (annots-- > 0)
{
prim.Annots.Add(ReadAnnotation(reader));
}
}
return(prim);
}
else
{
var cnt = tag & 0x1F;
if (cnt == 0x1F)
{
cnt = reader.Read7BitInt();
}
switch ((MichelineType)(tag & 0xE0))
{
case MichelineType.Array:
var arr = new MichelineArray(cnt);
if (depth < Micheline.MaxRecursionDepth)
{
while (cnt-- > 0)
{
arr.Add(Read(reader, depth + 1));
}
}
else
{
while (cnt-- > 0)
{
arr.Add(ReadFlat(reader));
}
}
return(arr);
case MichelineType.Bytes:
return(new MichelineBytes(reader.ReadBytes(cnt)));
case MichelineType.Int:
return(new MichelineInt(new BigInteger(reader.ReadBytes(cnt))));
case MichelineType.String:
return(new MichelineString(Utf8.Convert(reader.ReadBytes(cnt))));
default:
throw new FormatException("Invalid micheline tag");
}
}
}
