stellar-base 0.23.0.rc2 → 0.25.0

data/lib/stellar/ledger_key.rb

@@ -0,0 +1,32 @@
+require "stellar/convert"
+require "stellar/dsl"
+
+module Stellar
+  class LedgerKey
+    class << self
+      include Stellar::DSL
+
+      def switch_for_arm(name)
+        (@switch_by_arm ||= switches.invert).fetch(name)
+      end
+
+      def from(account_id:, **options)
+        field, value = options.first
+        case field
+        when nil
+          account(account_id: KeyPair(account_id).account_id)
+        when :balance_id
+          claimable_balance(balance_id: ClaimableBalanceID.v0(Stellar::Convert.from_hex(value.to_s)))
+        when :offer_id
+          offer(seller_id: account_id, offer_id: Integer(value))
+        when :data_name
+          data(account_id: account_id, data_name: value.to_s)
+        when :asset
+          trust_line(account_id: account_id, asset: Asset(value))
+        else
+          raise ArgumentError, "unknown option #{field} (not in :asset, :offer_id, :data_name, :balance_id)"
+        end
+      end
+    end
+  end
+end

data/lib/stellar/muxed_account.rb

@@ -0,0 +1,16 @@
+module Stellar
+  class MuxedAccount
+    def to_keypair
+      case arm
+      when :ed25519 then KeyPair.from_public_key(value)
+      when :med25519 then KeyPair.from_public_key(value.ed25519)
+      else
+        raise "impossible"
+      end
+    end
+
+    def address
+      to_keypair.address
+    end
+  end
+end

data/lib/stellar/networks.rb

@@ -12,18 +12,18 @@ module Stellar
   #        methods of specifying a network if you need two threads in the same process to communicate with
   #        different networks
   #
-  # @see Stellar.default_network
   # @see Stellar.on_network
-  def self.default_network=(passphrase)
-    @default_network = passphrase
-  end
+  mattr_accessor :default_network, default: Networks::TESTNET
+
+  # Stellar network passphrase selected for current thread
+  #
+  # @see Stellar.current_network
+  # @see Stellar.on_network
+  thread_mattr_accessor :network
 
-  # Returns the passphrase for the currently-configured network, as set by Stellar.default_network
-  # or Stellar.on_network
+  # Returns the passphrase for the network currently active per-thread with a fallback to `Stellar.default_network`
   def self.current_network
-    Thread.current["stellar_network_passphrase"] ||
-      @default_network ||
-      Stellar::Networks::TESTNET
+    network.presence || default_network
   end
 
   # Returns the id for the currently configured network, suitable for use in generating
@@ -34,10 +34,10 @@ module Stellar
 
   # Executes the provided block in the context of the provided network.
   def self.on_network(passphrase, &block)
-    old = Thread.current["stellar_network_passphrase"]
-    Thread.current["stellar_network_passphrase"] = passphrase
+    old = network
+    self.network = passphrase
     block.call
   ensure
-    Thread.current["stellar_network_passphrase"] = old
+    self.network = old
   end
 end

data/lib/stellar/operation.rb

@@ -5,6 +5,7 @@ module Stellar
     MAX_INT64 = 2**63 - 1
 
     class << self
+      include Stellar::DSL
       #
       # Construct a new Stellar::Operation from the provided
       # source account and body
@@ -168,7 +169,6 @@ module Stellar
         }))
       end
 
-      #
       # Helper method to create a valid ChangeTrustOp, wrapped
       # in the necessary XDR structs to be included within a
       # transactions `operations` array.
@@ -200,6 +200,64 @@ module Stellar
         }))
       end
 
