stellar-base 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be220a6f1b2170167a2d882bbe31bc1ea1b663fd
-  data.tar.gz: 3078d50d5aa5eebfce79687c3ed7dc99f56a2920
+  metadata.gz: 52b90527d5fbb20ee588ab94b7c0d86d84f66fce
+  data.tar.gz: 1258a60de1ae91d5c3e1cba5ef19c1ae49aa7e6b
 SHA512:
-  metadata.gz: 27a122fd0f53a8d0b3d187017f56a6ae712c10b9d51721c65c97fdee55f3fc37c33bc0910fbe62edb8216ec2390237747d2ac473b7488976081918b1163dcdfa
-  data.tar.gz: d87e8a4bd376b25cb66c8c517403769e1ba3ac95944d473c7725b4fb5ccd3f072fe814ede7ce926fda1291b23ac867e8d2a41b812db1ab81cf1bee6ba27ed69d
+  metadata.gz: 26926d0eeaedd8e4bbd453e232c7b72fe507a03f095f43c6afd2c052f32d7b5f5e10ca239294665a32cb8f9c0802fd43932de33398c4e5258bd1f66a80343521
+  data.tar.gz: a242c1f440a7ab985e48b9a4482a765c2cfd66dc25d2dc0966aebe7e4492d6822a7e178a50235e6f88d38e5cc4645dd46390ae262d1dffd6a610a61b120d0328

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+.DS_Store

data/lib/stellar-base.rb

@@ -14,12 +14,13 @@ Stellar.load_all!
 
 # extensions onto the generated files must be loaded manually, below
 
-require_relative './stellar/change_trust_op'
-require_relative './stellar/create_offer_op'
+require_relative './stellar/account_flags'
 require_relative './stellar/currency'
 require_relative './stellar/key_pair'
+require_relative './stellar/operation'
 require_relative './stellar/payment_op'
 require_relative './stellar/price'
 require_relative './stellar/transaction'
 require_relative './stellar/transaction_envelope'
-require_relative './stellar/util/base58'
+require_relative './stellar/util/base58'
+require_relative './stellar/util/continued_fraction'

data/lib/stellar/account_flags.rb

@@ -0,0 +1,19 @@
+module Stellar
+  class AccountFlags
+
+
+    # 
+    # Converts an array of Stellar::AccountFlags members into
+    # an Integer suitable for use in a SetOptionsOp.
+    # 
+    # @param flags=nil [Array<Stellar::AccountFlags>] the flags to combine
+    # 
+    # @return [Fixnum] the combined result
+    def self.make_mask(flags=nil)
+      flags ||= []
+
+      flags.map(&:value).inject(&:|) || 0
+    end
+
+  end
+end

data/lib/stellar/base/version.rb

@@ -1,5 +1,5 @@
 module Stellar
   module Base
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/lib/stellar/operation.rb

