Пример #1
0
        public void Serialize(Serializer so, string val, bool noMarker = false)
        {
            var bytes = Core.Config.GetB58IdentiferCodecs().DecodeAddress(val);

            SerializedTypeHelper.SerializeVarint(so, (uint)bytes.Length);
            so.Append(bytes);
        }
Пример #2
0
        public void Serialize(Serializer so, object val, bool noMarker = false)
        {
            var properties = val.GetType().GetProperties()
                             .Where(p => p.Name != p.Name.ToLower())
                             .ToArray();

            var invalid = properties.FirstOrDefault(p => !SerializedTypeHelper.InverseFieldsMap.ContainsKey(p.Name));

            if (invalid != null)
            {
                throw new InvalidOperationException("JSON contains unknown field: '" + invalid.Name + "'");
            }

            properties = SerializedTypeHelper.SortProperties(properties);

            foreach (var property in properties)
            {
                var pval = property.GetValue(val);
                if (pval == null)
                {
                    continue;
                }

                SerializedTypeHelper.Serialize(so, property.Name, pval);
            }

            if (!noMarker)
            {
                //Object ending marker
                SerializedTypeHelper.STInt8.Serialize(so, 0xe1);
            }
        }
Пример #3
0
        void ISerializedType.Serialize(Serializer so, object val, bool noMarker)
        {
            ulong?number = Utils.TryGetNumber <ulong>(val, false);

            if (number.HasValue)
            {
                Serialize(so, number.Value, noMarker);
                return;
            }

            if (val is string str)
            {
                if (!Utils.IsHexString(str))
                {
                    throw new ArgumentException("Invalid hex string.");
                }

                if (str.Length > 16)
                {
                    throw new ArgumentException("Int64 is too large.");
                }

                while (str.Length < 16)
                {
                    str = "0" + str;
                }

                SerializedTypeHelper.SerializeHex(so, str, true);
                return;
            }

            throw new ArgumentException("Invalid type for Int64.");
        }
Пример #4
0
        public void Serialize(Serializer so, IEnumerable <string> val, bool noMarker = false)
        {
            var array = val.ToArray();

            SerializedTypeHelper.SerializeVarint(so, (uint)array.Length * 32);
            foreach (var item in array)
            {
                SerializedTypeHelper.STHash256.Serialize(so, item);
            }
        }
Пример #5
0
        public void Serialize(Serializer so, string val, bool noMarker = false)
        {
            if (val != null && Regex.IsMatch(val, "^[0-9A-F]{0,64}$", RegexOptions.IgnoreCase) &&
                val.Length <= 64)
            {
                SerializedTypeHelper.SerializeHex(so, val, true);
                return;
            }

            throw new ArgumentException("Invalid Hash256.");
        }
Пример #6
0
        public void Serialize(Serializer so, IEnumerable val, bool noMarker = false)
        {
            foreach (var item in val)
            {
                if (item == null || item.GetType().IsValueType)
                {
                    throw new ArgumentException("Cannot serialize an array containing null or value type object.");
                }

                var properties = item.GetType().GetProperties();
                if (properties.Length != 1)
                {
                    throw new ArgumentException("Cannot serialize an array containing non-single-key objects");
                }

                var property = properties.First();
                SerializedTypeHelper.Serialize(so, property.Name, property.GetValue(item));
            }

            //Array ending marker
            SerializedTypeHelper.STInt8.Serialize(so, 0xf1);
        }
Пример #7
0
 public void Serialize(Serializer so, string val, bool noMarker = false)
 {
     SerializedTypeHelper.SerializeHex(so, val);
 }
Пример #8
0
        public void Serialize(Serializer so, MemoDataInfo val, bool noMarker = false)
        {
            var properties = val.GetType().GetProperties()
                             .Where(p => p.Name != p.Name.ToLower())
                             .ToArray();

            var invalid = properties.FirstOrDefault(p => !SerializedTypeHelper.InverseFieldsMap.ContainsKey(p.Name));

            if (invalid != null)
            {
                throw new InvalidOperationException("JSON contains unknown field: '" + invalid.Name + "'");
            }

            properties = SerializedTypeHelper.SortProperties(properties);

            // memo format always be string
            var isJson = val.MemoFormat == "json";

            foreach (var property in properties)
            {
                object value = property.GetValue(val);
                if (value == null)
                {
                    continue;
                }

                switch (property.Name)
                {
                case "MemoType":
                    value = SerializedTypeHelper.ConvertStringToHex(val.MemoType);
                    break;

                case "MemoFormat":
                    value = SerializedTypeHelper.ConvertStringToHex(val.MemoFormat);
                    break;

                case "MemoData":
                    if (val.MemoData is string str)
                    {
                        value = SerializedTypeHelper.ConvertStringToHex(str);
                        break;
                    }

                    if (isJson)
                    {
                        var json = JsonConvert.SerializeObject(val.MemoData);
                        value = SerializedTypeHelper.ConvertStringToHex(json);
                        break;
                    }

                    throw new InvalidOperationException("MemoData can only be a JSON object with a valid json MemoFormat.");
                }

                SerializedTypeHelper.Serialize(so, property.Name, value);
            }

            if (!noMarker)
            {
                //Object ending marker
                SerializedTypeHelper.STInt8.Serialize(so, 0xe1);
            }
        }
