cryptoconditions_ruby 0.5.1

data/lib/cryptoconditions_ruby/utils/reader.rb

@@ -0,0 +1,167 @@
+class CryptoconditionsRuby::Utils::Reader
+  HIGH_BIT = 0x80
+  LOWER_SEVEN_BITS = 0x7F
+  MAX_INT_BYTES = 6
+
+  attr_accessor :bookmarks, :buffer, :cursor
+  def initialize(buffer)
+    @buffer = buffer
+    @cursor = 0
+    @bookmarks = []
+  end
+
+  def self.from_source(source)
+    source.is_a?(self) ? source : new(source)
+  end
+
+  def bookmark
+    self.bookmarks << cursor
+  end
+
+  def restore
+    self.cursor = bookmarks.pop
+  end
+
+  def ensure_available(num_bytes)
+    if buffer.length < cursor + num_bytes
+      raise RangeError.new("Tried to read #{num_bytes} bytes, but only #{buffer.length - cursor} bytes available")
+    end
+  end
+
+  def read_uint(length, peek: false)
+    if length > MAX_INT_BYTES
+      raise RangeError.new("Tried to read too large integer (requested: #{length}, max: #{MAX_INT_BYTES})")
+    end
+    ensure_available(length)
+    value = buffer[cursor...(cursor + length)]
+    self.cursor += length unless peek
+    CryptoconditionsRuby::Utils::Bytes.new(value).to_i(16)
+  end
+
+  def peek_uint(length)
+    read_uint(length, peek: true)
+  end
+
+  def skip_uint(length)
+    skip(length)
+  end
+
+  def read_var_uint
+    buffer = read_var_octet_string
+    if buffer.length > MAX_INT_BYTES
+      raise RangeError.new("UInt of length #{butter.length} too large to parse as integer(#{MAX_INT_BYTES})")
+    end
+    value = buffer[0...buffer.length]
+    CryptoconditionsRuby::Utils::Bytes.new(value).to_i(16)
+  end
+
+  def peek_var_uint
+    bookmark
+    read_var_uint.tap { restore }
+  end
+
+  def skip_var_uint
+    skip_var_octet_string
+  end
+
+  def read_octet_string(length)
+    read(length)
+  end
+
+  def peek_octet_string(length)
+    peek(length)
+  end
+
+  def skip_octet_string(length)
+    skip(length)
+  end
+
+  def read_length_prefix
+    length = read_uint8
+
+    if length & HIGH_BIT > 0
+      return read_uint(length & LOWER_SEVEN_BITS)
+    end
+    length
+  end
+
+  def read_var_octet_string
+    length = read_length_prefix
+    read(length)
+  end
+
+  def peek_var_octet_string
+    bookmark
+    read_var_octet_string.tap { restore }
+  end
+
+  def skip_var_octet_string
+    length = read_length_prefix
+    skip(length)
+  end
+
+  def read(num_bytes, peek: false)
+    ensure_available(num_bytes)
+
+    value = buffer[cursor...(cursor + num_bytes)]
+    self.cursor += num_bytes unless peek
+    value
+  end
+
+  def peek(num_bytes)
+    read(num_bytes, peek: true)
+  end
+
+  def skip(num_bytes)
+    ensure_available(num_bytes)
+    self.cursor += num_bytes
+  end
+
+  def read_uint8
+    read_uint(1)
+  end
+
+  def read_uint16
+    read_uint(2)
+  end
+
+  def read_uint32
+    read_uint(4)
+  end
+
+  def read_uint64
+    read_uint(8)
+  end
+
+  def peek_uint8
+    peek_uint(1)
+  end
+
+  def peek_uint16
+    peek_uint(2)
+  end
+
+  def peek_uint32
+    peek_uint(4)
+  end
+
+  def peek_uint64
+    peek_uint(8)
+  end
+
+  def skip_uint8
+    skip_uint(1)
+  end
+
+  def skip_uint16
+    skip_uint(2)
+  end
+
+  def skip_uint32
+    skip_uint(4)
+  end
+
+  def skip_uint64
+    skip_uint(8)
+  end
+end

data/lib/cryptoconditions_ruby/utils/writer.rb

@@ -0,0 +1,81 @@
+module CryptoconditionsRuby
+  module Utils
+    class Writer
+      attr_accessor :components
+      def initialize
+        @components = []
+      end
+
+      def write_uint(value, length)
+        raise TypeError.new('UInt must be an integer') unless value.is_a?(Integer)
+        raise TypeError.new('UInt must be positive') unless value >= 0
+        raise TypeError.new("UInt '#{value}' does not fit in '#{length}' bytes") if sprintf('%02b', value).length > length * 8
+
+        _buffer = (length - 1).times.map { 0 }.push(value).pack('C*')
+        write(_buffer)
+      end
+
+      def write_var_uint(value)
+        if value.is_a?(String)
+          write_var_octet_string(value)
+        else
+          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
+      end
+
+      def write_octet_string(_buffer, length)
+        raise TypeError, '_buffer must be an array of bytes' unless _buffer.respond_to?(:bytes)
+        raise ArgumentError, "Incorrect length for octet string (actual: #{_buffer.length}, expected: #{length})" unless _buffer.length == length
+
+        write(_buffer)
+      end
+
+      def write_var_octet_string(_buffer)
+        msb = 0x80
+        if _buffer.length <= 127
+          write_uint8(_buffer.length)
+        else
+          length_of_length = (format('%02b', _buffer.length).length / 8.0).ceil.to_i
+          write_uint8(msb | length_of_length)
+          write_uint(_buffer.length, length_of_length)
+        end
+        write(_buffer)
+      end
+
+      def write(in_bytes)
+        components.push(in_bytes)
+      end
+
+      def buffer
+        components.join
+      end
+
+      def write_uint8(value)
+        write_uint(value, 1)
+      end
+
+      def write_uint16(value)
+        write_uint(value, 2)
+      end
+
+      def write_uint32(value)
+        write_uint(value, 4)
+      end
+
+      def write_uint64(value)
+        write_uint(value, 8)
+      end
+
+      private
+
+      def write_out(in_bytes)
+        ByteArray.new(in_bytes).map { |x| format('%02x', x) }.join
+      end
+    end
+  end
+end

