Module: Nem::Util::Serializer

Defined in:
lib/nem/util/serializer.rb

Class Method Summary collapse

Class Method Details

.serialize_bin_string(str) ⇒ Array 



157
158
159
160
161
162
 
# File 'lib/nem/util/serializer.rb', line 157

def self.serialize_bin_string(str)
  return [255, 255, 255, 255] if str.nil?
  return [0, 0, 0, 0] if str.empty?
  chars = str.is_a?(String) ? str.chars : str
  [chars.size, 0, 0, 0] + chars.map(&:to_i)
end

.serialize_common(entity) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/nem/util/serializer.rb', line 132

def self.serialize_common(entity)
  a = []
  a.concat serialize_int(entity[:type])
  a.concat serialize_int(entity[:version])
  a.concat serialize_int(entity[:timeStamp])

  signer = Nem::Util::Convert.hex2ua(entity[:signer])
  a.concat serialize_int(signer.size)
  a.concat signer

  a.concat serialize_long(entity[:fee].to_i)
  a.concat serialize_int(entity[:deadline])
end

.serialize_importance_transfer(entity) ⇒ Object 



43
44
45
46
47
48
49
 
# File 'lib/nem/util/serializer.rb', line 43

def self.serialize_importance_transfer(entity)
  a = []
  a.concat serialize_int(entity[:mode])
  temp = Nem::Util::Convert.hex2ua(entity[:remoteAccount])
  a.concat serialize_int(temp.size)
  a.concat temp
end

.serialize_int(value) ⇒ Array 



166
167
168
 
# File 'lib/nem/util/serializer.rb', line 166

def self.serialize_int(value)
  [value].pack('I').unpack('C4')
end

.serialize_levy(entity) ⇒ Array 



237
238
239
240
241
242
243
244
245
 
# File 'lib/nem/util/serializer.rb', line 237

def self.serialize_levy(entity)
  return [0, 0, 0, 0] if entity.nil?
  a = []
  a.concat serialize_int(entity[:type])
  a.concat serialize_safe_string(entity[:recipient])
  a.concat serialize_mosaic_id(entity[:mosaicId])
  a.concat serialize_long(entity[:fee])
  serialize_int(a.size) + a
end

.serialize_long(value) ⇒ Array 



172
173
174
175
176
177
178
179
 
# File 'lib/nem/util/serializer.rb', line 172

def self.serialize_long(value)
  a = [0, 0, 0, 0, 0, 0, 0, 0]
  bin = sprintf('%040b', value)
  0.upto(bin.size / 8 - 1) do |i|
    a[i] = 0xFF & (value >> 8 * i)
  end
  a
end

.serialize_mosaic_attachment(mosaic_attachment) ⇒ Array 



183
184
185
186
187
188
189
190
 
# File 'lib/nem/util/serializer.rb', line 183

def self.serialize_mosaic_attachment(mosaic_attachment)
  a = []
  mosaic_id = serialize_mosaic_id(mosaic_attachment[:mosaicId])
  quantity = serialize_long(mosaic_attachment[:quantity])
  a.concat serialize_int((mosaic_id + quantity).size)
  a.concat mosaic_id
  a.concat quantity
end

.serialize_mosaic_definition(entity) ⇒ Array 



249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/nem/util/serializer.rb', line 249

def self.serialize_mosaic_definition(entity)
  a = []
  creator = Nem::Util::Convert.hex2ua(entity[:creator])
  a.concat serialize_int(creator.size)
  a.concat creator
  a.concat serialize_mosaic_id(entity[:id])
  a.concat serialize_bin_string(Nem::Util::Convert.hex2ua(Nem::Util::Convert.utf8_to_hex(entity[:description])))
  a.concat serialize_properties(entity[:properties])
  a.concat serialize_levy(entity[:levy])
  serialize_int(a.size) + a
end

.serialize_mosaic_definition_creation(entity) ⇒ Object 



118
119
120
121
122
123
 
# File 'lib/nem/util/serializer.rb', line 118

def self.serialize_mosaic_definition_creation(entity)
  a = []
  a.concat serialize_mosaic_definition(entity[:mosaicDefinition])
  a.concat serialize_safe_string(entity[:creationFeeSink])
  a.concat serialize_long(entity[:creationFee])
end

.serialize_mosaic_id(entity) ⇒ Array 



205
206
207
208
209
210
 
# File 'lib/nem/util/serializer.rb', line 205

def self.serialize_mosaic_id(entity)
  a = []
  a.concat serialize_safe_string(entity[:namespaceId])
  a.concat serialize_safe_string(entity[:name])
  serialize_int(a.size) + a
end

.serialize_mosaic_supply_change(entity) ⇒ Object 



125
126
127
128
129
130
 
# File 'lib/nem/util/serializer.rb', line 125

def self.serialize_mosaic_supply_change(entity)
  a = []
  a.concat serialize_mosaic_id(entity[:mosaicId])
  a.concat serialize_int(entity[:supplyType])
  a.concat serialize_long(entity[:delta])
end

.serialize_mosaics(entities) ⇒ Array 



194
195
196
197
198
199
200
201
 
# File 'lib/nem/util/serializer.rb', line 194

def self.serialize_mosaics(entities)
  a = []
  a.concat serialize_int(entities.size)
  mosaics = entities.inject([]) do |memo, ent|
    memo.concat serialize_mosaic_attachment(ent)
  end
  a.concat mosaics
end

.serialize_multisig(entity) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/nem/util/serializer.rb', line 87

