scale_rb 0.1.14 → 0.2.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/Gemfile.lock +1 -1
- data/lib/address.rb +85 -89
- data/lib/client/abstract_ws_client.rb +85 -81
- data/lib/client/http_client.rb +2 -170
- data/lib/client/http_client_metadata.rb +10 -8
- data/lib/client/http_client_storage.rb +180 -0
- data/lib/client/rpc_request_builder.rb +44 -42
- data/lib/codec.rb +28 -29
- data/lib/hasher.rb +39 -37
- data/lib/metadata/metadata.rb +130 -122
- data/lib/metadata/metadata_v10.rb +72 -69
- data/lib/metadata/metadata_v11.rb +78 -75
- data/lib/metadata/metadata_v12.rb +42 -39
- data/lib/metadata/metadata_v13.rb +71 -68
- data/lib/metadata/metadata_v14.rb +185 -181
- data/lib/metadata/metadata_v9.rb +92 -89
- data/lib/monkey_patching.rb +22 -22
- data/lib/portable_codec.rb +236 -232
- data/lib/scale_rb/version.rb +1 -1
- data/lib/scale_rb.rb +0 -1
- data/lib/storage_helper.rb +52 -50
- metadata +3 -2
data/lib/portable_codec.rb
CHANGED
@@ -1,280 +1,284 @@
|
|
1
1
|
# frozen_string_literal: true
|
2
2
|
|
3
|
-
module
|
4
|
-
|
5
|
-
|
6
|
-
|
7
|
-
|
8
|
-
|
9
|
-
|
10
|
-
|
11
|
-
|
12
|
-
|
13
|
-
|
14
|
-
|
15
|
-
|
16
|
-
|
17
|
-
|
3
|
+
module ScaleRb
|
4
|
+
module PortableCodec
|
5
|
+
class Error < StandardError; end
|
6
|
+
class TypeNotFound < Error; end
|
7
|
+
class TypeNotImplemented < Error; end
|
8
|
+
class CompositeInvalidValue < Error; end
|
9
|
+
class ArrayLengthNotEqual < Error; end
|
10
|
+
class VariantItemNotFound < Error; end
|
11
|
+
class VariantIndexOutOfRange < Error; end
|
12
|
+
class VariantInvalidValue < Error; end
|
13
|
+
|
14
|
+
class << self
|
15
|
+
def u256(value)
|
16
|
+
bytes = ScaleRb.encode('u256', value)
|
17
|
+
bytes.each_slice(8).map do |slice|
|
18
|
+
ScaleRb.decode('u64', slice).first
|
19
|
+
end
|
18
20
|
end
|
19
21
|
end
|
20
|
-
end
|
21
22
|
|
22
|
-
|
23
|
-
|
24
|
-
|
25
|
-
|
26
|
-
|
27
|
-
|
28
|
-
|
29
|
-
|
30
|
-
|
31
|
-
|
32
|
-
|
33
|
-
|
34
|
-
|
35
|
-
|
36
|
-
|
37
|
-
|
38
|
-
|
39
|
-
|
40
|
-
|
41
|
-
|
42
|
-
|
43
|
-
|
44
|
-
|
45
|
-
|
46
|
-
|
47
|
-
|
48
|
-
|
49
|
-
|
50
|
-
|
51
|
-
|
52
|
-
|
53
|
-
|
23
|
+
class << self
|
24
|
+
# registry:
|
25
|
+
# {
|
26
|
+
# 0 => {
|
27
|
+
# path: [...],
|
28
|
+
# params: [...],
|
29
|
+
# def: {
|
30
|
+
# primitive: 'u8' | array: {} | ...
|
31
|
+
# }
|
32
|
+
# },
|
33
|
+
# 1 => {
|
34
|
+
# ...
|
35
|
+
# }
|
36
|
+
# }
|
37
|
+
def decode(id, bytes, registry)
|
38
|
+
type = registry[id]
|
39
|
+
raise TypeNotFound, "id: #{id}" if type.nil?
|
40
|
+
|
41
|
+
_path = type._get(:path)
|
42
|
+
_params = type._get(:params)
|
43
|
+
type_def = type._get(:def)
|
44
|
+
|
45
|
+
return decode_primitive(type_def, bytes) if type_def._key?(:primitive)
|
46
|
+
return decode_compact(bytes) if type_def._key?(:compact)
|
47
|
+
return decode_array(type_def._get(:array), bytes, registry) if type_def._key?(:array)
|
48
|
+
return decode_sequence(type_def._get(:sequence), bytes, registry) if type_def._key?(:sequence)
|
49
|
+
return decode_tuple(type_def._get(:tuple), bytes, registry) if type_def._key?(:tuple)
|
50
|
+
return decode_composite(type_def._get(:composite), bytes, registry) if type_def._key?(:composite)
|
51
|
+
return decode_variant(type_def._get(:variant), bytes, registry) if type_def._key?(:variant)
|
52
|
+
|
53
|
+
raise TypeNotImplemented, "id: #{id}"
|
54
|
+
end
|
54
55
|
|
55
|
-
|
56
|
-
|
57
|
-
|
58
|
-
|
59
|
-
|
60
|
-
|
61
|
-
return ScaleRb.decode_boolean(bytes) if ScaleRb.boolean?(primitive)
|
62
|
-
# return ScaleRb.decode_int(primitive, bytes) if int?(primitive)
|
63
|
-
# return ScaleRb.decode_bytes(bytes) if bytes?(primitive)
|
64
|
-
end
|
56
|
+
# Uint, Str, Bool
|
57
|
+
# Int, Bytes ?
|
58
|
+
def decode_primitive(type_def, bytes)
|
59
|
+
primitive = type_def._get(:primitive)
|
60
|
+
return ScaleRb.decode_uint(primitive, bytes) if ScaleRb.uint?(primitive)
|
61
|
+
return ScaleRb.decode_string(bytes) if ScaleRb.string?(primitive)
|
65
62
|
|
66
|
-
|
67
|
-
|
68
|
-
|
63
|
+
ScaleRb.decode_boolean(bytes) if ScaleRb.boolean?(primitive)
|
64
|
+
# return ScaleRb.decode_int(primitive, bytes) if int?(primitive)
|
65
|
+
# return ScaleRb.decode_bytes(bytes) if bytes?(primitive)
|
66
|
+
end
|
69
67
|
|
70
|
-
|
71
|
-
|
72
|
-
inner_type_id = array_type._get(:type)
|
73
|
-
|
74
|
-
# check if the type of inner_type_id is a u8
|
75
|
-
if _u8?(inner_type_id, registry)
|
76
|
-
[
|
77
|
-
bytes[0...len].to_hex,
|
78
|
-
bytes[len..]
|
79
|
-
]
|
80
|
-
else
|
81
|
-
_decode_types([inner_type_id] * len, bytes, registry)
|
68
|
+
def decode_compact(bytes)
|
69
|
+
ScaleRb.decode_compact(bytes)
|
82
70
|
end
|
83
|
-
end
|
84
71
|
|
85
|
-
|
86
|
-
|
87
|
-
|
72
|
+
def decode_array(array_type, bytes, registry)
|
73
|
+
len = array_type._get(:len)
|
74
|
+
inner_type_id = array_type._get(:type)
|
88
75
|
|
89
|
-
|
90
|
-
|
76
|
+
# check if the type of inner_type_id is a u8
|
77
|
+
if _u8?(inner_type_id, registry)
|
78
|
+
[
|
79
|
+
bytes[0...len]._to_hex,
|
80
|
+
bytes[len..]
|
81
|
+
]
|
82
|
+
else
|
83
|
+
_decode_types([inner_type_id] * len, bytes, registry)
|
84
|
+
end
|
85
|
+
end
|
91
86
|
|
92
|
-
|
93
|
-
|
94
|
-
|
95
|
-
_decode_types([inner_type_id] * len, remaining_bytes, registry)
|
96
|
-
end
|
87
|
+
def _u8?(type_id, registry)
|
88
|
+
type = registry[type_id]
|
89
|
+
raise TypeNotFound, "id: #{type_id}" if type.nil?
|
97
90
|
|
98
|
-
|
99
|
-
|
100
|
-
end
|
91
|
+
type._get(:def)._get(:primitive)&.downcase == 'u8'
|
92
|
+
end
|
101
93
|
|
102
|
-
|
103
|
-
|
104
|
-
|
105
|
-
|
106
|
-
|
107
|
-
|
108
|
-
|
109
|
-
|
110
|
-
|
111
|
-
|
112
|
-
|
113
|
-
|
114
|
-
|
115
|
-
|
116
|
-
|
117
|
-
|
118
|
-
|
119
|
-
|
120
|
-
|
121
|
-
|
122
|
-
|
123
|
-
|
124
|
-
|
94
|
+
def decode_sequence(sequence_type, bytes, registry)
|
95
|
+
len, remaining_bytes = decode_compact(bytes)
|
96
|
+
inner_type_id = sequence_type._get(:type)
|
97
|
+
_decode_types([inner_type_id] * len, remaining_bytes, registry)
|
98
|
+
end
|
99
|
+
|
100
|
+
def decode_tuple(tuple_type, bytes, registry)
|
101
|
+
_decode_types(tuple_type, bytes, registry)
|
102
|
+
end
|
103
|
+
|
104
|
+
# {
|
105
|
+
# name: value,
|
106
|
+
# ...
|
107
|
+
# }
|
108
|
+
def decode_composite(composite_type, bytes, registry)
|
109
|
+
fields = composite_type._get(:fields)
|
110
|
+
|
111
|
+
# reduce composite level when composite only has one field without name
|
112
|
+
if fields.length == 1 && fields.first._get(:name).nil?
|
113
|
+
decode(fields.first._get(:type), bytes, registry)
|
114
|
+
else
|
115
|
+
type_name_list = fields.map { |f| f._get(:name) }
|
116
|
+
type_id_list = fields.map { |f| f._get(:type) }
|
117
|
+
|
118
|
+
type_value_list, remaining_bytes = _decode_types(type_id_list, bytes, registry)
|
119
|
+
[
|
120
|
+
if type_name_list.all?(&:nil?)
|
121
|
+
type_value_list
|
122
|
+
else
|
123
|
+
[type_name_list.map(&:to_sym), type_value_list].transpose.to_h
|
124
|
+
end,
|
125
|
+
remaining_bytes
|
126
|
+
]
|
127
|
+
end
|
125
128
|
end
|
126
|
-
end
|
127
129
|
|
128
|
-
|
129
|
-
|
130
|
+
def decode_variant(variant_type, bytes, registry)
|
131
|
+
variants = variant_type._get(:variants)
|
130
132
|
|
131
|
-
|
132
|
-
|
133
|
+
index = bytes[0].to_i # TODO: check
|
134
|
+
item = variants.find { |v| v._get(:index) == index } # item is an composite
|
133
135
|
|
134
|
-
|
136
|
+
raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
|
135
137
|
|
136
|
-
|
137
|
-
|
138
|
-
|
139
|
-
|
140
|
-
|
141
|
-
|
142
|
-
|
138
|
+
item_name = item._get(:name)
|
139
|
+
item_fields = item._get(:fields)
|
140
|
+
if item_fields.empty?
|
141
|
+
[item_name, bytes[1..]]
|
142
|
+
else
|
143
|
+
item_value, remaining_bytes = decode_composite(item, bytes[1..], registry)
|
144
|
+
[{ item_name.to_sym => item_value }, remaining_bytes]
|
145
|
+
end
|
143
146
|
end
|
144
|
-
end
|
145
147
|
|
146
|
-
|
147
|
-
|
148
|
-
|
148
|
+
def _decode_types(ids, bytes, registry = {})
|
149
|
+
ScaleRb._decode_each(ids, bytes) do |id, remaining_bytes|
|
150
|
+
decode(id, remaining_bytes, registry)
|
151
|
+
end
|
149
152
|
end
|
150
|
-
end
|
151
153
|
|
152
|
-
|
153
|
-
|
154
|
-
|
155
|
-
|
154
|
+
def encode_with_hasher(value, type_id, registry, hasher)
|
155
|
+
value_bytes = encode(type_id, value, registry)
|
156
|
+
Hasher.apply_hasher(hasher, value_bytes)
|
157
|
+
end
|
156
158
|
|
157
|
-
|
158
|
-
|
159
|
-
|
159
|
+
def encode(id, value, registry)
|
160
|
+
type = registry[id]
|
161
|
+
raise TypeNotFound, "id: #{id}" if type.nil?
|
160
162
|
|
161
|
-
|
162
|
-
|
163
|
-
|
164
|
-
|
163
|
+
type_def = type._get(:def)
|
164
|
+
# debug
|
165
|
+
# p type_def
|
166
|
+
# p value
|
165
167
|
|
166
|
-
|
167
|
-
|
168
|
-
|
169
|
-
|
170
|
-
|
171
|
-
|
172
|
-
|
168
|
+
return encode_primitive(type_def, value) if type_def._key?(:primitive)
|
169
|
+
return encode_compact(value) if type_def._key?(:compact)
|
170
|
+
return encode_array(type_def._get(:array), value, registry) if type_def._key?(:array)
|
171
|
+
return encode_sequence(type_def._get(:sequence), value, registry) if type_def._key?(:sequence)
|
172
|
+
return encode_tuple(type_def._get(:tuple), value, registry) if type_def._key?(:tuple)
|
173
|
+
return encode_composite(type_def._get(:composite), value, registry) if type_def._key?(:composite)
|
174
|
+
return encode_variant(type_def._get(:variant), value, registry) if type_def._key?(:variant)
|
173
175
|
|
174
|
-
|
175
|
-
|
176
|
+
raise TypeNotImplemented, "id: #{id}"
|
177
|
+
end
|
176
178
|
|
177
|
-
|
178
|
-
|
179
|
-
|
180
|
-
|
181
|
-
return ScaleRb.encode_boolean(value) if ScaleRb.boolean?(primitive)
|
182
|
-
end
|
179
|
+
def encode_primitive(type_def, value)
|
180
|
+
primitive = type_def._get(:primitive)
|
181
|
+
return ScaleRb.encode_uint(primitive, value) if ScaleRb.uint?(primitive)
|
182
|
+
return ScaleRb.encode_string(value) if ScaleRb.string?(primitive)
|
183
183
|
|
184
|
-
|
185
|
-
|
186
|
-
end
|
184
|
+
ScaleRb.encode_boolean(value) if ScaleRb.boolean?(primitive)
|
185
|
+
end
|
187
186
|
|
188
|
-
|
189
|
-
|
190
|
-
|
191
|
-
raise ArrayLengthNotEqual, "type: #{array_type}, value: #{value.inspect}" if length != value.length
|
187
|
+
def encode_compact(value)
|
188
|
+
ScaleRb.encode_compact(value)
|
189
|
+
end
|
192
190
|
|
193
|
-
|
194
|
-
|
191
|
+
def encode_array(array_type, value, registry)
|
192
|
+
length = array_type._get(:len)
|
193
|
+
inner_type_id = array_type._get(:type)
|
194
|
+
raise ArrayLengthNotEqual, "type: #{array_type}, value: #{value.inspect}" if length != value.length
|
195
195
|
|
196
|
-
|
197
|
-
|
198
|
-
length_bytes = encode_compact(value.length)
|
199
|
-
length_bytes + _encode_types([inner_type_id] * value.length, value, registry)
|
200
|
-
end
|
196
|
+
_encode_types([inner_type_id] * length, value, registry)
|
197
|
+
end
|
201
198
|
|
202
|
-
|
203
|
-
|
204
|
-
|
205
|
-
|
199
|
+
def encode_sequence(sequence_type, value, registry)
|
200
|
+
inner_type_id = sequence_type._get(:type)
|
201
|
+
length_bytes = encode_compact(value.length)
|
202
|
+
length_bytes + _encode_types([inner_type_id] * value.length, value, registry)
|
203
|
+
end
|
206
204
|
|
207
|
-
|
208
|
-
|
209
|
-
|
210
|
-
|
211
|
-
|
212
|
-
|
213
|
-
|
214
|
-
|
215
|
-
|
216
|
-
|
217
|
-
#
|
218
|
-
|
219
|
-
|
220
|
-
|
221
|
-
|
222
|
-
|
223
|
-
|
224
|
-
|
205
|
+
# tuple_type: [type_id1, type_id2, ...]
|
206
|
+
def encode_tuple(tuple_type, value, registry)
|
207
|
+
_encode_types(tuple_type, value, registry)
|
208
|
+
end
|
209
|
+
|
210
|
+
# value:
|
211
|
+
# {
|
212
|
+
# name1: value1,
|
213
|
+
# name2: value2,
|
214
|
+
# ...
|
215
|
+
# }
|
216
|
+
# or
|
217
|
+
# [value1, value2, ...]
|
218
|
+
def encode_composite(composite_type, value, registry)
|
219
|
+
fields = composite_type._get(:fields)
|
220
|
+
# reduce composite level when composite only has one field without name
|
221
|
+
if fields.length == 1 && fields.first._get(:name).nil?
|
222
|
+
# debug
|
223
|
+
# p fields.first._get(:type)
|
224
|
+
# p value
|
225
|
+
encode(fields.first._get(:type), value, registry)
|
226
|
+
else
|
227
|
+
values =
|
228
|
+
if value.instance_of?(Hash)
|
229
|
+
value.values
|
230
|
+
elsif value.instance_of?(Array)
|
231
|
+
value
|
232
|
+
else
|
233
|
+
raise CompositeInvalidValue, "value: #{value}, only hash and array"
|
234
|
+
end
|
235
|
+
|
236
|
+
type_id_list = fields.map { |f| f._get(:type) }
|
237
|
+
_encode_types(type_id_list, values, registry)
|
238
|
+
end
|
239
|
+
end
|
240
|
+
|
241
|
+
# value:
|
242
|
+
# {
|
243
|
+
# name: v(Hash)
|
244
|
+
# }
|
245
|
+
# or
|
246
|
+
# the_value(String)
|
247
|
+
def encode_variant(variant_type, value, registry)
|
248
|
+
variants = variant_type._get(:variants)
|
249
|
+
|
250
|
+
name, v = # v: item inner value
|
225
251
|
if value.instance_of?(Hash)
|
226
|
-
value.values
|
227
|
-
elsif value.instance_of?(
|
228
|
-
value
|
252
|
+
[value.keys.first.to_s, value.values.first]
|
253
|
+
elsif value.instance_of?(String)
|
254
|
+
[value, {}]
|
229
255
|
else
|
230
|
-
raise
|
256
|
+
raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
|
231
257
|
end
|
232
258
|
|
233
|
-
|
234
|
-
|
235
|
-
end
|
236
|
-
end
|
259
|
+
item = variants.find { |var| var._get(:name) == name }
|
260
|
+
raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
|
237
261
|
|
238
|
-
|
239
|
-
|
240
|
-
|
241
|
-
|
242
|
-
|
243
|
-
# the_value(String)
|
244
|
-
def encode_variant(variant_type, value, registry)
|
245
|
-
variants = variant_type._get(:variants)
|
246
|
-
|
247
|
-
name, v = # v: item inner value
|
248
|
-
if value.instance_of?(Hash)
|
249
|
-
[value.keys.first.to_s, value.values.first]
|
250
|
-
elsif value.instance_of?(String)
|
251
|
-
[value, {}]
|
252
|
-
else
|
253
|
-
raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
|
262
|
+
# if the variant item has more than one field, the value must be a hash with the same length.
|
263
|
+
# if the variant item has only one field, that means the field is a type id point to a composite. TODO: check the type's fields length
|
264
|
+
if item._get(:fields).length > 1 && item._get(:fields).length != v.length
|
265
|
+
raise VariantFieldsLengthNotMatch,
|
266
|
+
"type: #{variant_type}, \nvalue: #{v}"
|
254
267
|
end
|
255
268
|
|
256
|
-
|
257
|
-
raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
|
258
|
-
|
259
|
-
# if the variant item has more than one field, the value must be a hash with the same length.
|
260
|
-
# if the variant item has only one field, that means the field is a type id point to a composite. TODO: check the type's fields length
|
261
|
-
if item._get(:fields).length > 1 && item._get(:fields).length != v.length
|
262
|
-
raise VariantFieldsLengthNotMatch,
|
263
|
-
"type: #{variant_type}, \nvalue: #{v}"
|
269
|
+
ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
|
264
270
|
end
|
265
271
|
|
266
|
-
|
267
|
-
|
268
|
-
|
269
|
-
|
270
|
-
ScaleRb._encode_each(ids, values) do |id, value|
|
271
|
-
encode(id, value, registry)
|
272
|
+
def _encode_types(ids, values, registry)
|
273
|
+
ScaleRb._encode_each(ids, values) do |id, value|
|
274
|
+
encode(id, value, registry)
|
275
|
+
end
|
272
276
|
end
|
273
|
-
end
|
274
277
|
|
275
|
-
|
276
|
-
|
277
|
-
|
278
|
+
def _encode_types_with_hashers(ids, values, registry, hashers)
|
279
|
+
ScaleRb._encode_each_with_hashers(ids, values, hashers) do |id, value|
|
280
|
+
encode(id, value, registry)
|
281
|
+
end
|
278
282
|
end
|
279
283
|
end
|
280
284
|
end
|
data/lib/scale_rb/version.rb
CHANGED
data/lib/scale_rb.rb
CHANGED
data/lib/storage_helper.rb
CHANGED
@@ -1,64 +1,66 @@
|
|
1
1
|
# frozen_string_literal: true
|
2
2
|
|
3
|
-
module
|
4
|
-
|
5
|
-
|
6
|
-
|
7
|
-
|
8
|
-
|
9
|
-
|
10
|
-
|
11
|
-
|
3
|
+
module ScaleRb
|
4
|
+
module StorageHelper
|
5
|
+
class << self
|
6
|
+
# key: {
|
7
|
+
# value: ,
|
8
|
+
# type: ,
|
9
|
+
# hashers: []
|
10
|
+
# }
|
11
|
+
def encode_storage_key(pallet_name, item_name, key = nil, registry = nil)
|
12
|
+
storage_key = Hasher.twox128(pallet_name) + Hasher.twox128(item_name)
|
12
13
|
|
13
|
-
|
14
|
+
if key && registry
|
14
15
|
|
15
|
-
|
16
|
-
|
17
|
-
|
18
|
-
|
19
|
-
|
20
|
-
|
21
|
-
|
22
|
-
|
23
|
-
|
24
|
-
|
25
|
-
|
26
|
-
|
27
|
-
|
16
|
+
key_types, key_values, key_hashers =
|
17
|
+
if key[:hashers].length == 1
|
18
|
+
[
|
19
|
+
[key[:type]],
|
20
|
+
[key[:value]],
|
21
|
+
key[:hashers]
|
22
|
+
]
|
23
|
+
else
|
24
|
+
[
|
25
|
+
registry[key[:type]]._get(:def)._get(:tuple).first(key[:value].length),
|
26
|
+
key[:value],
|
27
|
+
key[:hashers].first(key[:value].length)
|
28
|
+
]
|
29
|
+
end
|
30
|
+
|
31
|
+
if key_types.class != key_values.class || key_types.length != key_values.length
|
32
|
+
raise "Key's value doesn't match key's type, key's value: #{key_values.inspect}, but key's type: #{key_types.inspect}. Please check your key's value."
|
28
33
|
end
|
29
34
|
|
30
|
-
|
31
|
-
|
35
|
+
storage_key + PortableCodec._encode_types_with_hashers(key_types, key_values, registry, key_hashers)
|
36
|
+
else
|
37
|
+
storage_key
|
32
38
|
end
|
33
|
-
|
34
|
-
storage_key + PortableCodec._encode_types_with_hashers(key_types, key_values, registry, key_hashers)
|
35
|
-
else
|
36
|
-
storage_key
|
37
39
|
end
|
38
|
-
end
|
39
40
|
|
40
|
-
|
41
|
-
|
42
|
-
|
43
|
-
|
44
|
-
|
45
|
-
|
46
|
-
|
47
|
-
|
48
|
-
|
41
|
+
# data: hex string
|
42
|
+
# type: portable type id
|
43
|
+
# optional: boolean
|
44
|
+
# fallback: hex string
|
45
|
+
# returns nil or data
|
46
|
+
def decode_storage(data, type, optional, fallback, registry)
|
47
|
+
data ||= (optional ? nil : fallback)
|
48
|
+
PortableCodec.decode(type, data._to_bytes, registry)[0] if data
|
49
|
+
end
|
49
50
|
|
50
|
-
|
51
|
-
|
52
|
-
|
53
|
-
|
54
|
-
|
55
|
-
|
56
|
-
|
51
|
+
# storage_item: the storage item from metadata
|
52
|
+
def decode_storage2(data, storage_item, registry)
|
53
|
+
modifier = storage_item._get(:modifier) # Default | Optional
|
54
|
+
fallback = storage_item._get(:fallback)
|
55
|
+
type = storage_item._get(:type)._get(:plain) || storage_item._get(:type)._get(:map)._get(:value)
|
56
|
+
decode_storage(data, type, modifier == 'Optional', fallback, registry)
|
57
|
+
end
|
57
58
|
|
58
|
-
|
59
|
-
|
60
|
-
|
61
|
-
|
59
|
+
def decode_storage3(data, pallet_name, item_name, metadata)
|
60
|
+
registry = Metadata.build_registry(metadata)
|
61
|
+
storage_item = Metadata.get_storage_item(pallet_name, item_name, metadata)
|
62
|
+
decode_storage2(data, storage_item, registry)
|
63
|
+
end
|
62
64
|
end
|
63
65
|
end
|
64
66
|
end
|