scale_rb 0.1.15 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- 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 +1 -0
- data/lib/client/http_client_metadata.rb +1 -1
- data/lib/client/http_client_storage.rb +6 -6
- data/lib/client/rpc_request_builder.rb +44 -42
- data/lib/codec.rb +11 -11
- 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 +2 -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
|