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.
@@ -1,280 +1,284 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- module PortableCodec
4
- class Error < StandardError; end
5
- class TypeNotFound < Error; end
6
- class TypeNotImplemented < Error; end
7
- class CompositeInvalidValue < Error; end
8
- class ArrayLengthNotEqual < Error; end
9
- class VariantItemNotFound < Error; end
10
- class VariantIndexOutOfRange < Error; end
11
- class VariantInvalidValue < Error; end
12
-
13
- class << self
14
- def u256(value)
15
- bytes = ScaleRb.encode('u256', value)
16
- bytes.each_slice(8).map do |slice|
17
- ScaleRb.decode('u64', slice).first
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
- class << self
23
- # registry:
24
- # {
25
- # 0 => {
26
- # path: [...],
27
- # params: [...],
28
- # def: {
29
- # primitive: 'u8' | array: {} | ...
30
- # }
31
- # },
32
- # 1 => {
33
- # ...
34
- # }
35
- # }
36
- def decode(id, bytes, registry)
37
- type = registry[id]
38
- raise TypeNotFound, "id: #{id}" if type.nil?
39
-
40
- _path = type._get(:path)
41
- _params = type._get(:params)
42
- type_def = type._get(:def)
43
-
44
- return decode_primitive(type_def, bytes) if type_def._key?(:primitive)
45
- return decode_compact(bytes) if type_def._key?(:compact)
46
- return decode_array(type_def._get(:array), bytes, registry) if type_def._key?(:array)
47
- return decode_sequence(type_def._get(:sequence), bytes, registry) if type_def._key?(:sequence)
48
- return decode_tuple(type_def._get(:tuple), bytes, registry) if type_def._key?(:tuple)
49
- return decode_composite(type_def._get(:composite), bytes, registry) if type_def._key?(:composite)
50
- return decode_variant(type_def._get(:variant), bytes, registry) if type_def._key?(:variant)
51
-
52
- raise TypeNotImplemented, "id: #{id}"
53
- end
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
- # Uint, Str, Bool
56
- # Int, Bytes ?
57
- def decode_primitive(type_def, bytes)
58
- primitive = type_def._get(:primitive)
59
- return ScaleRb.decode_uint(primitive, bytes) if ScaleRb.uint?(primitive)
60
- return ScaleRb.decode_string(bytes) if ScaleRb.string?(primitive)
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
- def decode_compact(bytes)
67
- ScaleRb.decode_compact(bytes)
68
- end
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
- def decode_array(array_type, bytes, registry)
71
- len = array_type._get(:len)
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
- def _u8?(type_id, registry)
86
- type = registry[type_id]
87
- raise TypeNotFound, "id: #{type_id}" if type.nil?
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
- type._get(:def)._get(:primitive)&.downcase == 'u8'
90
- end
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
- def decode_sequence(sequence_type, bytes, registry)
93
- len, remaining_bytes = decode_compact(bytes)
94
- inner_type_id = sequence_type._get(:type)
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
- def decode_tuple(tuple_type, bytes, registry)
99
- _decode_types(tuple_type, bytes, registry)
100
- end
91
+ type._get(:def)._get(:primitive)&.downcase == 'u8'
92
+ end
101
93
 
