static bool IsFramed(MichelinePrim prim)
{
switch (prim.Prim)
{
case PrimType.Pair:
case PrimType.Left:
case PrimType.Right:
case PrimType.Some:
case PrimType.Elt:
case PrimType.pair:
case PrimType.or:
case PrimType.option:
case PrimType.map:
case PrimType.big_map:
case PrimType.list:
case PrimType.set:
case PrimType.contract:
case PrimType.lambda:
case PrimType.sapling_state:
case PrimType.sapling_transaction:
case PrimType.ticket:
return(true);
default:
return(prim.Annots?.Any(x => x.Type != AnnotationType.Variable) ?? false);
}
}
IMicheline Uncomb(IMicheline value)
{
if (value is MichelineArray array)
{
value = new MichelinePrim
{
Prim = PrimType.Pair,
Args = array
};
}
if (value is MichelinePrim p && p.Prim == PrimType.Pair && p.Args?.Count > 2)
{
value = new MichelinePrim
{
Prim = p.Prim,
Annots = p.Annots,
Args = new List <IMicheline>(2)
{
p.Args[0],
new MichelinePrim
{
Prim = PrimType.Pair,
Args = p.Args.Skip(1).ToList()
}
}
};
}
return(value);
}
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;
}
}
}
public SetSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 1 || !(micheline.Args[0] is MichelinePrim item))
{
throw new FormatException($"Invalid {Prim} schema format");
}
Item = Create(item);
}
protected Schema(MichelinePrim micheline)
{
if (micheline.Annots?.Count > 0)
{
Field = micheline.Annots.FirstOrDefault(x => x.Type == AnnotationType.Field && x.Value.Length > 0)?.Value;
Type = micheline.Annots.FirstOrDefault(x => x.Type == AnnotationType.Type && x.Value.Length > 0)?.Value;
Annot = (Field ?? Type)?.ToAlphaNumeric();
}
}
public OptionSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 1 || !(micheline.Args[0] is MichelinePrim some))
{
throw new FormatException($"Invalid {Prim} schema format");
}
Some = Create(some);
}
public SaplingStateSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 1 || !(micheline.Args[0] is MichelineInt micheInt))
{
throw new FormatException($"Invalid {Prim} schema format");
}
MemoSize = micheInt.Value;
}
public ContractSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 1 || !(micheline.Args[0] is MichelinePrim type))
{
throw new FormatException($"Invalid {Prim} schema format");
}
Parameters = Create(type);
}
public SaplingTransactionDeprecatedSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 1 || micheline.Args[0] is not MichelineInt micheInt)
{
throw new FormatException($"Invalid {Prim} schema format");
}
MemoSize = micheInt.Value;
}
public ParameterSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 1 ||
!(micheline.Args[0] is MichelinePrim parameter))
{
throw new FormatException($"Invalid {Prim} schema format");
}
Schema = Create(parameter);
}
public LambdaSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 2 ||
!(micheline.Args[0] is MichelinePrim input) ||
!(micheline.Args[1] is MichelinePrim output))
{
throw new FormatException($"Invalid {Prim} schema format");
}
In = Create(input);
Out = Create(output);
}
public BigMapSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 2 ||
!(micheline.Args[0] is MichelinePrim key) ||
!(micheline.Args[1] is MichelinePrim value))
{
throw new FormatException($"Invalid {Prim} schema format");
}
Key = Create(key);
Value = Create(value);
}
public TicketSchema(MichelinePrim micheline) : base(micheline)
{
if (micheline.Args?.Count != 1 || !(micheline.Args[0] is MichelinePrim type))
{
throw new FormatException($"Invalid {Prim} schema format");
}
if (type.Annots == null)
{
type.Annots = new List <IAnnotation>(1);
}
if (type.Annots.Count == 0)
{
type.Annots.Add(new FieldAnnotation("data"));
}
var data = new MichelinePrim
{
Prim = PrimType.pair,
Args = new List <IMicheline>(2)
{
new MichelinePrim
{
Prim = PrimType.address,
Annots = new List <IAnnotation>(1)
{
new FieldAnnotation("address")
}
},
new MichelinePrim
{
Prim = PrimType.pair,
Args = new List <IMicheline>(2)
{
type,
new MichelinePrim
{
Prim = PrimType.nat,
Annots = new List <IAnnotation>(1)
{
new FieldAnnotation("amount")
}
}
}
}
}
};
Data = Create(data);
}
public OrSchema(MichelinePrim micheline, bool nested = false) : base(micheline)
{
if (micheline.Args?.Count != 2 ||
!(micheline.Args[0] is MichelinePrim left) ||
!(micheline.Args[1] is MichelinePrim right))
{
throw new FormatException($"Invalid {Prim} schema format");
}
Left = left.Prim == PrimType.or
? new OrSchema(left, true)
: Create(left);
Right = right.Prim == PrimType.or
? new OrSchema(right, true)
: Create(right);
if (!nested)
{
var fields = new Dictionary <string, int>();
var children = Children();
foreach (var child in children.Where(x => x.Name != null))
{
var name = child.Name;
if (fields.ContainsKey(name))
{
child.Index = ++fields[name];
}
else
{
fields.Add(name, 0);
}
}
foreach (var kv in fields.Where(x => x.Value > 0))
{
children.First(x => x.Name == kv.Key).Index = 0;
}
}
}
public MutezSchema(MichelinePrim micheline) : base(micheline)
{
}
public Bls12381G2Schema(MichelinePrim micheline) : base(micheline)
{
}
private MichelinePrim ReadMichelinePrimitive(int argsLength, bool annotations = false)
{
var primTag = (PrimType)ReadByte();
var prim = new MichelinePrim
{
Prim = primTag
};
if (0 < argsLength && argsLength < 3)
{
prim.Args = new MichelineArray(argsLength);
for (var i = 0; i < argsLength; i++)
{
prim.Args.Add(ReadMicheline());
}
}
else if (argsLength == 3)
{
prim.Args = ReadMichelineArray();
}
else if (argsLength != 0)
{
throw new ArgumentException($"Unexpected args length {argsLength}", nameof(argsLength));
}
if (annotations)
{
var annots = ReadString();
if (annots.Length > 0)
{
prim.Annots = annots
.Split(' ')
.Select(a =>
{
var annotVal = a.Substring(1);
IAnnotation annotation;
switch (a[0])
{
case FieldAnnotation.Prefix:
annotation = new FieldAnnotation(annotVal);
break;
case TypeAnnotation.Prefix:
annotation = new TypeAnnotation(annotVal);
break;
case VariableAnnotation.Prefix:
annotation = new VariableAnnotation(annotVal);
break;
default:
throw new InvalidOperationException($"Unknown annotation type: {a[0]}");
}
return(annotation);
})
.ToList();
}
}
return(prim);
}
public IntSchema(MichelinePrim micheline) : base(micheline)
{
}
static bool IsInline(MichelinePrim prim)
{
return(prim.Prim == PrimType.PUSH);
}
public ChainIdSchema(MichelinePrim micheline) : base(micheline)
{
}
public NeverSchema(MichelinePrim micheline) : base(micheline)
{
}
public TimestampSchema(MichelinePrim micheline) : base(micheline)
{
}
public KeyHashSchema(MichelinePrim micheline) : base(micheline)
{
}
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");
}
}
}
public OperationSchema(MichelinePrim micheline) : base(micheline)
{
}
public TxRollupL2AddressSchema(MichelinePrim micheline) : base(micheline)
{
}
public static Schema Create(MichelinePrim micheline)
{
switch (micheline.Prim)
{
case PrimType.address: return(new AddressSchema(micheline));
case PrimType.bls12_381_fr: return(new Bls12381FrSchema(micheline));
case PrimType.bls12_381_g1: return(new Bls12381G1Schema(micheline));
case PrimType.bls12_381_g2: return(new Bls12381G2Schema(micheline));
case PrimType.big_map: return(new BigMapSchema(micheline));
case PrimType.@bool: return(new BoolSchema(micheline));
case PrimType.bytes: return(new BytesSchema(micheline));
case PrimType.chest: return(new ChestSchema(micheline));
case PrimType.chest_key: return(new ChestKeySchema(micheline));
case PrimType.chain_id: return(new ChainIdSchema(micheline));
case PrimType.constant: return(new ConstantSchema(micheline));
case PrimType.contract: return(new ContractSchema(micheline));
case PrimType.@int: return(new IntSchema(micheline));
case PrimType.key: return(new KeySchema(micheline));
case PrimType.key_hash: return(new KeyHashSchema(micheline));
case PrimType.lambda: return(new LambdaSchema(micheline));
case PrimType.list: return(new ListSchema(micheline));
case PrimType.map: return(new MapSchema(micheline));
case PrimType.mutez: return(new MutezSchema(micheline));
case PrimType.nat: return(new NatSchema(micheline));
case PrimType.never: return(new NeverSchema(micheline));
case PrimType.option: return(new OptionSchema(micheline));
case PrimType.or: return(new OrSchema(micheline));
case PrimType.pair: return(new PairSchema(micheline));
case PrimType.sapling_state: return(new SaplingStateSchema(micheline));
case PrimType.sapling_transaction: return(new SaplingTransactionSchema(micheline));
case PrimType.set: return(new SetSchema(micheline));
case PrimType.signature: return(new SignatureSchema(micheline));
case PrimType.@string: return(new StringSchema(micheline));
case PrimType.ticket: return(new TicketSchema(micheline));
case PrimType.timestamp: return(new TimestampSchema(micheline));
case PrimType.unit: return(new UnitSchema(micheline));
case PrimType.operation: return(new OperationSchema(micheline));
case PrimType.view: return(new ViewSchema(micheline));
default:
throw new NotImplementedException($"Schema for prim {micheline.Prim} is not implemented");
}
}
public AddressSchema(MichelinePrim micheline) : base(micheline)
{
}
public BoolSchema(MichelinePrim micheline) : base(micheline)
{
}
public ConstantSchema(MichelinePrim micheline) : base(micheline)
{
}
