cryptoconditions_ruby 0.5.1

data/lib/cryptoconditions_ruby/types/threshold_sha_256_fulfillment.rb

@@ -0,0 +1,343 @@
+require 'duplicate'
+module CryptoconditionsRuby
+  module Types
+    CONDITION = 'condition'
+    FULFILLMENT = 'fulfillment'
+
+    class ThresholdSha256Fulfillment < BaseSha256Fulfillment
+      TYPE_ID = 2
+      FEATURE_BITMASK = 0x09
+
+      attr_accessor :bitmask, :threshold, :subconditions
+      private :bitmask
+      def initialize(threshold = nil)
+        if threshold && (!threshold.is_a?(Integer) || threshold < 1)
+          raise StandardError, "Threshold must be a integer greater than zero, was: #{threshold}"
+        end
+        self.threshold = threshold
+        self.subconditions = []
+      end
+
+      def add_subcondition(subcondition, weight = 1)
+        if subcondition.is_a?(String)
+          subcondition = Condition.from_uri(subcondition)
+        end
+        unless subcondition.is_a?(Condition)
+          raise TypeError, 'Subconditions must be URIs or objects of type Condition'
+        end
+        unless weight.is_a?(Integer) || weight < 1
+          raise StandardError, "Invalid weight: #{weight}"
+        end
+
+        subconditions.push(
+          'type' => CONDITION,
+          'body' => subcondition,
+          'weight' => weight
+        )
+      end
+
+      def add_subcondition_uri(subcondition_uri)
+        unless subcondition_uri.is_a?(String)
+          raise TypeError, "Subcondition must be provided as a URI string, was #{subcondition_uri}"
+        end
+
+        add_subcondition(Condition.from_uri(subcondition_uri))
+      end
+
+      def add_subfulfillment(subfulfillment, weight = 1)
+        if subfulfillment.is_a?(String)
+          subfulfillment = Fulfillment.from_uri(subfulfillment)
+        end
+        unless subfulfillment.is_a?(Fulfillment)
+          raise TypeError, 'Subfulfillments must be URIs or objects of type Fulfillment'
+        end
+        if !weight.is_a?(Integer) || weight < 0
+          raise StandardError, "Invalid weight: #{weight}"
+        end
+        subconditions.push(
+          'type' => FULFILLMENT,
+          'body' => subfulfillment,
+          'weight' => weight
+        )
+      end
+
+      def add_subfulfillment_uri(subfulfillment_uri)
+        unless subfulfillment_uri.is_a?(String)
+          raise TypeError, "Subfulfillment must be provided as a URI string, was: #{subfulfillment_uri}"
+        end
+        add_subfulfillment(Fulfillment.from_uri(subfulfillment_uri))
+      end
+
+      def bitmask
+        bitmask = super
+        subconditions.each do |cond|
+          bitmask |= cond['body'].bitmask
+        end
+        bitmask
+      end
+
+      def get_subcondition_from_vk(vk)
+        subconditions.inject([]) do |store, c|
+          if c['body'].is_a?(Ed25519Fulfillment) && Utils::Base58.encode(c['body'].public_key.to_s) == vk
+            store.push(c)
+          elsif c['body'].is_a?(ThresholdSha256Fulfillment)
+            result = c['body'].get_subcondition_from_vk(vk)
+            store += result if result
+          end
+          store
+        end
+      end
+
+      def write_hash_payload(hasher)
+        raise StandardError, 'Requires subconditions' if subconditions.empty?
+
+        _subconditions = subconditions.inject([]) do |store, c|
+          writer = Utils::Writer.new
+          writer.write_var_uint(c['weight'])
+          writer.write(
+            c['type'] == FULFILLMENT ? c['body'].condition_binary : c['body'].serialize_binary
+          )
+          store.push(writer.buffer)
+        end
+        sorted_subconditions = ThresholdSha256Fulfillment.sort_buffers(_subconditions)
+
+        hasher.write_uint32(threshold)
+        hasher.write_var_uint(sorted_subconditions.length)
+        sorted_subconditions.each do |cond|
+          hasher.write(cond)
+        end
+        hasher
+      end
+
+      def calculate_max_fulfillment_length
+        total_condition_len = 0
+
+        _subconditions = subconditions.map do |c|
+          condition_len = ThresholdSha256Fulfillment.predict_subcondition_length(c)
+          fulfillment_len = ThresholdSha256Fulfillment.predict_subfulfillment_length(c)
+          total_condition_len += condition_len
+          {
+            'weight' => c['weight'],
+            'size' => fulfillment_len - condition_len
+          }
+        end
+
+        _subconditions.sort_by! { |x| x['weight'].abs }
+
+        worst_case_fulfillments_length = total_condition_len + ThresholdSha256Fulfillment.calculate_worst_case_length(threshold, _subconditions)
+
+        if worst_case_fulfillments_length == -Float::INFINITY
+          raise StandardError, 'Insufficient subconditions/weights to meet the threshold'
+        end
+
+        # Calculate resulting total maximum fulfillment size
+        predictor = Utils::Predictor.new
+        predictor.write_uint32(threshold)
+        predictor.write_var_uint(subconditions.length)
+        subconditions.each do |c|
+          predictor.write_uint8(nil)
+          predictor.write_var_uint(c['weight']) unless c['weight'] == 1
+        end
+
+        predictor.skip(worst_case_fulfillments_length)
+
+        predictor.size
+      end
+
+      def self.predict_subcondition_length(cond)
+        return cond['body'].condition_binary.length if cond['type'] == FULFILLMENT
+
+        cond['body'].serialize_binary.length
+      end
+
+      def self.predict_subfulfillment_length(cond)
+        fulfillment_len = if cond['type'] == FULFILLMENT
+                            cond['body'].condition.max_fulfillment_length
+                          else
+                            cond['body'].max_fulfillment_length
+                          end
+
+        predictor = Utils::Predictor.new
+        predictor.write_uint16(nil)
+        predictor.write_var_octet_string('0' * fulfillment_len)
+        predictor.size
+      end
+
+      def self.calculate_worst_case_length(threshold, subconditions, index = 0)
+        return 0 if threshold <= 0
+        if index < subconditions.length
+          next_condition = subconditions[index]
+
+          [
+            next_condition['size'] + ThresholdSha256Fulfillment.calculate_worst_case_length(
+              threshold - next_condition['weight'].abs,
+              subconditions,
+              index + 1
+            ),
+            ThresholdSha256Fulfillment.calculate_worst_case_length(
+              threshold,
+              subconditions,
+              index + 1
+            )
+          ].max
+        else
+          -Float::INFINITY
+        end
+      end
+
+      def parse_payload(reader, *args)
+        raise TypeError, 'reader must be a Reader instance' unless reader.is_a?(Utils::Reader)
+
+        self.threshold = reader.read_var_uint
+        condition_count = reader.read_var_uint
+
+        condition_count.times do
+          weight = reader.read_var_uint
+          fulfillment = reader.read_var_octet_string
+          condition = reader.read_var_octet_string
+          if !fulfillment.empty? && !condition.empty?
+            raise TypeError, 'Subconditions may not provide both subcondition and fulfillment.'
+          elsif
+            if !fulfillment.empty?
+              add_subfulfillment(Fulfillment.from_binary(fulfillment), weight)
+            elsif !condition.empty?
+              add_subcondition(Condition.from_binary(condition), weight)
+            else
+              raise TypeError, 'Subconditions must provide either subcondition or fulfillment.'
+            end
+          end
+        end
+      end
+
+      def write_payload(writer)
+        raise TypeError, 'writer must be a Writer instance' unless writer.is_a?(Utils::Writer)
+
+        subfulfillments = subconditions.each_with_index.map do |c, i|
+          next unless c['type'] == FULFILLMENT
+
+          subfulfillment = c.dup
+          subfulfillment.merge!(
+            'index' => i,
+            'size' => c['body'].serialize_binary.length,
+            'omit_size' => c['body'].condition_binary.length
+          )
+        end.compact
+
+        smallest_set = ThresholdSha256Fulfillment.calculate_smallest_valid_fulfillment_set(
+          threshold, subfulfillments
+        )['set']
+
+        optimized_subfulfillments = subconditions.each_with_index.map do |c, i|
+          if c['type'] == FULFILLMENT && !smallest_set.include?(i)
+            subfulfillment = c.dup
+            subfulfillment.update(
+              'type' => CONDITION,
+              'body' => c['body'].condition
+            )
+          else
+            c
+          end
+        end
+
+        serialized_subconditions = optimized_subfulfillments.map do |c|
+          writer_ = Utils::Writer.new
+          writer_.write_var_uint(c['weight'])
+          writer_.write_var_octet_string(c['type'] == FULFILLMENT ? c['body'].serialize_binary : '')
+          writer_.write_var_octet_string(c['type'] == CONDITION ? c['body'].serialize_binary : '')
+          writer_.buffer
+        end
+
+        sorted_subconditions = ThresholdSha256Fulfillment.sort_buffers(serialized_subconditions)
+
+        writer.write_var_uint(threshold)
+        writer.write_var_uint(sorted_subconditions.length)
+        sorted_subconditions.each { |c| writer.write(c) }
+        writer
+      end
+
+      def self.calculate_smallest_valid_fulfillment_set(threshold, fulfillments, state = nil)
+        state ||= { 'index' => 0, 'size' => 0, 'set' => [] }
+
+        if threshold <= 0
+          { 'size' => state['size'], 'set' => state['set'] }
+        elsif state['index'] < fulfillments.length
+          next_fulfillment = fulfillments[state['index']]
+          with_next = ThresholdSha256Fulfillment.calculate_smallest_valid_fulfillment_set(
+            threshold - next_fulfillment['weight'].abs,
+            fulfillments,
+            'size' => state['size'] + next_fulfillment['size'],
+            'index' => state['index'] + 1,
+            'set' => state['set'] + [next_fulfillment['index']]
+          )
+
+          without_next = ThresholdSha256Fulfillment.calculate_smallest_valid_fulfillment_set(
+            threshold,
+            fulfillments,
+            'size' => state['size'] + next_fulfillment['omit_size'],
+            'index' => state['index'] + 1,
+            'set' => state['set']
+          )
+          with_next['size'] < without_next['size'] ? with_next : without_next
+        else
+          { 'size' => Float::INFINITY }
+        end
+      end
+
+      def self.sort_buffers(buffers)
+        Duplicate.duplicate(buffers).sort_by { |item| [item.length, item] }
+      end
+
+      def to_dict
+        subfulfillments = subconditions.map do |c|
+          subcondition = c['body'].to_dict
+          subcondition.merge!('weight' => c['weight'])
+        end
+
+        {
+          'type' => 'fulfillment',
+          'type_id' => type_id,
+          'bitmask' => bitmask,
+          'threshold' => threshold,
+          'subfulfillments' => subfulfillments
+        }
+      end
+
+      def parse_dict(data)
+        raise TypeError, 'reader must be a dict instance' unless data.is_a?(Hash)
+        self.threshold = data['threshold']
+
+        data['subfulfillments'].each do |subfulfillments|
+          weight = subfulfillments['weight']
+          if subfulfillments['type'] == FULFILLMENT
+            add_subfulfillment(Fulfillment.from_dict(subfulfillments), weight)
+          elsif subfulfillments['type'] == CONDITION
+            add_subcondition(Condition.from_dict(subfulfillments), weight)
+          else
+            raise TypeError, 'Subconditions must provide either subcondition or fulfillment.'
+          end
+        end
+      end
+
+      def validate(message: nil, **_kwargs)
+        fulfillments = subconditions.select { |c| c['type'] == FULFILLMENT }
+
+        min_weight = Float::INFINITY
+        total_weight = 0
+        fulfillments.each do |fulfillment|
+          min_weight = [min_weight, fulfillment['weight'].abs].max
+          total_weight += min_weight
+        end
+
+        # Total weight must meet the threshold
+        return if total_weight < threshold
+
+        valid_decisions = fulfillments.map do |fulfillment|
+          if fulfillment['body'].validate(message: message, **_kwargs)
+            [true] * fulfillment['weight']
+          end
+        end.compact.flatten
+        valid_decisions.count >= threshold
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/types/timeout_fulfillment.rb

