Пример #1
0
        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());
        }
Пример #2
0
        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);
        }
Пример #3
0
        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}'");
            }
        }