102
- # {
103
- # name: value,
104
- # ...
105
- # }
106
- def decode_composite(composite_type, bytes, registry)
107
- fields = composite_type._get(:fields)
108
-
109
- # reduce composite level when composite only has one field without name
110
- if fields.length == 1 && fields.first._get(:name).nil?
111
- decode(fields.first._get(:type), bytes, registry)
112
- else
113
- type_name_list = fields.map { |f| f._get(:name) }
114
- type_id_list = fields.map { |f| f._get(:type) }
115
-
116
- type_value_list, remaining_bytes = _decode_types(type_id_list, bytes, registry)
117
- [
118
- if type_name_list.all?(&:nil?)
119
- type_value_list
120
- else
121
- [type_name_list.map(&:to_sym), type_value_list].transpose.to_h
122
- end,
123
- remaining_bytes
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
- def decode_variant(variant_type, bytes, registry)
129
- variants = variant_type._get(:variants)
130
+ def decode_variant(variant_type, bytes, registry)
131
+ variants = variant_type._get(:variants)
130
132
 
131
- index = bytes[0].to_i # TODO: check
132
- item = variants.find { |v| v._get(:index) == index } # item is an composite
133
+ index = bytes[0].to_i # TODO: check
134
+ item = variants.find { |v| v._get(:index) == index } # item is an composite
133
135
 
134
- raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
136
+ raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
135
137
 
136
- item_name = item._get(:name)
137
- item_fields = item._get(:fields)
138
- if item_fields.empty?
139
- [item_name, bytes[1..]]
140
- else
141
- item_value, remaining_bytes = decode_composite(item, bytes[1..], registry)
142
- [{ item_name.to_sym => item_value }, remaining_bytes]
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
- def _decode_types(ids, bytes, registry = {})
147
- ScaleRb._decode_each(ids, bytes) do |id, remaining_bytes|
148
- decode(id, remaining_bytes, registry)
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
- def encode_with_hasher(value, type_id, registry, hasher)
153
- value_bytes = encode(type_id, value, registry)
154
- Hasher.apply_hasher(hasher, value_bytes)
155
- end
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
- def encode(id, value, registry)
158
- type = registry[id]
159
- raise TypeNotFound, "id: #{id}" if type.nil?
159
+ def encode(id, value, registry)
160
+ type = registry[id]
161
+ raise TypeNotFound, "id: #{id}" if type.nil?
160
162
 
161
- type_def = type._get(:def)
162
- # debug
163
- # p type_def
164
- # p value
163
+ type_def = type._get(:def)
164
+ # debug
165
+ # p type_def
166
+ # p value
165
167
 
166
- return encode_primitive(type_def, value) if type_def._key?(:primitive)
167
- return encode_compact(value) if type_def._key?(:compact)
168
- return encode_array(type_def._get(:array), value, registry) if type_def._key?(:array)
169
- return encode_sequence(type_def._get(:sequence), value, registry) if type_def._key?(:sequence)
170
- return encode_tuple(type_def._get(:tuple), value, registry) if type_def._key?(:tuple)
171
- return encode_composite(type_def._get(:composite), value, registry) if type_def._key?(:composite)
172
- return encode_variant(type_def._get(:variant), value, registry) if type_def._key?(:variant)
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
- raise TypeNotImplemented, "id: #{id}"
175
- end
176
+ raise TypeNotImplemented, "id: #{id}"
177
+ end
176
178
 
177
- def encode_primitive(type_def, value)
178
- primitive = type_def._get(:primitive)
179
- return ScaleRb.encode_uint(primitive, value) if ScaleRb.uint?(primitive)
180
- return ScaleRb.encode_string(value) if ScaleRb.string?(primitive)
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
- def encode_compact(value)
185
- ScaleRb.encode_compact(value)
186
- end
184
+ ScaleRb.encode_boolean(value) if ScaleRb.boolean?(primitive)
185
+ end
187
186
 
188
- def encode_array(array_type, value, registry)
189
- length = array_type._get(:len)
190
- inner_type_id = array_type._get(:type)
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
- _encode_types([inner_type_id] * length, value, registry)
194
- end
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
- def encode_sequence(sequence_type, value, registry)
197
- inner_type_id = sequence_type._get(:type)
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
- # tuple_type: [type_id1, type_id2, ...]
203
- def encode_tuple(tuple_type, value, registry)
204
- _encode_types(tuple_type, value, registry)
205
- end
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
- # value:
208
- # {
209
- # name1: value1,
210
- # name2: value2,
211
- # ...
212
- # }
213
- # or
214
- # [value1, value2, ...]
215
- def encode_composite(composite_type, value, registry)
216
- fields = composite_type._get(:fields)
217
- # reduce composite level when composite only has one field without name
218
- if fields.length == 1 && fields.first._get(:name).nil?
219
- # debug
220
- # p fields.first._get(:type)
221
- # p value
222
- encode(fields.first._get(:type), value, registry)
223
- else
224
- values =
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?(Array)
228
- value
252
+ [value.keys.first.to_s, value.values.first]
253
+ elsif value.instance_of?(String)
254
+ [value, {}]
229
255
  else
230
- raise CompositeInvalidValue, "value: #{value}, only hash and array"
256
+ raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
231
257
  end
232
258
 
233
- type_id_list = fields.map { |f| f._get(:type) }
234
- _encode_types(type_id_list, values, registry)
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
- # value:
239
- # {
240
- # name: v(Hash)
241
- # }
242
- # or
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
- item = variants.find { |var| var._get(:name) == name }
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
- ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
267
- end
268
-
269
- def _encode_types(ids, values, registry)
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
- def _encode_types_with_hashers(ids, values, registry, hashers)
276
- ScaleRb._encode_each_with_hashers(ids, values, hashers) do |id, value|
277
- encode(id, value, registry)
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
@@ -1,3 +1,3 @@
1
1
  module ScaleRb
2
- VERSION = '0.1.15'
2
+ VERSION = '0.2.0'
3
3
  end
data/lib/scale_rb.rb CHANGED
@@ -21,7 +21,6 @@ require 'hasher'
21
21
  require 'storage_helper'
22
22
 
23
23
  # client
24
- require 'client/rpc_request_builder'
25
24
  require 'client/http_client'
26
25
  require 'client/abstract_ws_client'
27
26
 
@@ -1,64 +1,66 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- module StorageHelper
4
- class << self
5
- # key: {
6
- # value: ,
7
- # type: ,
8
- # hashers: []
9
- # }
10
- def encode_storage_key(pallet_name, item_name, key = nil, registry = nil)
11
- storage_key = Hasher.twox128(pallet_name) + Hasher.twox128(item_name)
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
- if key && registry
14
+ if key && registry
14
15
 
15
- key_types, key_values, key_hashers =
16
- if key[:hashers].length == 1
17
- [
18
- [key[:type]],
19
- key[:value],
20
- key[:hashers]
21
- ]
22
- else
23
- [
24
- registry[key[:type]]._get(:def)._get(:tuple).first(key[:value].length),
25
- key[:value],
26
- key[:hashers].first(key[:value].length)
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
- if key_types.class != key_values.class || key_types.length != key_values.length
31
- 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."
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
- # data: hex string
41
- # type: portable type id
42
- # optional: boolean
43
- # fallback: hex string
44
- # returns nil or data
45
- def decode_storage(data, type, optional, fallback, registry)
46
- data ||= (optional ? nil : fallback)
47
- PortableCodec.decode(type, data.to_bytes, registry)[0] if data
48
- end
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
- # storage_item: the storage item from metadata
51
- def decode_storage2(data, storage_item, registry)
52
- modifier = storage_item._get(:modifier) # Default | Optional
53
- fallback = storage_item._get(:fallback)
54
- type = storage_item._get(:type)._get(:plain) || storage_item._get(:type)._get(:map)._get(:value)
55
- decode_storage(data, type, modifier == 'Optional', fallback, registry)
56
- end
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
- def decode_storage3(data, pallet_name, item_name, metadata)
59
- registry = Metadata.build_registry(metadata)
60
- storage_item = Metadata.get_storage_item(pallet_name, item_name, metadata)
61
- decode_storage2(data, storage_item, registry)
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