open-core 0.3.0

data/lib/stellar/path_payment_result.rb

@@ -0,0 +1,17 @@
+module Stellar
+  class PathPaymentResult
+    # send_amount returns the actual amount paid for the corresponding
+    # PathPaymentOp to this result.
+    #
+    def send_amount
+      s = success!
+      return s.last.amount if s.offers.blank?
+
+      source_asset = s.offers.first.asset_bought
+      source_offers = s.offers.take_while{|o| o.asset_bought == source_asset}
+
+      source_offers.map(&:amount_bought).sum
+    end
+
+  end
+end

data/lib/stellar/price.rb

@@ -0,0 +1,32 @@
+module Stellar
+
+  # reopen class
+  class Price
+
+    MAX_PRECISION = (2**31) - 1
+
+    def self.from_f(number)
+      best_r = Util::ContinuedFraction.best_r(number, MAX_PRECISION)
+      new({
+        n: best_r.numerator,
+        d: best_r.denominator
+      })
+    end
+
+    def invert
+      self.class.new(n:d,d:n)
+    end
+
+    def to_f
+      n / d.to_f
+    end
+
+    def to_s
+      "#{n} / #{d}"
+    end
+
+    def inspect
+      "#<Stellar::Price #{self}>"
+    end
+  end
+end

data/lib/stellar/thresholds.rb

@@ -0,0 +1,39 @@
+module Stellar
+  class << Thresholds
+    COMPONENTS = [:master_weight, :low, :medium, :high]
+    VALID_RANGE = 0..255
+
+    def make(thresholds={})
+
+      # error if any of the needed components are not provided
+      if COMPONENTS.any?{|c| thresholds[c].blank? }
+        raise ArgumentError, "invalid thresholds hash, must have #{COMPONENTS.inspect} keys, had: #{thresholds.keys.inspect}"
+      end
+
+      # error if any of the needed components are not numbers 0 <= N <= 255
+      COMPONENTS.each do |c|
+        good = true
+
+        good &&= thresholds[c].is_a?(Fixnum)
+        good &&= VALID_RANGE.include? thresholds[c]
+
+        unless good
+          raise ArgumentError, "invalid #{c.inspect}, must be number in (0..255), got #{thresholds[c].inspect}"
+        end
+      end
+
+
+      thresholds.values_at(*COMPONENTS).pack("C*")
+    end
+
+    def parse(combined)
+      master_weight, low, medium, high = combined.unpack("C*")
+      {
+        master_weight: master_weight,
+        low:           low,
+        medium:        medium,
+        high:          high,
+      }
+    end
+  end
+end

data/lib/stellar/transaction.rb

