stellar-base 0.23.1 → 0.27.0

data/lib/stellar/price.rb

@@ -4,7 +4,12 @@ module Stellar
     MAX_PRECISION = (2**31) - 1
 
     def self.from_f(number)
-      best_r = Util::ContinuedFraction.best_r(number, MAX_PRECISION)
+      best_r = number.to_r.rationalize(1.0e-7)
+
+      if best_r.numerator > MAX_PRECISION || best_r.denominator > MAX_PRECISION
+        raise ArgumentError("Couldn't find price approximation")
+      end
+
       new({
         n: best_r.numerator,
         d: best_r.denominator
@@ -15,8 +20,12 @@ module Stellar
       self.class.new(n: d, d: n)
     end
 
+    def to_d
+      n.to_d / d
+    end
+
     def to_f
-      n / d.to_f
+      n.to_f / d
     end
 
     def to_s

data/lib/stellar/transaction.rb

@@ -2,174 +2,6 @@ module Stellar
   class Transaction
     include Stellar::Concerns::Transaction
 
-    class << self
-      #
-      # @see  Stellar::Operation.payment
-      def payment(attributes = {})
-        make :payment, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.path_payment
-      def path_payment(attributes = {})
-        make :path_payment, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.path_payment_strict_receive
-      def path_payment_strict_receive(attributes = {})
-        make :path_payment_strict_receive, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.path_payment_strict_send
-      def path_payment_strict_send(attributes = {})
-        make :path_payment_strict_send, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.create_account
-      def create_account(attributes = {})
-        make :create_account, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.change_trust
-      def change_trust(attributes = {})
-        make :change_trust, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.manage_sell_offer
-      def manage_sell_offer(attributes = {})
-        make :manage_sell_offer, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.manage_buy_offer
-      def manage_buy_offer(attributes = {})
-        make :manage_buy_offer, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.create_passive_sell_offer
-      def create_passive_sell_offer(attributes = {})
-        make :create_passive_sell_offer, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.set_options
-      def set_options(attributes = {})
-        make :set_options, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.allow_trust
-      def allow_trust(attributes = {})
-        make :allow_trust, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.account_merge
-      def account_merge(attributes = {})
-        make :account_merge, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.inflation
-      def inflation(attributes = {})
-        make :inflation, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.manage_data
-      def manage_data(attributes = {})
-        make :manage_data, attributes
-      end
-
-      #
-      # @see  Stellar::Operation.manage_data
-      def bump_sequence(attributes = {})
-        make :bump_sequence, attributes
-      end
-
-      #
-      # DEPRECATED
-      #
-      # All methods calling make() have been deprecated in favor of Stellar::TransactionBuilder.
-      # These functions only create single-operation transactions and essentially duplicate the
-      # methods provided by Stellar::Operation. Stellar::TransactionBuilder enables the construction
-      # of multi-operation transactions and mirrors the functionality provided by the Python and
-      # JavaScript SDKs.
-      #
-      # 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 make(operation_type, attributes = {})
-        Stellar::Deprecation.warn(
-          "Transaction.#{operation_type} is deprecated. Use Stellar::TransactionBuilder instead."
-        )
-        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 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.muxed_account
-          result.apply_defaults
-        end
-      end
-
-      private
-
-      def 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
-
     def to_v0
       ed25519 = if source_account.switch == Stellar::CryptoKeyType.key_type_ed25519
         source_account.ed25519!
@@ -197,7 +29,7 @@ module Stellar
     end
 
     def to_envelope(*key_pairs)
-      signatures = (key_pairs || []).map(&method(:sign_decorated))
+      signatures = key_pairs.map(&method(:sign_decorated))
 
       TransactionEnvelope.v1(signatures: signatures, tx: self)
     end

data/lib/stellar/transaction_builder.rb

@@ -2,12 +2,34 @@ module Stellar
   class TransactionBuilder
     attr_reader :source_account, :sequence_number, :base_fee, :time_bounds, :memo, :operations
 
+    class << self
+      # This enable user to call shortcut methods, like
+      # TransactionBuilder.payment(...),
+      # TransactionBuilder.manage_data(...) and etc.
+      # It reduces the boilerplate, when you just need to
+      # shoot a single operation in transaction
+      def method_missing(method_name, *args, **kwargs)
+        unless Stellar::Operation.respond_to?(method_name)
+          return super
+        end
+
+        op = Stellar::Operation.send(method_name, **kwargs)
+
+        new(**kwargs).add_operation(op).build
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        Stellar::Operation.respond_to?(method_name) || super
+      end
+    end
+
     def initialize(
       source_account:,
       sequence_number:,
       base_fee: 100,
       time_bounds: nil,
-      memo: nil
+      memo: nil,
+      **_ # ignore any additional parameters without errors
     )
       raise ArgumentError, "Bad :source_account" unless source_account.is_a?(Stellar::KeyPair)
       raise ArgumentError, "Bad :sequence_number" unless sequence_number.is_a?(Integer) && sequence_number >= 0
@@ -18,6 +40,11 @@ module Stellar
       @sequence_number = sequence_number
       @base_fee = base_fee
       @time_bounds = time_bounds
+
+      if time_bounds.nil?
+        set_timeout(0)
+      end
+
       @memo = make_memo(memo)
       @operations = []
     end
@@ -47,7 +74,6 @@ module Stellar
     end
 
     def build_fee_bump(inner_txe:)
-      p inner_txe.switch
       if inner_txe.switch == Stellar::EnvelopeType.envelope_type_tx_v0
         inner_txe = Stellar::TransactionEnvelope.v1(tx: inner_txe.tx.to_v1, signatures: inner_txe.signatures)
       elsif inner_txe.switch != Stellar::EnvelopeType.envelope_type_tx

data/lib/stellar/transaction_envelope.rb

@@ -1,39 +1,7 @@
 module Stellar
   class TransactionEnvelope
-    class << self
-      def v0(tx:, signatures:)
-        v0_envelope = TransactionV0Envelope.new(tx: tx, signatures: signatures)
-        new(:envelope_type_tx_v0, v0_envelope)
-      end
-
-      def v1(tx:, signatures:)
-        v1_envelope = TransactionV1Envelope.new(tx: tx, signatures: signatures)
-        new(:envelope_type_tx, v1_envelope)
-      end
-
-      def fee_bump(tx:, signatures:)
-        fee_bump_envelope = FeeBumpTransactionEnvelope.new(tx: tx, signatures: signatures)
-        new(:envelope_type_tx_fee_bump, fee_bump_envelope)
-      end
-    end
-
-    # Delegates any undefined method to the currently set arm
-    def method_missing(method, *args, &block)
-      case switch
-      when EnvelopeType.envelope_type_tx_v0
-        v0!.public_send(method, *args)
-      when EnvelopeType.envelope_type_tx
-        v1!.public_send(method, *args)
-      when EnvelopeType.envelope_type_tx_fee_bump
-        fee_bump!.public_send(method, *args)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      ["tx", "signatures"].include?(method) || super
-    end
+    delegate :tx, :signatures, to: :value
+    delegate :hash, to: :tx
 
     # Checks to ensure that every signature for the envelope is
     # a valid signature of one of the provided `key_pairs`
@@ -41,27 +9,23 @@ module Stellar
     # 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
+    # @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)
+      tx_hash = tx.hash
+      keys_by_hint = key_pairs.index_by(&:signature_hint)
 
       signatures.all? do |sig|
-        key_pair = key_index[sig.hint]
+        key_pair = keys_by_hint[sig.hint]
         break false if key_pair.nil?
 
-        key_pair.verify(sig.signature, hash)
+        key_pair.verify(sig.signature, tx_hash)
       end
     end
 
-    def hash
-      Digest::SHA256.digest(to_xdr)
-    end
-
     def merge(other)
       merged_tx = tx.merge(other.tx)
       merged_tx.signatures = [signatures, other.signatures]

data/lib/stellar/transaction_v0.rb

@@ -3,15 +3,7 @@ module Stellar
     include Stellar::Concerns::Transaction
 
     def to_v1
-      Transaction.new(
-        source_account: Stellar::MuxedAccount.new(:key_type_ed25519, source_account),
-        seq_num: seq_num,
-        operations: operations,
-        fee: fee,
-        memo: memo,
-        time_bounds: time_bounds,
-        ext: ext
-      )
+      Transaction.new(**attributes.except(:source_account_ed25519), source_account: source_account)
     end
 
     def to_envelope(*key_pairs)
@@ -45,7 +37,7 @@ module Stellar
     end
 
     def source_account
-      source_account_ed25519
+      Stellar::MuxedAccount.ed25519(source_account_ed25519)
     end
   end
 end

data/lib/stellar/trust_line_flags.rb

@@ -0,0 +1,53 @@
+module Stellar
+  class TrustLineFlags
+    # Converts an array of Stellar::TrustLineFlags members into
+    # an integers suitable for use in in a SetTrustLineFlagsOp.
+    #
+    # @param flags [Array<Stellar::TrustLineFlags>] the flags to combine
+    #
+    # @return [Fixnum] the combined result
+    def self.make_mask(flags)
+      normalize(flags).map(&:value).inject(&:|) || 0
+    end
+
+    # Converts an integer used in SetTrustLineFlagsOp on the set/clear flag options
+    # into an array of Stellar::TrustLineFlags members
+    #
+    #  @param combined [Fixnum]
+    #  @return [Array<Stellar::AccountFlags>]
+    def self.parse_mask(combined)
+      members.values.select { |m| (m.value & combined) != 0 }
+    end
+
+    # Converts each element of the input array to Stellar::TrustLineFlags instance.
+    #
+    # @param [Array<Stellar::TrustLineFlags,Symbol,#to_s>] input
+    # @return [Array<Stellar::TrustLineFlags>]
+    # @raise [TypeError] if any element of the input cannot be converted
+    def self.normalize(input)
+      input.map do |val|
+        case val
+        when Stellar::TrustLineFlags
+          val
+        when ->(_) { members.key?(val.to_s) }
+          from_name(val.to_s)
+        when ->(_) { members.key?("#{val}_flag") }
+          from_name("#{val}_flag")
+        else
+          raise TypeError, "unknown trustline flag: #{val}"
+        end
+      end
+    end
+
+    def self.set_clear_masks(flags)
+      set_flags = []
+      clear_flags = []
+
+      Hash(flags).each do |flag, value|
+        value.present? ? set_flags.push(flag) : clear_flags.push(flag)
+      end
+
+      {set_flags: make_mask(set_flags), clear_flags: make_mask(clear_flags)}
+    end
+  end
+end

data/lib/stellar/util/strkey.rb

@@ -22,7 +22,7 @@ module Stellar
       end
 
       # Converts an Stellar::MuxedAccount to its string representation, forcing the ed25519 representation.
-      # @param [Stellar::MuxedAccount] muxed account
+      # @param muxed_account [Stellar::MuxedAccount] account
       # @return [String] "G.."-like address
       def self.encode_muxed_account(muxed_account)
         ed25519 = if muxed_account.switch == Stellar::CryptoKeyType.key_type_ed25519
@@ -36,7 +36,7 @@ module Stellar
 
       # Returns a Stellar::MuxedAccount, forcing the ed25519 discriminant
       #
-      # @param [String] address to decode to XDR
+      # @param strkey [String] address string to decode
       # @return [Stellar::MuxedAccount] MuxedAccount with ed25519 discriminant
       def self.decode_muxed_account(strkey)
         Stellar::MuxedAccount.new(:key_type_ed25519, check_decode(:account_id, strkey))
@@ -44,10 +44,10 @@ module Stellar
 
       def self.check_decode(expected_version, str)
         decoded = begin
-                    Base32.decode(str)
-                  rescue
-                    raise ArgumentError, "Invalid base32 string"
-                  end
+          Base32.decode(str)
+        rescue
+          raise ArgumentError, "Invalid base32 string"
+        end
         version_byte = decoded[0]
         payload = decoded[1...-2]
         check = decoded[-2..-1]