Class: CryptoconditionsRuby::Condition

Inherits:
Object
  • Object
show all
Extended by:
CryptoconditionsRuby::Crypto::Helpers
Includes:
CryptoconditionsRuby::Crypto::Helpers
Defined in:
lib/cryptoconditions_ruby/condition.rb

Constant Summary collapse

MAX_SAFE_BITMASK = 
0xffffffff
SUPPORTED_BITMASK = 
0x3f
MAX_FULFILLMENT_LENGTH = 
65_535
REGEX = 
CONDITION_REGEX
REGEX_STRICT = 
CONDITION_REGEX_STRICT

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from CryptoconditionsRuby::Crypto::Helpers

base64_add_padding, base64_remove_padding, ed25519_generate_key_pair

Instance Attribute Details

#bitmask ⇒ Object

Returns the value of attribute bitmask.



19
20
21
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 19

def bitmask
  @bitmask
end

#hash ⇒ Object

Returns the value of attribute hash.

Raises:

  • (TypeError) 


19
20
21
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 19

def hash
  @hash
end

#max_fulfillment_length ⇒ Object

Returns the value of attribute max_fulfillment_length.

Raises:

  • (TypeError) 


19
20
21
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 19

def max_fulfillment_length
  @max_fulfillment_length
end

#type_id ⇒ Object

Returns the value of attribute type_id.



19
20
21
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 19

def type_id
  @type_id
end

Class Method Details

.from_binary(reader) ⇒ Object 



44
45
46
47
48
49
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 44

def self.from_binary(reader)
  reader = Utils::Reader.from_source(reader)
  new.tap do |condition|
    condition.parse_binary(reader)
  end
end

.from_dict(data) ⇒ Object 



51
52
53
54
55
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 51

def self.from_dict(data)
  new.tap do |condition|
    condition.parse_dict(data)
  end
end

.from_uri(serialized_condition) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 21

def self.from_uri(serialized_condition)
  return serialized_condition if serialized_condition.is_a?(Condition)
  unless serialized_condition.is_a?(String)
    raise TypeError, 'Serialized condition must be a string'
  end

  pieces = serialized_condition.split(':')
  unless pieces.first == 'cc'
    raise TypeError, 'Serialized condition must start with "cc:"'
  end

  unless serialized_condition.match(CONDITION_REGEX_STRICT)
    raise TypeError, 'Invalid condition format'
  end

  new.tap do |condition|
    condition.type_id = pieces[1].to_i(16)
    condition.bitmask = pieces[2].to_i(16)
    condition.hash = Base64.urlsafe_decode64(base64_add_padding(pieces[3]))
    condition.max_fulfillment_length = pieces[4].to_i
  end
end

Instance Method Details

#parse_binary(reader) ⇒ Object 



86
87
88
89
90
91
92
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 86

def parse_binary(reader)
  self.type_id = reader.read_uint16
  self.bitmask = reader.read_var_uint

  self.hash = reader.read_var_octet_string
  self.max_fulfillment_length = reader.read_var_uint
end

#parse_dict(data) ⇒ Object 



104
105
106
107
108
109
110
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 104

def parse_dict(data)
  self.type_id = data['type_id']
  self.bitmask = data['bitmask']

  self.hash = Utils::Base58.decode(data['hash'])
  self.max_fulfillment_length = data['max_fulfillment_length']
end

#serialize_binary ⇒ Object 



77
78
79
80
81
82
83
84
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 77

def serialize_binary
  writer = Utils::Writer.new
  writer.write_uint16(type_id)
  writer.write_var_uint(bitmask)
  writer.write_var_octet_string(hash)
  writer.write_var_uint(max_fulfillment_length)
  writer.buffer
end

#serialize_uri ⇒ Object 



67
68
69
70
71
72
73
74
75
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 67

def serialize_uri
  format(
    'cc:%x:%x:%s:%s',
    type_id,
    bitmask,
    base64_remove_padding(Base64.urlsafe_encode64(hash)),
    max_fulfillment_length
  )
end

#to_dict ⇒ Object 



94
95
96
97
98
99
100
101
102
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 94

def to_dict
  {
    'type' => 'condition',
    'type_id' => type_id,
    'bitmask' => bitmask,
    'hash' => Utils::Base58.encode(hash),
    'max_fulfillment_length' => max_fulfillment_length
  }
end

#validate ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/cryptoconditions_ruby/condition.rb', line 112

def validate
  TypeRegistry.get_class_from_type_id(type_id)

  if bitmask > Condition::MAX_SAFE_BITMASK
    raise StandardError, 'Bitmask too large to be safely represented'
  end

  if bitmask & ~Condition::SUPPORTED_BITMASK
    raise StandardError, 'Condition requested unsupported feature suites'
  end

  if max_fulfillment_length > Condition::MAX_FULFILLMENT_LENGTH
    raise StandardError, 'Condition requested too large of a max fulfillment size'
  end
  true
end