@@ -0,0 +1,206 @@
+module Stellar
+  class Operation
+
+
+    # 
+    # Construct a new Stellar::Operation from the provided
+    # source account and body
+    # 
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair] :source_account
+    # @option attributes [Stellar::Operation::Body] :body
+    # 
+    # @return [Stellar::Operation] the built operation
+    def self.make(attributes={})
+      source_account = attributes[:source_account]
+      body           = Stellar::Operation::Body.new(*attributes[:body])
+
+      op = Stellar::Operation.new(body:body)
+
+      if source_account
+        raise ArgumentError, "Bad :source_account" unless source_account.is_a?(Stellar::KeyPair)
+        op.source_account = source_account.public_key
+      end
+
+      return op
+    end
+
+
+    # 
+    # Helper method to create a valid PaymentOp, wrapped
+    # in the necessary XDR structs to be included within a 
+    # transactions `operations` array.
+    # 
+    # @see Stellar::Currency
+    # 
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair] :destination the receiver of the payment
+    # @option attributes [Array] :amount the amount to pay
+    # @option attributes [Array<Stellar::Currency>] :path the payment path to use
+    # 
+    # @return [Stellar::Operation] the built operation, containing a 
+    #                              Stellar::PaymentOp body
+    def self.payment(attributes={})
+      destination = attributes[:destination]
+      amount      = attributes[:amount]
+      path        = attributes[:path] || []
+      path        = path.map{|p| Stellar::Currency.send(*p)}
+
+      raise ArgumentError unless destination.is_a?(KeyPair)
+
+      op = PaymentOp.send(*amount)
+      op.destination = destination.public_key
+      op.path = path
+      op.apply_defaults
+
+      return make(attributes.merge({
+        body:[:payment, op]
+      }))
+    end
+
+    # 
+    # Helper method to create a valid ChangeTrustOp, wrapped
+    # in the necessary XDR structs to be included within a 
+    # transactions `operations` array.
+    # 
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::Currrency] :line the currency to trust
+    # @option attributes [Fixnum] :limit the maximum amount to trust
+    # 
+    # @return [Stellar::Operation] the built operation, containing a 
+    #                              Stellar::ChangeTrustOp body
+    def self.change_trust(attributes={})
+      line  = Currency.send(*attributes[:line])
+      limit = attributes[:limit]
+
+      raise ArgumentError, "Bad :limit #{limit}" unless limit.is_a?(Integer)
+
+      op = ChangeTrustOp.new(line: line, limit: limit)
+
+      return make(attributes.merge({
+        body:[:change_trust, op]
+      }))
+    end
+
+    def self.create_offer(attributes={})
+      taker_pays = Currency.send(*attributes[:taker_pays])
+      taker_gets = Currency.send(*attributes[:taker_gets])
+      amount     = attributes[:amount]
+      offer_id   = attributes[:offer_id] || 0
+      price      = Price.from_f(attributes[:price])
+
+      op = CreateOfferOp.new({
+        taker_pays: taker_pays, 
+        taker_gets: taker_gets,
+        amount:     amount,
+        price:      price,
+        offer_id:   offer_id
+      })
+      
+      return make(attributes.merge({
+        body:[:create_offer, op]
+      }))
+    end
+
+    # 
+    # Helper method to create a valid SetOptionsOp, wrapped
+    # in the necessary XDR structs to be included within a 
+    # transactions `operations` array.
+    # 
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair] :inflation_dest
+    # @option attributes [Array<Stellar::AccountFlags>] :set flags to set
+    # @option attributes [Array<Stellar::AccountFlags>] :clear flags to clear
+    # @option attributes [String] :thresholds
+    # @option attributes [Stellar::Signer] :signer
+    # 
+    # @return [Stellar::Operation] the built operation, containing a 
+    #                              Stellar::SetOptionsOp body
+    def self.set_options(attributes={})
+      op             = SetOptionsOp.new()
+      op.set_flags   = Stellar::AccountFlags.make_mask attributes[:set]
+      op.clear_flags = Stellar::AccountFlags.make_mask attributes[:clear]
+      op.thresholds  = attributes[:thresholds]
+      op.signer      = attributes[:signer]
+
+
+      inflation_dest = attributes[:inflation_dest]
+      if inflation_dest
+        raise ArgumentError, "Bad :inflation_dest" unless inflation_dest.is_a?(Stellar::KeyPair)
+        op.inflation_dest = inflation_dest.public_key
+      end
+
+            
+      return make(attributes.merge({
+        body:[:set_options, op]
+      }))
+    end
+
+    # 
+    # Helper method to create a valid AllowTrustOp, wrapped
+    # in the necessary XDR structs to be included within a 
+    # transactions `operations` array.
+    # 
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair]  :trustor
+    # @option attributes [Stellar::Currency] :currency
+    # 
+    # @return [Stellar::Operation] the built operation, containing a 
+    #                              Stellar::AllowTrustOp body
+    def self.allow_trust(attributes={})
+      op = AllowTrustOp.new()
+      
+      trustor   = attributes[:trustor]
+      authorize = attributes[:authorize]
+      currency  = Currency.send(*attributes[:currency])
+
+      raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Stellar::KeyPair)
+      raise ArgumentError, "Bad :authorize" unless authorize == !!authorize # check boolean
+      raise ArgumentError, "Bad :currency" unless currency.type == Stellar::CurrencyType.iso4217
+
+      op.trustor   = trustor.public_key
+      op.authorize = authorize
+      op.currency  = currency
+
+      return make(attributes.merge({
+        body:[:allow_trust, op]
+      }))
+    end
+
+    # 
+    # Helper method to create an account merge operation
+    # 
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair]  :destination
+    # 
+    # @return [Stellar::Operation] the built operation
+    def self.account_merge(attributes={})
+      destination = attributes[:destination]
+
+      raise ArgumentError, "Bad :destination" unless destination.is_a?(KeyPair)
+
+      # TODO: add source_account support
+      return make(attributes.merge({
+        body:[:account_merge, destination.public_key]
+      }))
+    end
+
+    # 
+    # Helper method to create an inflation operation
+    # 
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Integer]  :sequence
+    # 
+    # @return [Stellar::Operation] the built operation
+    def self.inflation(attributes={})
+      sequence = attributes[:sequence]
+
+      raise ArgumentError, "Bad :sequence #{sequence}" unless sequence.is_a?(Integer)
+
+      # TODO: add source_account support
+      return make(attributes.merge({
+        body:[:inflation, sequence]
+      }))
+    end
+  end
+end