@@ -0,0 +1,46 @@
+module CryptoconditionsRuby
+  TIMESTAMP_REGEX = /^\d{10}(\.\d+)?$/
+
+  module Types
+    class TimeoutFulfillment < PreimageSha256Fulfillment
+      TYPE_ID = 99
+      FEATURE_BITMASK = 0x09
+      REGEX = TIMESTAMP_REGEX
+
+      def self.timestamp(time)
+        format('%6f', time.to_f)
+      end
+
+      def initialize(expire_time = nil)
+        if expire_time.is_a?(String) && !expire_time.match(REGEX)
+          raise TypeError, "Expire time must be conform UTC unix time, was: #{expire_time}"
+        end
+        super if expire_time
+      end
+
+      def expire_time
+        preimage
+      end
+
+      def to_dict
+        {
+          'type' => 'fulfillment',
+          'type_id' => TYPE_ID,
+          'bitmask' => bitmask,
+          'expire_time' => expire_time
+        }
+      end
+
+      def parse_dict(data)
+        self.preimage = data['expire_time']
+      end
+
+      def validate(message: nil, now: nil, **_kwargs)
+        unless now || now.match(REGEX)
+          raise TypeError, "message must be of unix time format, was: #{message}"
+        end
+        now.to_f <= expire_time.to_f
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/utils/base16.rb