@@ -0,0 +1,170 @@
+module Stellar
+  class Transaction
+
+    #
+    # @see  Stellar::Operation.payment
+    def self.payment(attributes={})
+      make :payment, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.path_payment
+    def self.path_payment(attributes={})
+      make :path_payment, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.create_account
+    def self.create_account(attributes={})
+      make :create_account, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.change_trust
+    def self.change_trust(attributes={})
+      make :change_trust, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.create_offer
+    def self.manage_offer(attributes={})
+      make :manage_offer, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.create_passive_offer
+    def self.create_passive_offer(attributes={})
+      make :create_passive_offer, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.set_options
+    def self.set_options(attributes={})
+      make :set_options, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.allow_trust
+    def self.allow_trust(attributes={})
+      make :allow_trust, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.account_merge
+    def self.account_merge(attributes={})
+      make :account_merge, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.inflation
+    def self.inflation(attributes={})
+      make :inflation, attributes
+    end
+
+    #
+    # Helper method to create a transaction with a single
+    # operation of the provided type.  See class methods
+    # on Stellar::Operation for available values for
+    # operation_type.
+    #
+    # @see  Stellar::Operation
+    #
+    # @param operation_type [Symbol] the operation to use
+    # @param attributes={} [Hash] attributes to use for both the transaction and the operation
+    #
+    # @return [Stellar::Transaction] the resulting transaction
+    def self.make(operation_type, attributes={})
+      for_account(attributes).tap do |result|
+        result.operations << Operation.send(operation_type, attributes)
+      end
+    end
+
+
+    #
+    # Helper method to create the skeleton of a transaction.
+    # The resulting transaction will have its source account,
+    # sequence, fee, min ledger and max ledger set.
+    #
+    #
+    # @param attributes={} [type] [description]
+    #
+    # @return [Stellar::Transaction] the resulting skeleton
+    def self.for_account(attributes={})
+      account  = attributes[:account]
+      sequence = attributes[:sequence]
+      fee      = attributes[:fee]
+
+      raise ArgumentError, "Bad :account" unless account.is_a?(KeyPair) && account.sign?
+      raise ArgumentError, "Bad :sequence #{sequence}" unless sequence.is_a?(Integer)
+      raise ArgumentError, "Bad :fee #{sequence}" if fee.present? && !fee.is_a?(Integer)
+
+      new.tap do |result|
+        result.seq_num        = sequence
+        result.fee            = fee
+        result.source_account = account.account_id
+        result.apply_defaults
+      end
+    end
+
+    def sign(key_pair)
+      key_pair.sign(hash)
+    end
+
+    def sign_decorated(key_pair)
+      key_pair.sign_decorated(hash)
+    end
+
+    def hash
+      Digest::SHA256.digest(signature_base)
+    end
+
+    # Returns the string of bytes that, when hashed, provide the value which
+    # should be signed to create a valid stellar transaciton signature
+    def signature_base
+      signature_base_prefix + to_xdr
+    end
+
+    def signature_base_prefix
+      val = Stellar::EnvelopeType.envelope_type_tx
+
+      Stellar::EnvelopeType.to_xdr(val)
+    end
+
+    def to_envelope(*key_pairs)
+      signatures = key_pairs.map(&method(:sign_decorated))
+
+      TransactionEnvelope.new({
+        :signatures => signatures,
+        :tx => self
+      })
+    end
+
+    def merge(other)
+      cloned = Marshal.load Marshal.dump(self)
+      cloned.operations += other.to_operations
+      cloned
+    end
+
+
+    #
+    # Extracts the operations from this single transaction,
+    # setting the source account on the extracted operations.
+    #
+    # Useful for merging transactions.
+    #
+    # @return [Array<Operation>] the operations
+    def to_operations
+      cloned = Marshal.load Marshal.dump(operations)
+      operations.each do |op|
+        op.source_account = self.source_account
+      end
+    end
+
+    def apply_defaults
+      self.operations ||= []
+      self.fee        ||= 10
+      self.memo       ||= Memo.new(:memo_none)
+      self.ext        ||= Stellar::Transaction::Ext.new 0
+    end
+  end
+end

data/lib/stellar/transaction_envelope.rb

@@ -0,0 +1,32 @@
+module Stellar
+  class TransactionEnvelope
+
+    # 
+    # Checks to ensure that every signature for the envelope is
+    # a valid signature of one of the provided `key_pairs`
+    # 
+    # NOTE: this does not do any authorization checks, which requires access to
+    # the current ledger state.
+    # 
+    # @param *key_pairs [Array<Stellar::KeyPair>] The key pairs to check the envelopes signatures against
+    # 
+    # @return [Boolean] true if all signatures are from the provided key_pairs and validly sign the tx's hash
+    def signed_correctly?(*key_pairs)
+      hash = tx.hash
+      return false if signatures.empty?
+
+      key_index = key_pairs.index_by(&:signature_hint)
+      
+      signatures.all? do |sig| 
+        key_pair = key_index[sig.hint]
+        break false if key_pair.nil?
+
+        key_pair.verify(sig.signature, hash)
+      end
+    end
+
+    def hash
+      Digest::SHA256.digest(to_xdr)
+    end
+  end
+end

data/lib/stellar/util/continued_fraction.rb