+      # Helper method to create a valid CreateClaimableBalanceOp, ready to be used
+      # within a transactions `operations` array.
+      #
+      # @see Stellar::DSL::Claimant
+      # @see https://github.com/astroband/ruby-stellar-sdk/tree/master/base/examples/claimable_balances.rb
+      #
+      # @param asset [Asset] the asset to transfer to a claimable balance
+      # @param amount [Fixnum] the amount of `asset` to put into a claimable balance
+      # @param claimants [Array<Claimant>] accounts authorized to claim the balance in the future
+      #
+      # @return [Operation] the built operation
+      def create_claimable_balance(asset:, amount:, claimants:, **attributes)
+        op = CreateClaimableBalanceOp.new(asset: asset, amount: amount, claimants: claimants)
+
+        make(attributes.merge(body: [:create_claimable_balance, op]))
+      end
+
+      # Helper method to create a valid CreateClaimableBalanceOp, ready to be used
+      # within a transactions `operations` array.
+      #
+      # @see Stellar::DSL::Claimant
+      # @see https://github.com/astroband/ruby-stellar-sdk/tree/master/base/examples/claimable_balances.rb
+      #
+      # @param balance_id [ClaimableBalanceID] unique ID of claimable balance
+      #
+      # @return [Operation] the built operation, containing a Stellar::ChangeTrustOp body
+      def claim_claimable_balance(balance_id:, **attributes)
+        op = ClaimClaimableBalanceOp.new(balance_id: balance_id)
+
+        make(attributes.merge(body: [:claim_claimable_balance, op]))
+      end
+
+      def begin_sponsoring_future_reserves(sponsored:, **attributes)
+        op = BeginSponsoringFutureReservesOp.new(
+          sponsored_id: KeyPair(sponsored).account_id
+        )
+
+        make(attributes.merge(body: [:begin_sponsoring_future_reserves, op]))
+      end
+
+      def end_sponsoring_future_reserves(**attributes)
+        make(attributes.merge(body: [:end_sponsoring_future_reserves]))
+      end
+
+      # @param sponsored [#to_keypair] owner of sponsored entry
+      def revoke_sponsorship(sponsored:, **attributes)
+        key_fields = attributes.slice(:offer_id, :data_name, :balance_id, :asset, :signer)
+        raise ArgumentError, "conflicting attributes: #{key_fields.keys.join(", ")}" if key_fields.size > 1
+        account_id = KeyPair(sponsored).account_id
+        key, value = key_fields.first
+        op = if key == :signer
+          RevokeSponsorshipOp.signer(account_id: account_id, signer_key: SignerKey(value))
+        else
+          RevokeSponsorshipOp.ledger_key(LedgerKey.from(account_id: account_id, **key_fields))
+        end
+        make(attributes.merge(body: [:revoke_sponsorship, op]))
+      end
+
       def manage_sell_offer(attributes = {})
         buying = attributes[:buying]
         if buying.is_a?(Array)

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,172 +2,22 @@ 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
+    def to_v0
+      ed25519 = if source_account.switch == Stellar::CryptoKeyType.key_type_ed25519
+        source_account.ed25519!
+      else
+        source_account.med25519!.ed25519
+      end
+
+      TransactionV0.new(
+        source_account_ed25519: ed25519,
+        seq_num: seq_num,
+        operations: operations,
+        fee: fee,
+        memo: memo,
+        time_bounds: time_bounds,
+        ext: ext
+      )
     end
 
     def signature_base
@@ -179,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,13 +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,
-      v1: false
+      **_ # 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
@@ -19,9 +40,13 @@ 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 = []
-      @v1 = v1
     end
 
     def build
@@ -34,6 +59,7 @@ module Stellar
       end
 
       attrs = {
+        source_account: @source_account.muxed_account,
         fee: @base_fee * @operations.length,
         seq_num: @sequence_number,
         time_bounds: @time_bounds,
@@ -42,21 +68,16 @@ module Stellar
         ext: Stellar::Transaction::Ext.new(0)
       }
 
-      tx = if @v1
-        attrs[:source_account] = @source_account.muxed_account
-        Stellar::Transaction.new(attrs)
-      else
-        attrs[:source_account_ed25519] = @source_account.raw_public_key
-        Stellar::TransactionV0.new(attrs)
-      end
-
       @sequence_number += 1
-      tx
+
+      Stellar::Transaction.new(attrs)
     end
 
     def build_fee_bump(inner_txe:)
-      if inner_txe.switch != Stellar::EnvelopeType.envelope_type_tx
-        raise "Invalid inner transaction type, it should be a `envelope_type_tx` but received a #{inner_tx.to_envelope.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
+        raise ArgumentError, "Invalid inner transaction type #{inner_txe.switch}"
       end
 
       inner_tx = inner_txe.tx
@@ -108,11 +129,7 @@ module Stellar
         @time_bounds = Stellar::TimeBounds.new(min_time: 0, max_time: nil)
       end
 
-      @time_bounds.max_time = if timeout == 0
-        timeout
-      else
-        Time.now.to_i + timeout
-      end
+      @time_bounds.max_time = timeout == 0 ? timeout : Time.now.to_i + timeout
 
       self
     end