@@ -0,0 +1,28 @@
+module CryptoconditionsRuby
+  module Utils
+    class Base16
+      def self.encode(data)
+        ret = ''
+        data.each_char do |c|
+          ch = c.ord.to_s(16)
+          ch = '0' + ch if ch.size == 1
+          ret += ch
+        end
+        ret.upcase
+      end
+
+      def self.decode(data)
+        chars = ''
+        ret = ''
+        data.each_char do |c|
+          chars += c
+          if chars.size == 2
+            ret += chars.to_i(16).chr
+            chars = ''
+          end
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/utils/base58.rb

@@ -0,0 +1,53 @@
+module CryptoconditionsRuby
+  module Utils
+    class Base58
+      CHARS = %w(123456789 ABCDEFGHJKLMNPQRSTUVWXYZ abcdefghijkmnopqrstuvwxyz).freeze
+
+      def self.decoding_table
+        @decoding_table ||= generate_decoding_table
+      end
+
+      def self.generate_decoding_table
+        CHARS.join.split('').each_with_index.each_with_object({}) do |(c, i), store|
+          store[c] = i
+        end
+      end
+
+      def self.encoding_table
+        @encoding_table ||= decoding_table.invert
+      end
+
+      def self.encode(data)
+        cdata = data.unpack('C*')
+        vlong = cdata.inject(0) { |store, v| v + store * 256 }
+        result = ''
+        while vlong > 0
+          result += encoding_table[vlong % 58]
+          vlong /= 58
+        end
+        while cdata.first.zero?
+          result += '1'
+          cdata = cdata[1..-1]
+        end
+        result.reverse
+      end
+
+      def self.decode(data_string)
+        vlong = data_string.each_byte.inject(0) do |store, b|
+          store = decoding_table[b.chr] + (58 * store)
+          store
+        end
+        result = ''
+        while vlong > 0
+          result += (vlong % 256).chr
+          vlong /= 256
+        end
+        while data_string[0] == '1'
+          result += "\x00"
+          data_string = data_string[1..-1]
+        end
+        result.reverse
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/utils/byte_array.rb