Пример #9
0
        public void Serialize(Serializer so, PathComputed[][] val, bool noMarker = false)
        {
            if (val != null)
            {
                for (int i = 0, l = val.Length; i < l; i++)
                {
                    //Boundary,
                    if (i > 0)
                    {
                        SerializedTypeHelper.STInt8.Serialize(so, typeBoundary);
                    }

                    var pathes = val[i];
                    for (int j = 0, l2 = pathes.Length; j < l2; j++)
                    {
                        var entry = pathes[j];

                        byte type;
                        if (entry.Type != null)
                        {
                            type = entry.Type.Value;
                        }
                        else
                        {
                            type = 0;
                            if (entry.Account != null)
                            {
                                type |= typeAccount;
                            }
                            if (entry.Currency != null)
                            {
                                type |= typeCurrency;
                            }
                            if (entry.Issuer != null)
                            {
                                type |= typeIssuer;
                            }
                        }

                        SerializedTypeHelper.STInt8.Serialize(so, type);

                        if (entry.Account != null)
                        {
                            so.Append(SerializedTypeHelper.ConvertAddressToBytes(entry.Account));
                        }

                        if (entry.Currency != null)
                        {
                            var currencyBytes = SerializedCurrency.FromJsonToBytes(entry.Currency);
                            so.Append(currencyBytes);
                        }

                        if (entry.Issuer != null)
                        {
                            so.Append(SerializedTypeHelper.ConvertAddressToBytes(entry.Issuer));
                        }
                    }
                }
            }

            SerializedTypeHelper.STInt8.Serialize(so, typeEnd);
        }
Пример #10
0
        public void Serialize(Serializer so, TumAmount val, bool noMarker = false)
        {
            if (!val.IsValid)
            {
                throw new Exception("Not a valid Amount object.");
            }

            //For SWT, offset is 0
            //only convert the value
            if (val.IsNative)
            {
                var valueHex = val.Value.ToString(16);

                // Enforce correct length (64 bits)
                if (valueHex.Length > 16)
                {
                    throw new Exception("Amount value out of bounds.");
                }

                while (valueHex.Length < 16)
                {
                    valueHex = '0' + valueHex;
                }

                //Convert the HEX value to bytes array
                var valueBytes = Utils.HexToBytes(valueHex);

                // Clear most significant two bits - these bits should already be 0 if
                // Amount enforces the range correctly, but we'll clear them anyway just
                // so this code can make certain guarantees about the encoded value.
                valueBytes[0] &= 0x3f;

                if (!val.IsNegative)
                {
                    valueBytes[0] |= 0x40;
                }

                so.Append(valueBytes);
            }
            else
            {
                //For other non-native currency
                //1. Serialize the currency value with offset
                //Put offset
                long hi = 0, lo = 0;

                // First bit: non-native
                hi |= 1 << 31;

                if (!val.IsZero)
                {
                    // Second bit: non-negative?
                    if (!val.IsNegative)
                    {
                        hi |= 1 << 30;
                    }

                    // Next eight bits: offset/exponent
                    hi |= ((97L + val.Offset) & 0xff) << 22;
                    // Remaining 54 bits: mantissa
                    hi |= val.Value.ShiftRight(32).LongValue & 0x3fffff;
                    lo  = val.Value.LongValue & 0xffffffff;
                }

                // Convert from a bitArray to an array of bytes.
                var  arr = new long[] { hi, lo };
                int  l   = arr.Length;
                long bl;

                if (l == 0)
                {
                    bl = 0;
                }
                else
                {
                    var x      = arr[l - 1];
                    var roundX = x / 0x10000000000; // result as Math.Round(x/0x10000000000)
                    if (roundX == 0)
                    {
                        roundX = 32;
                    }
                    bl = (l - 1) * 32 + roundX;
                }

                //Setup a new byte array and filled the byte data in
                //Results should not longer than 8 bytes as defined earlier
                var tmparray = new List <byte>();

                long tmp = 0;
                for (var i = 0; i < bl / 8; i++)
                {
                    if ((i & 3) == 0)
                    {
                        tmp = arr[i / 4];
                    }
                    tmparray.Add((byte)(tmp >> 24));
                    tmp <<= 8;
                }

                if (tmparray.Count > 8)
                {
                    throw new Exception("Invalid byte array length in AMOUNT value representation");
                }

                var valueBytes = tmparray.ToArray();
                so.Append(valueBytes);

                //2. Serialize the currency info with currency code
                //   and issuer
                //console.log("Serial non-native AMOUNT ......");
                // Currency (160-bit hash)
                var tum_bytes = val.TumToBytes();
                so.Append(tum_bytes);

                // Issuer (160-bit hash)
                //so.append(amount.issuer().to_bytes());
                so.Append(SerializedTypeHelper.ConvertAddressToBytes(val.Issuer));
            }
        }