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); }