@@ -0,0 +1,16 @@
+module CryptoconditionsRuby
+  module Utils
+    class ByteArray
+      include Enumerable
+
+      def initialize(string_or_array)
+        @original = string_or_array
+        @collection = string_or_array.is_a?(Array) ? string_or_array : string_or_array.bytes
+      end
+
+      def each
+        @collection.each
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/utils/bytes.rb

@@ -0,0 +1,13 @@
+class CryptoconditionsRuby::Utils::Bytes
+  attr_reader :bytes
+  private :bytes
+  def initialize(input)
+    @bytes = input.is_a?(Array) ? input : input.bytes
+  end
+
+  def to_i(base)
+    bytes.reverse.each_with_index.inject(0) do |store, (byte, index)|
+      store += byte * base**(index * 2)
+    end
+  end
+end

data/lib/cryptoconditions_ruby/utils/hasher.rb

@@ -0,0 +1,27 @@
+require 'digest'
+
+class CryptoconditionsRuby::Utils::Hasher < CryptoconditionsRuby::Utils::Writer
+  attr_reader :digest_instance
+  private :digest_instance
+
+  def initialize(algorithm)
+    if algorithm == 'sha256'
+      @digest_instance = Digest::SHA256.new
+    else
+      raise NotImplementedError
+    end
+    super()
+  end
+
+  def write(in_bytes)
+    digest_instance.update(in_bytes)
+  end
+
+  def digest
+    digest_instance.digest
+  end
+
+  def self.length(algorithm)
+    new(algorithm).digest.length
+  end
+end

