auction-ruby-base 0.1.1

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,205 @@
+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.create_account
+    def self.provide_proof(attributes={})
+      make :provide_proof, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.create_lot
+    def self.create_lot(attributes={})
+      make :create_lot, attributes
+    end
+
+    def self.register_participant(attributes={})
+      make :register_participant, 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)
+      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.memo           = make_memo(attributes[:memo])
+        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.current_network_id + 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        ||= 100
+      self.memo       ||= Memo.new(:memo_none)
+      self.ext        ||= Stellar::Transaction::Ext.new 0
+    end
+
+    private
+    def self.make_memo(memo)
+      case memo
+      when Stellar::Memo ;
+        memo
+      when nil ;
+        nil
+      when Integer ;
+        Memo.new(:memo_id, memo)
+      when String ;
+        Memo.new(:memo_text, memo)
+      when Array ;
+        t, val = *memo
+        Memo.new(:"memo_#{t}", val)
+      else
+        raise ArgumentError, "Bad :memo"
+      end
+    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/spec/lib/stellar/account_flags_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Stellar::AccountFlags do
+  subject{ Stellar::AccountFlags }
+  let(:raw)    { 3 }
+  let(:result) { subject.parse_mask raw }
+
+  it "parses correctly" do
+    expect(subject.parse_mask(1)).to eq([Stellar::AccountFlags.auth_required_flag])
+    expect(subject.parse_mask(2)).to eq([Stellar::AccountFlags.auth_revocable_flag])
+    expect(subject.parse_mask(3)).to eq([Stellar::AccountFlags.auth_required_flag, Stellar::AccountFlags.auth_revocable_flag])
+  end
+
+  it "makes correctly" do
+    expect(subject.make_mask([Stellar::AccountFlags.auth_required_flag])).to eq(1)
+    expect(subject.make_mask([Stellar::AccountFlags.auth_revocable_flag])).to eq(2)
+    expect(subject.make_mask([Stellar::AccountFlags.auth_required_flag, Stellar::AccountFlags.auth_revocable_flag])).to eq(3)
+  end
+end

data/spec/lib/stellar/asset_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Stellar::Asset, ".native" do
+  it "returns a asset instance whose type is 'AssetType.asset_type_native'" do
+    expect(Stellar::Asset.native.type).to eq(Stellar::AssetType.asset_type_native)
+  end
+end
+
+describe Stellar::Asset, ".alphanum4" do
+  it "returns a asset instance whose type is 'AssetType.asset_type_credit_alphanum4'" do
+    result = Stellar::Asset.alphanum4("USD", Stellar::KeyPair.master)
+    expect(result.type).to eq(Stellar::AssetType.asset_type_credit_alphanum4)
+  end
+
+  it "pads the code to 4 bytes, padding on the right and with null bytes" do
+    result = Stellar::Asset.alphanum4("USD", Stellar::KeyPair.master)
+    expect(result.code).to eq("USD\x00")
+  end
+end
+
+describe Stellar::Asset, ".alphanum12" do
+  it "returns a asset instance whose type is 'AssetType.asset_type_credit_alphanum12'" do
+    result = Stellar::Asset.alphanum12("USD", Stellar::KeyPair.master)
+    expect(result.type).to eq(Stellar::AssetType.asset_type_credit_alphanum12)
+  end
+
+  it "pads the code to 12 bytes, padding on the right and with null bytes" do
+    result = Stellar::Asset.alphanum12("USD", Stellar::KeyPair.master)
+    expect(result.code).to eq("USD\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+  end
+end
+
+describe Stellar::Asset, "#code" do
+  it "returns the asset_code for either alphanum4 or alphanum12 assets" do
+    a4 = Stellar::Asset.alphanum4("USD", Stellar::KeyPair.master)
+    a12 = Stellar::Asset.alphanum12("USD", Stellar::KeyPair.master)
+
+    expect(a4.code.strip).to eq("USD")
+    expect(a12.code.strip).to eq("USD")
+  end
+
+  it "raises an error when called on a native asset" do
+    expect{ Stellar::Asset.native.code }.to raise_error(RuntimeError)
+  end
+end