class CryptoconditionsRuby::Condition

Constants

MAX_FULFILLMENT_LENGTH
MAX_SAFE_BITMASK
REGEX
REGEX_STRICT
SUPPORTED_BITMASK

Attributes

bitmask[RW]
hash[RW]
max_fulfillment_length[RW]
type_id[RW]

Public Class Methods

from_binary(reader) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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

Public Instance Methods

parse_binary(reader) click to toggle source
# 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) click to toggle source
# 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() click to toggle source
# 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() click to toggle source
# 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() click to toggle source
# 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() click to toggle source
# 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