data/lib/cryptoconditions_ruby/utils/hexlify.rb

@@ -0,0 +1,13 @@
+module CryptoconditionsRuby
+  module Utils
+    module Hexlify
+      def hexlify(msg)
+        msg.unpack('H*')[0]
+      end
+
+      def unhexlify(msg)
+        [msg].pack('H*')
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/utils/predictor.rb

@@ -0,0 +1,58 @@
+class CryptoconditionsRuby::Utils::Predictor
+  attr_accessor :size
+
+  def initialize
+    @size = 0
+  end
+
+  def write_uint(_value, length)
+    skip(length)
+  end
+
+  def write_var_uint(value)
+    return write_var_octet_string(value) if value.is_a?(String)
+    raise TypeError.new('UInt must be an integer') unless value.is_a?(Integer)
+    raise TypeError.new('UInt must be positive') unless value > 0
+
+    length_of_value = (sprintf('%02b', value).length / 8.0).ceil.to_i
+    buffer = (length_of_value - 1).times.map { 0 }.push(value).pack('C*')
+    write_var_octet_string(buffer)
+  end
+
+  def write_octet_string(_value, length)
+    skip(length)
+  end
+
+  def write_var_octet_string(value)
+    skip(1)
+    if value.length > 127
+      length_of_length = (sprintf('%02b', value.length).length / 8.0).ceil.to_i
+      skip(length_of_length)
+    end
+    skip(value.length)
+  end
+
+  def write(in_bytes)
+    self.size += in_bytes.length
+  end
+
+  def skip(byte_count)
+    self.size += byte_count
+  end
+
+  def write_uint8(value)
+    self.write_uint(value, 1)
+  end
+
+  def write_uint16(value)
+    self.write_uint(value, 2)
+  end
+
+  def write_uint32(value)
+    self.write_uint(value, 4)
+  end
+
+  def write_uint64(value)
+    self.write_uint(value, 8)
+  end
+end