stellar-base 0.18.0 → 0.23.0.pre1

data/lib/stellar/{path_payment_result.rb → path_payment_strict_receive_result.rb}

@@ -1,5 +1,5 @@
 module Stellar
-  class PathPaymentResult
+  class PathPaymentStrictReceiveResult
     # send_amount returns the actual amount paid for the corresponding
     # PathPaymentOp to this result.
     #
@@ -8,10 +8,9 @@ module Stellar
       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 = s.offers.take_while { |o| o.asset_bought == source_asset }
 
       source_offers.map(&:amount_bought).sum
     end
-
   end
 end

data/lib/stellar/price.rb

@@ -1,8 +1,6 @@
 module Stellar
-
   # reopen class
   class Price
-
     MAX_PRECISION = (2**31) - 1
 
     def self.from_f(number)
@@ -14,7 +12,7 @@ module Stellar
     end
 
     def invert
-      self.class.new(n:d,d:n)
+      self.class.new(n: d, d: n)
     end
 
     def to_f
@@ -29,4 +27,4 @@ module Stellar
       "#<Stellar::Price #{self}>"
     end
   end
-end
+end

data/lib/stellar/signer_key.rb

@@ -1,6 +1,5 @@
 module Stellar
   class SignerKey
-
     PREIMAGE_LENGTH = 32
 
     def self.ed25519(keypair)
@@ -8,16 +7,14 @@ module Stellar
       new(:signer_key_type_ed25519, keypair.raw_public_key)
     end
 
-
     def self.preauthorized_transaction(tx)
       new(:signer_key_type_pre_auth_tx, tx.hash)
     end
 
-
     def self.hash_x(preimage)
-      raise ArgumentError, "Must be string" unless preimage.is_a?(String) 
+      raise ArgumentError, "Must be string" unless preimage.is_a?(String)
       raise ArgumentError, "Must be 32 bytes" unless preimage.bytesize == PREIMAGE_LENGTH
-      
+
       hash_x = Digest::SHA256.digest(preimage)
       new(:signer_key_type_hash_x, hash_x)
     end
@@ -37,14 +34,13 @@ module Stellar
     end
 
     def inspect
-      label = switch.to_s
-      "#<Stellar::SignerKey #{to_s}>"
+      # label = switch.to_s
+      "#<Stellar::SignerKey #{self}>"
     end
 
     def signature_hint
       # take last 4 bytes
       value.to_xdr.slice(-4, 4)
     end
-
   end
 end

data/lib/stellar/thresholds.rb

@@ -3,10 +3,9 @@ module Stellar
     COMPONENTS = [:master_weight, :low, :medium, :high]
     VALID_RANGE = 0..255
 
-    def make(thresholds={})
-
+    def make(thresholds = {})
       # error if any of the needed components are not provided
-      if COMPONENTS.any?{|c| thresholds[c].blank? }
+      if COMPONENTS.any? { |c| thresholds[c].blank? }
         raise ArgumentError, "invalid thresholds hash, must have #{COMPONENTS.inspect} keys, had: #{thresholds.keys.inspect}"
       end
 
@@ -22,7 +21,6 @@ module Stellar
         end
       end
 
-
       thresholds.values_at(*COMPONENTS).pack("C*")
     end
 
@@ -30,9 +28,9 @@ module Stellar
       master_weight, low, medium, high = combined.unpack("C*")
       {
         master_weight: master_weight,
-        low:           low,
-        medium:        medium,
-        high:          high,
+        low: low,
+        medium: medium,
+        high: high
       }
     end
   end

data/lib/stellar/transaction.rb

@@ -1,202 +1,187 @@
 module Stellar
   class Transaction
+    include Stellar::Concerns::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
+    class << self
+      #
+      # @see  Stellar::Operation.payment
+      def payment(attributes = {})
+        make :payment, attributes
+      end
 
-    #
-    # @see  Stellar::Operation.create_account
-    def self.create_account(attributes={})
-      make :create_account, attributes
-    end
+      #
+      # @see  Stellar::Operation.path_payment
+      def path_payment(attributes = {})
+        make :path_payment, attributes
+      end
 
-    #
-    # @see  Stellar::Operation.change_trust
-    def self.change_trust(attributes={})
-      make :change_trust, 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.create_offer
-    def self.manage_offer(attributes={})
-      make :manage_offer, 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_passive_offer
-    def self.create_passive_offer(attributes={})
-      make :create_passive_offer, attributes
-    end
+      #
+      # @see  Stellar::Operation.create_account
+      def create_account(attributes = {})
+        make :create_account, attributes
+      end
 
-    #
-    # @see  Stellar::Operation.set_options
-    def self.set_options(attributes={})
-      make :set_options, attributes
-    end
+      #
+      # @see  Stellar::Operation.change_trust
+      def change_trust(attributes = {})
+        make :change_trust, attributes
+      end
 
-    #
-    # @see  Stellar::Operation.allow_trust
-    def self.allow_trust(attributes={})
-      make :allow_trust, attributes
-    end
+      #
+      # @see  Stellar::Operation.manage_sell_offer
+      def manage_sell_offer(attributes = {})
+        make :manage_sell_offer, attributes
+      end
 
-    #
-    # @see  Stellar::Operation.account_merge
-    def self.account_merge(attributes={})
-      make :account_merge, attributes
-    end
+      #
+      # @see  Stellar::Operation.manage_buy_offer
+      def manage_buy_offer(attributes = {})
+        make :manage_buy_offer, attributes
+      end
 
-    #
-    # @see  Stellar::Operation.inflation
-    def self.inflation(attributes={})
-      make :inflation, 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.manage_data
-    def self.manage_data(attributes={})
-      make :manage_data, attributes
-    end
+      #
+      # @see  Stellar::Operation.set_options
+      def set_options(attributes = {})
+        make :set_options, attributes
+      end
 
-    #
-    # @see  Stellar::Operation.manage_data
-    def self.bump_sequence(attributes={})
-      make :bump_sequence, attributes
-    end
+      #
+      # @see  Stellar::Operation.allow_trust
+      def allow_trust(attributes = {})
+        make :allow_trust, 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)
+      #
+      # @see  Stellar::Operation.account_merge
+      def account_merge(attributes = {})
+        make :account_merge, attributes
       end
-    end
 
+      #
+      # @see  Stellar::Operation.inflation
+      def inflation(attributes = {})
+        make :inflation, attributes
+      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
+      #
+      # @see  Stellar::Operation.manage_data
+      def manage_data(attributes = {})
+        make :manage_data, attributes
       end
-    end
 
-    def sign(key_pair)
-      key_pair.sign(hash)
-    end
+      #
+      # @see  Stellar::Operation.manage_data
+      def bump_sequence(attributes = {})
+        make :bump_sequence, attributes
+      end
 
-    def sign_decorated(key_pair)
-      key_pair.sign_decorated(hash)
-    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
 
-    def hash
-      Digest::SHA256.digest(signature_base)
-    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
 
-    # 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
+      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 signature_base_prefix
-      val = Stellar::EnvelopeType.envelope_type_tx
-
-      Stellar.current_network_id + Stellar::EnvelopeType.to_xdr(val)
+      tagged_tx = Stellar::TransactionSignaturePayload::TaggedTransaction.new(:envelope_type_tx, self)
+      Stellar::TransactionSignaturePayload.new(
+        network_id: Stellar.current_network_id,
+        tagged_transaction: tagged_tx
+      ).to_xdr
     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
+      TransactionEnvelope.v1(signatures: signatures, tx: self)
     end
   end
 end