public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out ulong val)
{
var encoder = new UInt64Encoder();
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out val);
}
public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out BigInteger val)
{
var encoder = new Int256Encoder();
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out val);
}
public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out UInt256 val)
{
NumberEncoder <UInt256> encoder = new UInt256Encoder();
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out val);
}
public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out Hash val)
{
var encoder = new BytesMEncoder();
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out var bytes);
val = new Hash(bytes is byte[] b ? b : bytes.ToArray());
}
public static void Decode <TItem>(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out TItem val)
{
var encoder = EncoderFactory.LoadEncoder(solidityType);
encoder.SetTypeInfo(solidityType);
encoder.DecodeObject(ref buff, out var objectVal);
val = (TItem)objectVal;
}
public static AbiTypeInfo GetSolidityTypeInfo(string name)
{
var arrayBracket = name.IndexOf('[');
if (arrayBracket > 0)
{
if (_cachedTypes.TryGetValue(name, out var t))
{
return(t);
}
var bracketPart = name.Substring(arrayBracket);
var typeCategory = SolidityTypeCategory.DynamicArray;
int[] arrayDimensionSizes;
// if a fixed array length has been set, ex: uint64[10]
if (bracketPart.Length > 2)
{
if (bracketPart.Contains("]["))
{
arrayDimensionSizes = ParseArrayDimensionSizes(bracketPart);
if (arrayDimensionSizes[0] > 0)
{
typeCategory = SolidityTypeCategory.FixedArray;
}
}
else
{
// parse the number within the square brackets
var sizeStr = bracketPart.Substring(1, bracketPart.Length - 2);
var arraySize = int.Parse(sizeStr, CultureInfo.InvariantCulture);
arrayDimensionSizes = new[] { arraySize };
typeCategory = SolidityTypeCategory.FixedArray;
}
}
else
{
arrayDimensionSizes = new[] { 0 };
}
var baseName = name.Substring(0, arrayBracket);
if (_finiteTypes.TryGetValue(baseName, out var baseInfo))
{
var arrayType = typeof(IEnumerable <>).MakeGenericType(baseInfo.ClrType);
var info = new AbiTypeInfo(name, arrayType, baseInfo.PrimitiveTypeByteSize, typeCategory, SolidityTypeElementaryBase.None, baseInfo, arrayDimensionSizes);
_cachedTypes[name] = info;
return(info);
}
}
else if (_finiteTypes.TryGetValue(name, out var t))
{
return(t);
}
throw new ArgumentException("Unexpected solidity ABI type: " + name, nameof(name));
}
public static AbiTypeInfo[] GetTypeInfo(this IAbiTypeEncoder[] encoders)
{
AbiTypeInfo[] info = new AbiTypeInfo[encoders.Length];
for (var i = 0; i < encoders.Length; i++)
{
info[i] = encoders[i].TypeInfo;
}
return(info);
}
static AbiTypeMap()
{
// elementary types
var dict = new Dictionary <string, AbiTypeInfo>
{
// equivalent to uint8 restricted to the values 0 and 1
["bool"] = new AbiTypeInfo("bool", typeof(bool), 1, elementaryBaseType: SolidityTypeElementaryBase.Bool),
// 20 bytes
["address"] = new AbiTypeInfo("address", typeof(Address), 20, elementaryBaseType: SolidityTypeElementaryBase.Address),
// dynamic sized unicode string assumed to be UTF - 8 encoded.
["string"] = new AbiTypeInfo("string", typeof(string), 1, SolidityTypeCategory.String),
// dynamic sized byte sequence
["bytes"] = new AbiTypeInfo("bytes", typeof(IEnumerable <byte>), 1, SolidityTypeCategory.Bytes)
};
// fixed sized bytes elementary types
for (var i = 1; i <= UInt256.SIZE; i++)
{
dict["bytes" + i] = new AbiTypeInfo(
"bytes" + i,
typeof(IEnumerable <byte>),
primitiveTypeByteSize: i,
SolidityTypeCategory.Elementary,
SolidityTypeElementaryBase.Bytes,
arrayTypeLength: i);
}
// signed and unsigned integer type of M bits, 0 < M <= 256, M % 8 == 0
AddIntRange <sbyte, byte>(1, 1);
AddIntRange <short, ushort>(2, 2);
AddIntRange <int, uint>(3, 4);
AddIntRange <long, ulong>(5, 8);
AddIntRange <BigInteger, UInt256>(9, 32);
void AddIntRange <TIntType, TUIntType>(int byteStart, int byteEnd)
{
for (var i = byteStart; i <= byteEnd; i++)
{
var bits = i * 8;
string typeSigned = "int" + bits;
string typeUnsigned = "uint" + bits;
dict.Add(typeSigned, new AbiTypeInfo(typeSigned, typeof(TIntType), i, elementaryBaseType: SolidityTypeElementaryBase.Int));
dict.Add(typeUnsigned, new AbiTypeInfo(typeUnsigned, typeof(TUIntType), i, elementaryBaseType: SolidityTypeElementaryBase.UInt));
}
}
_finiteTypes = new ReadOnlyDictionary <string, AbiTypeInfo>(dict);
}
public static DecodeDelegate <TItem> GetDecoder <TItem>(AbiTypeInfo solidityType)
{
var encoder = EncoderFactory.LoadEncoder(solidityType);
encoder.SetTypeInfo(solidityType);
void Decode(AbiTypeInfo st, ref AbiDecodeBuffer buff, out TItem val)
{
encoder.DecodeObject(ref buff, out var objectVal);
val = (TItem)objectVal;
}
return(Decode);
}
public static DecodeDelegate <TItem[]> GetMultiDimArrayDecoder <TItem>(AbiTypeInfo solidityType)
{
IAbiTypeEncoder encoder;
IAbiTypeEncoder itemEncoder;
if (solidityType.ArrayItemInfo.ElementaryBaseType == SolidityTypeElementaryBase.Bytes)
{
itemEncoder = new BytesMEncoder();
}
else
{
// TODO: define all multi-dim array encoder runtime matches
throw new NotImplementedException();
}
itemEncoder.SetTypeInfo(solidityType.ArrayItemInfo);
switch (solidityType.Category)
{
case SolidityTypeCategory.DynamicArray:
encoder = new DynamicArrayEncoderNonGeneric(itemEncoder);
break;
case SolidityTypeCategory.FixedArray:
encoder = new FixedArrayEncoderNonGeneric(itemEncoder);
break;
default:
throw new ArgumentException($"Encoder factory for array types was called with a type '{solidityType.Category}'");
}
encoder.SetTypeInfo(solidityType);
void Decode(AbiTypeInfo st, ref AbiDecodeBuffer buff, out TItem[] val)
{
encoder.DecodeObject(ref buff, out var objectVal);
var objectArray = (object[])objectVal;
val = objectArray.Select(v => (TItem)v).ToArray();
}
return(Decode);
}
public static void Decode <TItem>(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out IEnumerable <TItem> val, IAbiTypeEncoder <TItem> itemEncoder)
{
AbiTypeEncoder <IEnumerable <TItem> > encoder;
switch (solidityType.Category)
{
case SolidityTypeCategory.DynamicArray:
encoder = new DynamicArrayEncoder <TItem>(itemEncoder);
break;
case SolidityTypeCategory.FixedArray:
encoder = new FixedArrayEncoder <TItem>(itemEncoder);
break;
default:
throw new ArgumentException($"Encoder factory for array types was called with a type '{solidityType.Category}'");
}
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out val);
}
public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out IEnumerable <byte> val)
{
switch (solidityType.Category)
{
case SolidityTypeCategory.Bytes:
{
var encoder = new BytesEncoder();
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out val);
break;
}
case SolidityTypeCategory.DynamicArray:
{
var encoder = new DynamicArrayEncoder <byte>(new UInt8Encoder());
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out val);
break;
}
case SolidityTypeCategory.FixedArray:
{
var encoder = new FixedArrayEncoder <byte>(new UInt8Encoder());
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out val);
break;
}
case SolidityTypeCategory.Elementary when solidityType.ElementaryBaseType == SolidityTypeElementaryBase.Bytes:
{
var encoder = new BytesMEncoder();
encoder.SetTypeInfo(solidityType);
encoder.Decode(ref buff, out val);
break;
}
default:
throw new ArgumentException($"Encoder factor method for byte arrays called with type '{solidityType.Category}'");
}
}
public static void Decode <TItem>(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out TItem[] val, IAbiTypeEncoder <TItem> itemEncoder)
{
Decode(solidityType, ref buff, out IEnumerable <TItem> items, itemEncoder);
val = items is TItem[] arr ? arr : items.ToArray();
}
public void SetTypeInfo(AbiTypeInfo info)
{
_encoder.SetTypeInfo(info);
}
public static Exception CreateUnsupportedTypeEncodingException(AbiTypeInfo typeInfo)
{
return(new ArgumentException($"Encoder does not support solidity type category '{typeInfo.Category}', type name: {typeInfo.SolidityName}"));
}
public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out sbyte val)
{
var encoder = new Int8Encoder();
encoder.Decode(ref buff, out val);
}
public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out bool val)
{
var encoder = new BoolEncoder();
encoder.Decode(ref buff, out val);
}
public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out byte[] val)
{
Decode(solidityType, ref buff, out IEnumerable <byte> bytes);
val = bytes is byte[] arr ? arr : bytes.ToArray();
}
public static void Decode(AbiTypeInfo solidityType, ref AbiDecodeBuffer buff, out Address val)
{
var encoder = new AddressEncoder();
encoder.Decode(ref buff, out val);
}