data/lib/cryptoconditions_ruby/version.rb

@@ -0,0 +1,3 @@
+module CryptoconditionsRuby
+  VERSION = '0.5.1'.freeze
+end

data/lib/cryptoconditions_ruby.rb

@@ -0,0 +1,28 @@
+require 'cryptoconditions_ruby/version'
+
+module CryptoconditionsRuby
+  module Utils
+    autoload :Writer, 'cryptoconditions_ruby/utils/writer'
+    autoload :Hasher, 'cryptoconditions_ruby/utils/hasher'
+    autoload :Predictor, 'cryptoconditions_ruby/utils/predictor'
+    autoload :Reader, 'cryptoconditions_ruby/utils/reader'
+    autoload :Bytes, 'cryptoconditions_ruby/utils/bytes'
+    autoload :Base58, 'cryptoconditions_ruby/utils/base58'
+    autoload :Base16, 'cryptoconditions_ruby/utils/base16'
+    autoload :Hexlify, 'cryptoconditions_ruby/utils/hexlify'
+    autoload :ByteArray, 'cryptoconditions_ruby/utils/byte_array'
+  end
+  module Types
+    autoload :BaseSha256Fulfillment, 'cryptoconditions_ruby/types/base_sha_256_fulfillment'
+    autoload :InvertedThresholdSha256Fulfillment, 'cryptoconditions_ruby/types/inverted_threshold_sha_256_fulfillment'
+    autoload :PreimageSha256Fulfillment, 'cryptoconditions_ruby/types/preimage_sha_256_fulfillment'
+    autoload :TimeoutFulfillment, 'cryptoconditions_ruby/types/timeout_fulfillment'
+    autoload :Ed25519Fulfillment, 'cryptoconditions_ruby/types/ed25519_fulfillment'
+    autoload :ThresholdSha256Fulfillment, 'cryptoconditions_ruby/types/threshold_sha_256_fulfillment'
+  end
+  autoload :TypeRegistry, 'cryptoconditions_ruby/type_registry'
+  autoload :Crypto, 'cryptoconditions_ruby/crypto'
+  autoload :Fulfillment, 'cryptoconditions_ruby/fulfillment'
+  autoload :Condition, 'cryptoconditions_ruby/condition'
+  autoload :Exceptions, 'cryptoconditions_ruby/exceptions'
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: cryptoconditions_ruby
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- Adam Groves
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbnacl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+- !ruby/object:Gem::Dependency
+  name: base32
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+- !ruby/object:Gem::Dependency
+  name: duplicate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.48'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.48'
+description: Cryptoconditions gem based on the python cryptoconditions library
+email:
+- adam.groves@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cryptoconditions_ruby.gemspec
+- lib/cryptoconditions_ruby.rb
+- lib/cryptoconditions_ruby/condition.rb
+- lib/cryptoconditions_ruby/crypto.rb
+- lib/cryptoconditions_ruby/exceptions.rb
+- lib/cryptoconditions_ruby/fulfillment.rb
+- lib/cryptoconditions_ruby/type_registry.rb
+- lib/cryptoconditions_ruby/types/base_sha_256_fulfillment.rb
+- lib/cryptoconditions_ruby/types/ed25519_fulfillment.rb
+- lib/cryptoconditions_ruby/types/inverted_threshold_sha_256_fulfillment.rb
+- lib/cryptoconditions_ruby/types/preimage_sha_256_fulfillment.rb
+- lib/cryptoconditions_ruby/types/threshold_sha_256_fulfillment.rb
+- lib/cryptoconditions_ruby/types/timeout_fulfillment.rb
+- lib/cryptoconditions_ruby/utils/base16.rb
+- lib/cryptoconditions_ruby/utils/base58.rb
+- lib/cryptoconditions_ruby/utils/byte_array.rb
+- lib/cryptoconditions_ruby/utils/bytes.rb
+- lib/cryptoconditions_ruby/utils/hasher.rb
+- lib/cryptoconditions_ruby/utils/hexlify.rb
+- lib/cryptoconditions_ruby/utils/predictor.rb
+- lib/cryptoconditions_ruby/utils/reader.rb
+- lib/cryptoconditions_ruby/utils/writer.rb
+- lib/cryptoconditions_ruby/version.rb
+homepage: https://github.com/LicenseRocks/cryptoconditions_ruby
+licenses:
+- Apache License 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Cryptoconditions for Ruby
+test_files: []