@@ -0,0 +1,96 @@
+module Stellar
+  module Util
+    class ContinuedFraction
+      MAX_PRECISION = (2**32) - 1
+      attr_reader :i
+      attr_reader :f
+
+      def self.best_r(number, max_precision=MAX_PRECISION)
+        cur_cf = new(number)
+
+        loop do
+          next_cf = cur_cf.extend()
+          cur_r   = cur_cf.to_r(max_precision)
+          next_r  = next_cf.to_r(max_precision)
+
+          break cur_r if cur_cf.done? || cur_r == next_r
+
+          cur_cf = next_cf
+        end
+
+        cur_cf.to_r(max_precision)
+      end
+
+      def initialize(val, parents=[])
+        @i       = val.floor
+        @f       = val - @i
+        @parents = parents
+      end
+
+      def to_a
+        @parents + [i]
+      end
+
+      def error(actual)
+        (actual - to_f).abs
+      end
+
+      def to_f
+        convergent = convergents.last
+        convergent.n / convergent.d.to_f
+      end
+
+      def convergents
+        return @convergents if defined? @convergents
+
+        c = [Fraction.new(0,1), Fraction.new(1,0)]
+        to_a.each_with_index do |a, i|
+          i = i + 2
+
+          h = a * c[i-1].n + c[i-2].n
+          k = a * c[i-1].d + c[i-2].d
+          c << Fraction.new(h,k)
+        end
+
+        @converegents = c[2..-1]
+      end
+
+      def to_r(max_precision=MAX_PRECISION)
+        fraction = convergents.take_while do |c|
+          c.n <= max_precision && c.d <= max_precision
+        end.last
+
+        Rational(fraction.n, fraction.d)
+      end
+
+      def done?
+        @f == 0
+      end
+
+      def extend(count=1)
+        result = self
+
+        count.times do
+          break if result.done?
+          result = ContinuedFraction.new(1 / result.f, result.to_a)
+        end
+
+        result
+      end
+
+      class Fraction 
+        attr_reader :n
+        attr_reader :d
+
+        def initialize(n,d)
+          @n = n
+          @d = d
+        end
+
+        def to_r
+          Rational(@n, @d)
+        end
+      end
+    end
+  end
+end

data/lib/stellar/util/strkey.rb

@@ -0,0 +1,43 @@
+module Stellar
+  module Util
+
+    require 'base32'
+    require 'digest/crc16_xmodem'
+
+    class StrKey
+
+      VERSION_BYTES = {
+        account_id: [ 6 << 3].pack("C"), # Base32-encodes to 'G...'
+        seed:       [18 << 3].pack("C"), # Base32-encodes to 'S...'
+      }
+
+      def self.check_encode(version, byte_str)
+        version_byte = VERSION_BYTES[version]
+        raise ArgumentError, "Invalid version: #{version}" if version_byte.blank?
+        payload = version_byte + byte_str.dup.force_encoding("BINARY")
+        check   = checksum(payload)
+        Base32.encode(payload + check)
+      end
+
+      def self.check_decode(expected_version, str)
+        decoded      = Base32.decode(str) rescue (raise ArgumentError, "Invalid base32 string")
+        version_byte = decoded[0]
+        payload      = decoded[1...-2]
+        check        = decoded[-2..-1]
+        version      = VERSION_BYTES.key(version_byte)
+
+        raise ArgumentError, "Unexpected version: #{version.inspect}" if version != expected_version
+        raise ArgumentError, "Invalid checksum" if check != checksum(decoded[0...-2])
+        payload
+      end
+
+      # return the "XModem CRC16" (CCITT-like, but with 0-init and MSB first)
+      # packed into a string in little-endian order
+      def self.checksum(bytes)
+        crc = Digest::CRC16XModem.checksum(bytes)
+        [crc].pack("S<")
+      end
+
+    end
+  end
+end

data/open-core.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stellar/base/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "open-core"
+  spec.version       = Stellar::Base::VERSION
+  spec.authors       = ["Stefan Buhrmester"]
+  spec.email         = ["buhrmi@gmail.com"]
+  spec.summary       = %q{Open core client library: XDR}
+  spec.homepage      = "https://github.com/open-core/open-core-ruby"
+  spec.license       = "Apache 2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["generated", "lib"]
+
+  spec.add_dependency "xdr", ">= 0.0.4"
+  spec.add_dependency "digest-crc"
+  spec.add_dependency "base32"
+  spec.add_dependency "rbnacl"
+  spec.add_dependency "rbnacl-libsodium", "~> 1.0.3"
+  spec.add_dependency "activesupport", "~> 4"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "xdrgen"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "octokit"
+  spec.add_development_dependency "netrc"
+  spec.add_development_dependency "yard"
+
+end