def self.serialize_multisig(entity)
  a = []
  trans = entity[:otherTrans]
  tx = case trans[:type]
       when 0x0101 then serialize_transfer(trans)
       when 0x0801 then serialize_importance_transfer(trans)
       when 0x1001 then serialize_multisig_aggregate_modification(trans)
    else raise "Unexpected type #{trans[:type]}"
  end
  tx = serialize_common(trans) + tx
  a.concat serialize_int(tx.size)
  a.concat tx
end

.serialize_multisig_aggregate_modification(entity) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/nem/util/serializer.rb', line 51

def self.serialize_multisig_aggregate_modification(entity)
  a = []
  a.concat serialize_int(entity[:modifications].size)
  mods = entity[:modifications].inject([]) do |b, mod|
    b.concat serialize_int(40)
    b.concat serialize_int(mod[:modificationType])
    b.concat serialize_int(32)
    b.concat Nem::Util::Convert.hex2ua(mod[:cosignatoryAccount])
    b
  end
  a.concat mods

  # The following part describes the minimum cosignatories modification.
  # The part is optional. Version 1 aggregate modification transactions should omit this part.
  # Version 2 aggregate modification transactions with no minimum cosignatories modification
  # should only write the length field with value 0x00, 0x00, 0x00, 0x00.
  if true # only version2
    if entity[:minCosignatories][:relativeChange] > 0
      a.concat serialize_int(4)
      a.concat serialize_int(entity[:minCosignatories][:relativeChange])
    else
      a.concat [0, 0, 0, 0]
    end
  end
  a
end

.serialize_multisig_signature(entity) ⇒ Object 



78
79
80
81
82
83
84
85
 
# File 'lib/nem/util/serializer.rb', line 78

def self.serialize_multisig_signature(entity)
  a = []
  temp = Nem::Util::Convert.hex2ua(entity[:otherHash][:data])
  a.concat serialize_int(4 + temp.size)
  a.concat serialize_int(temp.size)
  a.concat temp
  a.concat serialize_safe_string(entity[:otherAccount])
end

.serialize_properties(entities) ⇒ Array 



223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/nem/util/serializer.rb', line 223

def self.serialize_properties(entities)
  order = {
    'divisibility'  => 1,
    'initialSupply' => 2,
    'supplyMutable' => 3,
    'transferable'  => 4
  }
  serialize_int(entities.size) + entities
    .sort_by { |ent| order[ent[:name]] }
    .inject([]) { |memo, ent| memo + serialize_property(ent) }
end

.serialize_property(entity) ⇒ Array 



214
215
216
217
218
219
 
# File 'lib/nem/util/serializer.rb', line 214

def self.serialize_property(entity)
  a = []
  a.concat serialize_safe_string(entity[:name])
  a.concat serialize_safe_string(entity[:value])
  serialize_int(a.size) + a
end

.serialize_provision_namespace(entity) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/nem/util/serializer.rb', line 101

def self.serialize_provision_namespace(entity)
  a = []
  a.concat serialize_safe_string(entity[:rentalFeeSink])
  a.concat serialize_long(entity[:rentalFee])
  temp = Nem::Util::Convert.hex2ua(Nem::Util::Convert.utf8_to_hex(entity[:newPart]))
  a.concat serialize_int(temp.size)
  a.concat temp
  if entity[:parent]
    temp = Nem::Util::Convert.hex2ua(Nem::Util::Convert.utf8_to_hex(entity[:parent]))
    a.concat serialize_int(temp.size)
    a.concat temp
  else
    a.concat [255, 255, 255, 255]
  end
  a
end

.serialize_safe_string(str) ⇒ Array

Safe String - Each char is 8 bit



149
150
151
152
153
 
# File 'lib/nem/util/serializer.rb', line 149

def self.serialize_safe_string(str)
  return [255, 255, 255, 255] if str.nil?
  return [0, 0, 0, 0] if str.empty?
  [str.size, 0, 0, 0] + str.bytes
end

.serialize_transaction(entity) ⇒ Array

Serialize a transaction object



7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/nem/util/serializer.rb', line 7

def self.serialize_transaction(entity)
  specific = case entity[:type]
             when 0x0101 then serialize_transfer(entity)
             when 0x0801 then serialize_importance_transfer(entity)
             when 0x1001 then serialize_multisig_aggregate_modification(entity)
             when 0x1002 then serialize_multisig_signature(entity)
             when 0x1004 then serialize_multisig(entity)
             when 0x2001 then serialize_provision_namespace(entity)
             when 0x4001 then serialize_mosaic_definition_creation(entity)
             when 0x4002 then serialize_mosaic_supply_change(entity)
    else raise "Not implemented entity type: #{entity[:type]}"
  end
  serialize_common(entity) + specific
end

.serialize_transfer(entity) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/nem/util/serializer.rb', line 24

def self.serialize_transfer(entity)
  a = []
  a.concat serialize_safe_string(entity[:recipient])
  a.concat serialize_long(entity[:amount])
  payload = Nem::Util::Convert.hex2ua(entity[:message][:payload])
  if payload.size == 0
    a.concat [0, 0, 0, 0]
  else
    a.concat serialize_int(payload.size + 8)
    a.concat serialize_int(entity[:message][:type])
    a.concat serialize_int(payload.size)
    a.concat payload
  end
  if entity[:mosaics] && entity[:mosaics].size > 0
    a.concat serialize_mosaics(entity[:mosaics])
  end
  a
end