data/lib/stellar/payment_op.rb

@@ -1,5 +1,5 @@
 module Stellar
-  PaymentOp.class_eval do
+  class PaymentOp
 
     def self.native(amount)
       currency = Stellar::Currency.new(:native)
@@ -29,10 +29,5 @@ module Stellar
       self.memo ||= ""
     end
 
-    def to_operation(source_account=nil)
-      body = Operation::Body.new(:payment, self)
-      Operation.new(source_account: source_account, body:body)
-    end
-
   end
 end

data/lib/stellar/price.rb

@@ -1,22 +1,15 @@
 module Stellar
-  Price.class_eval do
-    def self.from_f(number)
-      return new(n:0,d:0)  if number == 0.0
-
-      inverted = number > 0.0 
 
-      # normalize
-      number = 1.0 / number if inverted
+  # reopen class
+  class Price
 
-      # fractionalize
-      r = number.to_r
-      n = r.numerator
-      d = r.denominator
+    MAX_PRECISION = (2**31) - 1
 
-      # pricify
+    def self.from_f(number)
+      best_r = Util::ContinuedFraction.best_r(number, MAX_PRECISION)
       new({
-        n:inverted ? d : n, 
-        d:inverted ? n : d,
+        n: best_r.numerator,
+        d: best_r.denominator
       })
     end
 

data/lib/stellar/transaction.rb

@@ -1,64 +1,88 @@
 module Stellar
   Transaction.class_eval do
 
+    # 
+    # @see  Stellar::Operation.payment
     def self.payment(attributes={})
-      destination = attributes[:destination]
-      amount      = attributes[:amount]
-      path        = attributes[:path] || []
-      path        = path.map{|p| Stellar::Currency.send(*p)}
-
-      raise ArgumentError unless destination.is_a?(KeyPair)
-
-      for_account(attributes).tap do |result|
-        payment = PaymentOp.send(*amount)
-        payment.destination = destination.public_key
-        payment.path = path
-        payment.apply_defaults
-
-        result.operations = [payment.to_operation]
-      end
+      make :payment, attributes
     end
 
+    # 
+    # @see  Stellar::Operation.change_trust
     def self.change_trust(attributes={})
-      line  = Currency.send(*attributes[:line])
-      limit = attributes[:limit]
+      make :change_trust, attributes
+    end
 
-      raise ArgumentError, "Bad :limit #{limit}" unless limit.is_a?(Integer)
+    # 
+    # @see  Stellar::Operation.create_offer
+    def self.create_offer(attributes={})
+      make :create_offer, attributes
+    end
 
-      for_account(attributes).tap do |result|
-        details = ChangeTrustOp.new(line: line, limit: limit)
-        result.operations = [details.to_operation]
-      end
+    # 
+    # @see  Stellar::Operation.set_options
+    def self.set_options(attributes={})
+      make :set_options, attributes
     end
 
-    def self.create_offer(attributes={})
-      taker_pays = Currency.send(*attributes[:taker_pays])
-      taker_gets = Currency.send(*attributes[:taker_gets])
-      amount     = attributes[:amount]
-      offer_id   = attributes[:offer_id] || 0
-      price      = Price.from_f(attributes[:price])
+    # 
+    # @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|
-        details = CreateOfferOp.new({
-          taker_pays: taker_pays, 
-          taker_gets: taker_gets,
-          amount:     amount,
-          price:      price,
-          offer_id:   offer_id
-        })
-        result.operations = [details.to_operation]
+        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]
+      account  = attributes[:account]
+      sequence = attributes[:sequence]
+      max_fee  = attributes[:max_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 :max_fee #{sequence}" if max_fee.present? && !max_fee.is_a?(Integer)
 
       new.tap do |result|
         result.seq_num  = sequence
+        result.max_fee  = max_fee
         result.source_account  = account.public_key
         result.apply_defaults
       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/spec/lib/stellar/price_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Stellar::Price, "#from_f" do
+  subject{ Stellar::Price }
+  let(:seed){ 225571644875421139403973254661022579608 } #generated using Random.new
+  let(:random){ Random.new(seed) } 
+  let(:iterations){ ENV["SMOKE_ITERATIONS"].present? ? ENV["SMOKE_ITERATIONS"].to_i : 2000}
+
+  it "withstands a random smoke test" do
+    iterations.times do |i|
+      expected = random.rand
+      actual_p = subject.from_f(expected)
+      actual = actual_p.to_f
+
+      expect(actual).to be_within(0.000000001).of(actual)
+      expect(actual_p.n).to be <= Stellar::Price::MAX_PRECISION
+      expect(actual_p.d).to be <= Stellar::Price::MAX_PRECISION
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stellar-base
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Scott Fleckenstein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-27 00:00:00.000000000 Z
+date: 2015-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xdr
@@ -279,19 +279,21 @@ files:
 - generated/stellar/transaction_set.rb
 - generated/stellar/trust_line_entry.rb
 - lib/stellar-base.rb
+- lib/stellar/account_flags.rb
 - lib/stellar/base.rb
 - lib/stellar/base/version.rb
-- lib/stellar/change_trust_op.rb
-- lib/stellar/create_offer_op.rb
 - lib/stellar/currency.rb
 - lib/stellar/key_pair.rb
+- lib/stellar/operation.rb
 - lib/stellar/payment_op.rb
 - lib/stellar/price.rb
 - lib/stellar/transaction.rb
 - lib/stellar/transaction_envelope.rb
 - lib/stellar/util/base58.rb
+- lib/stellar/util/continued_fraction.rb
 - ruby-stellar-base.gemspec
 - spec/lib/stellar/key_pair_spec.rb
+- spec/lib/stellar/price_spec.rb
 - spec/lib/stellar/transaction_envelope_spec.rb
 - spec/lib/stellar/transaction_spec.rb
 - spec/lib/stellar/util/base58_spec.rb
@@ -336,6 +338,7 @@ specification_version: 4
 summary: 'Stellar client library: XDR'
 test_files:
 - spec/lib/stellar/key_pair_spec.rb
+- spec/lib/stellar/price_spec.rb
 - spec/lib/stellar/transaction_envelope_spec.rb
 - spec/lib/stellar/transaction_spec.rb
 - spec/lib/stellar/util/base58_spec.rb

data/lib/stellar/change_trust_op.rb

@@ -1,10 +0,0 @@
-module Stellar
-  ChangeTrustOp.class_eval do
-
-    def to_operation(source_account=nil)
-      body = Operation::Body.new(:change_trust, self)
-      Operation.new(source_account: source_account, body:body)
-    end
-    
-  end
-end

data/lib/stellar/create_offer_op.rb

@@ -1,10 +0,0 @@
-module Stellar
-  CreateOfferOp.class_eval do
-
-    def to_operation(source_account=nil)
-      body = Operation::Body.new(:create_offer, self)
-      Operation.new(source_account: source_account, body:body)
-    end
-    
-  end
-end