stellar-base 0.22.0 → 0.23.1

data/lib/stellar/convert.rb

@@ -3,10 +3,10 @@ module Stellar
   # Generic format conversion module
   #
   module Convert
-    require 'base64'
+    require "base64"
 
     def to_hex(string)
-      string.unpack("H*").first
+      string.unpack1("H*")
     end
 
     def from_hex(hex_string)

data/lib/stellar/factories.rb

@@ -1,5 +1,4 @@
 FactoryBot.define do
-
   factory :stellar_ledger, class: Hyperclient::Resource do
     initialize_with { new(attributes.stringify_keys, nil, nil) }
 
@@ -39,7 +38,7 @@ FactoryBot.define do
     fee_meta_xdr { "AAAAAgAAAAMAAAABAAAAAAAAAAABlHJijueOuScU0i0DkJY8JNkn6gCZmUhuiR+sLaqcIQ3gtrOnZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAABlHJijueOuScU0i0DkJY8JNkn6gCZmUhuiR+sLaqcIQ3gtrOnY/7UAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAA==" }
     memo_type { "text" }
     signatures do
-      [ "SsKlst02jsaBp35vXlI300Qbz39+HbwwNDX/gfM+MwaG/dFF7bgqpkKsDAsh/qJDiN3NOW695IZB9Mj+JAsHBA==" ]
+      ["SsKlst02jsaBp35vXlI300Qbz39+HbwwNDX/gfM+MwaG/dFF7bgqpkKsDAsh/qJDiN3NOW695IZB9Mj+JAsHBA=="]
     end
   end
 
@@ -57,5 +56,4 @@ FactoryBot.define do
     funder { "GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7" }
     account { "GALPCCZN4YXA3YMJHKL6CVIECKPLJJCTVMSNYWBTKJW4K5HQLYLDMZTB" }
   end
-
 end

data/lib/stellar/fee_bump_transaction.rb

@@ -0,0 +1,21 @@
+module Stellar
+  class FeeBumpTransaction
+    include Stellar::Concerns::Transaction
+
+    def to_envelope(*key_pairs)
+      signatures = (key_pairs || []).map(&method(:sign_decorated))
+
+      TransactionEnvelope.fee_bump(signatures: signatures, tx: self)
+    end
+
+    def signature_base_prefix
+      val = Stellar::EnvelopeType.envelope_type_tx_fee_bump
+
+      Stellar.current_network_id + Stellar::EnvelopeType.to_xdr(val)
+    end
+
+    def source_account
+      source_account_ed25519
+    end
+  end
+end

data/lib/stellar/key_pair.rb

@@ -36,7 +36,7 @@ module Stellar
       from_raw_seed(Stellar.current_network_id)
     end
 
-    def initialize(public_key, secret_key=nil)
+    def initialize(public_key, secret_key = nil)
       @public_key = public_key
       @secret_key = secret_key
     end
@@ -45,6 +45,10 @@ module Stellar
       Stellar::AccountID.new :public_key_type_ed25519, raw_public_key
     end
 
+    def muxed_account
+      Stellar::MuxedAccount.new :key_type_ed25519, raw_public_key
+    end
+
     def public_key
       Stellar::PublicKey.new :public_key_type_ed25519, raw_public_key
     end
@@ -81,9 +85,9 @@ module Stellar
 
     def seed
       raise "no private key" if @secret_key.nil?
-      #TODO: improve the error class above
+      # TODO: improve the error class above
       seed_bytes = raw_seed
-      encoder = Util::StrKey.check_encode(:seed, seed_bytes)
+      Util::StrKey.check_encode(:seed, seed_bytes)
     end
 
     def sign?
@@ -92,14 +96,14 @@ module Stellar
 
     def sign(message)
       raise "no private key" if @secret_key.nil?
-      #TODO: improve the error class above
+      # TODO: improve the error class above
       @secret_key.sign(message)
     end
 
     def sign_decorated(message)
       raw_signature = sign(message)
       Stellar::DecoratedSignature.new({
-        hint:      signature_hint,
+        hint: signature_hint,
         signature: raw_signature
       })
     end
@@ -111,6 +115,5 @@ module Stellar
     rescue RbNaCl::BadSignatureError
       false
     end
-
   end
 end

data/lib/stellar/networks.rb

@@ -1,10 +1,8 @@
 module Stellar
   # Provides a container for well-known network passphrases, such as the main network and SDF test network
   module Networks
-
-    PUBLIC  = "Public Global Stellar Network ; September 2015"
+    PUBLIC = "Public Global Stellar Network ; September 2015"
     TESTNET = "Test SDF Network ; September 2015"
-
   end
 
   # Configures the default stellar network passphrase for the current process.  Unless otherwise
@@ -23,15 +21,15 @@ module Stellar
   # Returns the passphrase for the currently-configured network, as set by Stellar.default_network
   # or Stellar.on_network
   def self.current_network
-    Thread.current["stellar_network_passphrase"] || 
-    @default_network || 
-    Stellar::Networks::TESTNET
+    Thread.current["stellar_network_passphrase"] ||
+      @default_network ||
+      Stellar::Networks::TESTNET
   end
 
   # Returns the id for the currently configured network, suitable for use in generating
   # a signature base string or making the root account's keypair.
   def self.current_network_id
-    Digest::SHA256.digest(self.current_network) 
+    Digest::SHA256.digest(current_network)
   end
 
   # Executes the provided block in the context of the provided network.

data/lib/stellar/operation.rb

@@ -1,473 +1,478 @@
-require 'bigdecimal'
+require "bigdecimal"
 
 module Stellar
   class Operation
-
     MAX_INT64 = 2**63 - 1
 
-    #
-    # 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.account_id
-      end
-
-      return op
-    end
-
+    class << self
+      #
+      # 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 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.muxed_account
+        end
 
-    #
-    # Helper method to create a valid PaymentOp, wrapped
-    # in the necessary XDR structs to be included within a
-    # transactions `operations` array.
-    #
-    # @see Stellar::Asset
-    #
-    # @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
-    # @return [Stellar::Operation] the built operation, containing a
-    #                              Stellar::PaymentOp body
-    def self.payment(attributes={})
-      destination = attributes[:destination]
-      asset, amount = get_asset_amount(attributes[:amount])
-
-      raise ArgumentError unless destination.is_a?(KeyPair)
-
-
-      op             = PaymentOp.new
-      op.asset       = asset
-      op.amount      = amount
-      op.destination = destination.account_id
-
-      return make(attributes.merge({
-        body:[:payment, op]
-      }))
-    end
+        op
+      end
 
-    #
-    # Helper method to create a valid PathPaymentStrictReceiveOp, wrapped
-    # in the necessary XDR structs to be included within a
-    # transactions `operations` array.
-    # 
-    # @deprecated Please use Operation.path_payment_strict_receive
-    #
-    # @see Stellar::Asset
-    #
-    # @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 destination asset and the amount to pay
-    # @option attributes [Array] :with the source asset and maximum allowed source amount to pay with
-    # @option attributes [Array<Stellar::Asset>] :path the payment path to use
-    #
-    # @return [Stellar::Operation] the built operation, containing a Stellar::PaymentOp body
-    #                              
-    def self.path_payment(attributes={})
-      path_payment_strict_receive(attributes)
-    end
+      #
+      # Helper method to create a valid PaymentOp, wrapped
+      # in the necessary XDR structs to be included within a
+      # transactions `operations` array.
+      #
+      # @see Stellar::Asset
+      #
+      # @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
+      # @return [Stellar::Operation] the built operation, containing a
+      #                              Stellar::PaymentOp body
+      def payment(attributes = {})
+        destination = attributes[:destination]
+        asset, amount = get_asset_amount(attributes[:amount])
+
+        raise ArgumentError unless destination.is_a?(KeyPair)
+
+        op = PaymentOp.new
+        op.asset = asset
+        op.amount = amount
+        op.destination = destination.muxed_account
+
+        make(attributes.merge({
+          body: [:payment, op]
+        }))
+      end
 
-    #
-    # Helper method to create a valid PathPaymentStrictReceiveOp, wrapped
-    # in the necessary XDR structs to be included within a
-    # transactions `operations` array.
-    # 
-    # @see Stellar::Asset
-    #
-    # @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 destination asset and the amount to pay
-    # @option attributes [Array] :with the source asset and maximum allowed source amount to pay with
-    # @option attributes [Array<Stellar::Asset>] :path the payment path to use
-    #
-    # @return [Stellar::Operation] the built operation, containing a Stellar::PaymentOp body
-    #                              
-    def self.path_payment_strict_receive(attributes={})
-      destination             = attributes[:destination]
-      asset, amount           = get_asset_amount(attributes[:amount])
-      send_asset, send_max    = get_asset_amount(attributes[:with])
-      path                    = (attributes[:path] || []).map{
-        |p| p.is_a?(Array) ? Stellar::Asset.send(*p) : p
-      }
-
-      raise ArgumentError unless destination.is_a?(KeyPair)
-
-      op               = PathPaymentStrictReceiveOp.new
-      op.send_asset    = send_asset
-      op.send_max      = send_max
-      op.destination   = destination.account_id
-      op.dest_asset    = asset
-      op.dest_amount   = amount
-      op.path          = path
-
-      return make(attributes.merge({
-        body:[:path_payment_strict_receive, op]
-      }))
-    end
+      #
+      # Helper method to create a valid PathPaymentStrictReceiveOp, wrapped
+      # in the necessary XDR structs to be included within a
+      # transactions `operations` array.
+      #
+      # @deprecated Please use Operation.path_payment_strict_receive
+      #
+      # @see Stellar::Asset
+      #
+      # @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 destination asset and the amount to pay
+      # @option attributes [Array] :with the source asset and maximum allowed source amount to pay with
+      # @option attributes [Array<Stellar::Asset>] :path the payment path to use
+      #
+      # @return [Stellar::Operation] the built operation, containing a Stellar::PaymentOp body
+      #
+      def path_payment(attributes = {})
+        path_payment_strict_receive(attributes)
+      end
 
-    #
-    # Helper method to create a valid PathPaymentStrictSendOp, wrapped
-    # in the necessary XDR structs to be included within a
-    # transactions `operations` array.
-    # 
-    # @see Stellar::Asset
-    #
-    # @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 destination asset and the minimum amount of destination asset to be received
-    # @option attributes [Array] :with the source asset and amount to pay with
-    # @option attributes [Array<Stellar::Asset>] :path the payment path to use
-    #
-    # @return [Stellar::Operation] the built operation, containing a Stellar::PaymentOp body
-    #                              
-    def self.path_payment_strict_send(attributes={})
-      destination             = attributes[:destination]
-      asset, dest_min         = get_asset_amount(attributes[:amount])
-      send_asset, send_amount = get_asset_amount(attributes[:with])
-      path                    = (attributes[:path] || []).map{
-        |p| p.is_a?(Array) ? Stellar::Asset.send(*p) : p
-      }
-
-      raise ArgumentError unless destination.is_a?(KeyPair)
-
-      op               = PathPaymentStrictSendOp.new
-      op.send_asset    = send_asset
-      op.send_amount   = send_amount
-      op.destination   = destination.account_id
-      op.dest_asset    = asset
-      op.dest_min      = dest_min
-      op.path          = path
-
-      return make(attributes.merge({
-        body:[:path_payment_strict_send, op]
-      }))
-    end
+      #
+      # Helper method to create a valid PathPaymentStrictReceiveOp, wrapped
+      # in the necessary XDR structs to be included within a
+      # transactions `operations` array.
+      #
+      # @see Stellar::Asset
+      #
+      # @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 destination asset and the amount to pay
+      # @option attributes [Array] :with the source asset and maximum allowed source amount to pay with
+      # @option attributes [Array<Stellar::Asset>] :path the payment path to use
+      #
+      # @return [Stellar::Operation] the built operation, containing a Stellar::PaymentOp body
+      #
+      def path_payment_strict_receive(attributes = {})
+        destination = attributes[:destination]
+        asset, amount = get_asset_amount(attributes[:amount])
+        send_asset, send_max = get_asset_amount(attributes[:with])
+        path = (attributes[:path] || []).map { |p|
+          p.is_a?(Array) ? Stellar::Asset.send(*p) : p
+        }
+
+        raise ArgumentError unless destination.is_a?(KeyPair)
+
+        op = PathPaymentStrictReceiveOp.new
+        op.send_asset = send_asset
+        op.send_max = send_max
+        op.destination = destination.muxed_account
+        op.dest_asset = asset
+        op.dest_amount = amount
+        op.path = path
+
+        make(attributes.merge({
+          body: [:path_payment_strict_receive, op]
+        }))
+      end
 
-    def self.create_account(attributes={})
-      destination      = attributes[:destination]
-      starting_balance = interpret_amount(attributes[:starting_balance])
+      #
+      # Helper method to create a valid PathPaymentStrictSendOp, wrapped
+      # in the necessary XDR structs to be included within a
+      # transactions `operations` array.
+      #
+      # @see Stellar::Asset
+      #
+      # @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 destination asset and the minimum amount of destination asset to be received
+      # @option attributes [Array] :with the source asset and amount to pay with
+      # @option attributes [Array<Stellar::Asset>] :path the payment path to use
+      #
+      # @return [Stellar::Operation] the built operation, containing a Stellar::PaymentOp body
+      #
+      def path_payment_strict_send(attributes = {})
+        destination = attributes[:destination]
+        asset, dest_min = get_asset_amount(attributes[:amount])
+        send_asset, send_amount = get_asset_amount(attributes[:with])
+        path = (attributes[:path] || []).map { |p|
+          p.is_a?(Array) ? Stellar::Asset.send(*p) : p
+        }
+
+        raise ArgumentError unless destination.is_a?(KeyPair)
+
+        op = PathPaymentStrictSendOp.new
+        op.send_asset = send_asset
+        op.send_amount = send_amount
+        op.destination = destination.muxed_account
+        op.dest_asset = asset
+        op.dest_min = dest_min
+        op.path = path
+
+        make(attributes.merge({
+          body: [:path_payment_strict_send, op]
+        }))
+      end
 
-      raise ArgumentError unless destination.is_a?(KeyPair)
+      def create_account(attributes = {})
+        destination = attributes[:destination]
+        starting_balance = interpret_amount(attributes[:starting_balance])
 
-      op = CreateAccountOp.new()
-      op.destination = destination.account_id
-      op.starting_balance = starting_balance
+        raise ArgumentError unless destination.is_a?(KeyPair)
 
-      return make(attributes.merge({
-        body:[:create_account, op]
-      }))
-    end
+        op = CreateAccountOp.new
+        op.destination = destination.account_id
+        op.starting_balance = starting_balance
 
-    #
-    # 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::Asset] :line the asset to trust
-    # @option attributes [Fixnum] :limit the maximum amount to trust, defaults to max int64,
-    #                                    if the limit is set to 0 it deletes the trustline.
-    #
-    # @return [Stellar::Operation] the built operation, containing a
-    #                              Stellar::ChangeTrustOp body
-    def self.change_trust(attributes={})
-      line = attributes[:line]
-      if !line.is_a?(Asset)
-        if !Asset::TYPES.include?(line[0])
-          fail ArgumentError, "must be one of #{Asset::TYPES}"
-        end
-        line = Asset.send(*line)
+        make(attributes.merge({
+          body: [:create_account, op]
+        }))
       end
 
-      limit = attributes.key?(:limit) ? interpret_amount(attributes[:limit]) : MAX_INT64
+      #
+      # 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::Asset] :line the asset to trust
+      # @option attributes [Fixnum] :limit the maximum amount to trust, defaults to max int64,
+      #                                    if the limit is set to 0 it deletes the trustline.
+      #
+      # @return [Stellar::Operation] the built operation, containing a
+      #                              Stellar::ChangeTrustOp body
+      def change_trust(attributes = {})
+        line = attributes[:line]
+        unless line.is_a?(Asset)
+          unless Asset::TYPES.include?(line[0])
+            fail ArgumentError, "must be one of #{Asset::TYPES}"
+          end
+          line = Asset.send(*line)
+        end
 
-      raise ArgumentError, "Bad :limit #{limit}" unless limit.is_a?(Integer)
+        limit = attributes.key?(:limit) ? interpret_amount(attributes[:limit]) : MAX_INT64
 
-      op = ChangeTrustOp.new(line: line, limit: limit)
+        raise ArgumentError, "Bad :limit #{limit}" unless limit.is_a?(Integer)
 
-      return make(attributes.merge({
-        body:[:change_trust, op]
-      }))
-    end
+        op = ChangeTrustOp.new(line: line, limit: limit)
 
-    def self.manage_sell_offer(attributes={})
-      buying = attributes[:buying]
-      if buying.is_a?(Array)
-        buying = Asset.send(*buying)
-      end
-      selling = attributes[:selling]
-      if selling.is_a?(Array)
-        selling = Asset.send(*selling)
+        make(attributes.merge({
+          body: [:change_trust, op]
+        }))
       end
-      amount = interpret_amount(attributes[:amount])
-      offer_id = attributes[:offer_id] || 0
-      price = interpret_price(attributes[:price])
-
-      op = ManageSellOfferOp.new({
-        buying:     buying,
-        selling:    selling,
-        amount:     amount,
-        price:      price,
-        offer_id:   offer_id
-      })
-
-      return make(attributes.merge({
-        body:[:manage_sell_offer, op]
-      }))
-    end
 
-    def self.manage_buy_offer(attributes={})
-      buying = attributes[:buying]
-      if buying.is_a?(Array)
-        buying = Asset.send(*buying)
-      end
-      selling = attributes[:selling]
-      if selling.is_a?(Array)
-        selling = Asset.send(*selling)
+      def manage_sell_offer(attributes = {})
+        buying = attributes[:buying]
+        if buying.is_a?(Array)
+          buying = Asset.send(*buying)
+        end
+        selling = attributes[:selling]
+        if selling.is_a?(Array)
+          selling = Asset.send(*selling)
+        end
+        amount = interpret_amount(attributes[:amount])
+        offer_id = attributes[:offer_id] || 0
+        price = interpret_price(attributes[:price])
+
+        op = ManageSellOfferOp.new({
+          buying: buying,
+          selling: selling,
+          amount: amount,
+          price: price,
+          offer_id: offer_id
+        })
+
+        make(attributes.merge({
+          body: [:manage_sell_offer, op]
+        }))
       end
-      amount = interpret_amount(attributes[:amount])
-      offer_id = attributes[:offer_id] || 0
-      price = interpret_price(attributes[:price])
-
-      op = ManageBuyOfferOp.new({
-        buying:     buying,
-        selling:    selling,
-        amount:     amount,
-        price:      price,
-        offer_id:   offer_id
-      })
-
-      return make(attributes.merge({
-        body:[:manage_buy_offer, op]
-      }))
-    end
 
-    def self.create_passive_sell_offer(attributes={})
-      buying = attributes[:buying]
-      if buying.is_a?(Array)
-        buying = Asset.send(*buying)
-      end
-      selling = attributes[:selling]
-      if selling.is_a?(Array)
-        selling = Asset.send(*selling)
+      def manage_buy_offer(attributes = {})
+        buying = attributes[:buying]
+        if buying.is_a?(Array)
+          buying = Asset.send(*buying)
+        end
+        selling = attributes[:selling]
+        if selling.is_a?(Array)
+          selling = Asset.send(*selling)
+        end
+        amount = interpret_amount(attributes[:amount])
+        offer_id = attributes[:offer_id] || 0
+        price = interpret_price(attributes[:price])
+
+        op = ManageBuyOfferOp.new({
+          buying: buying,
+          selling: selling,
+          amount: amount,
+          price: price,
+          offer_id: offer_id
+        })
+
+        make(attributes.merge({
+          body: [:manage_buy_offer, op]
+        }))
       end
-      amount = interpret_amount(attributes[:amount])
-      price = interpret_price(attributes[:price])
-
-      op = CreatePassiveSellOfferOp.new({
-        buying:     buying,
-        selling:    selling,
-        amount:     amount,
-        price:      price,
-      })
-
-      return make(attributes.merge({
-        body:[:create_passive_sell_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.master_weight  = attributes[:master_weight]
-      op.low_threshold  = attributes[:low_threshold]
-      op.med_threshold  = attributes[:med_threshold]
-      op.high_threshold = attributes[:high_threshold]
-
-      op.signer      = attributes[:signer]
-      op.home_domain = attributes[:home_domain]
-
-
-      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.account_id
+      def create_passive_sell_offer(attributes = {})
+        buying = attributes[:buying]
+        if buying.is_a?(Array)
+          buying = Asset.send(*buying)
+        end
+        selling = attributes[:selling]
+        if selling.is_a?(Array)
+          selling = Asset.send(*selling)
+        end
+        amount = interpret_amount(attributes[:amount])
+        price = interpret_price(attributes[:price])
+
+        op = CreatePassiveSellOfferOp.new({
+          buying: buying,
+          selling: selling,
+          amount: amount,
+          price: price
+        })
+
+        make(attributes.merge({
+          body: [:create_passive_sell_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 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.master_weight = attributes[:master_weight]
+        op.low_threshold = attributes[:low_threshold]
+        op.med_threshold = attributes[:med_threshold]
+        op.high_threshold = attributes[:high_threshold]
+
+        op.signer = attributes[:signer]
+        op.home_domain = attributes[:home_domain]
+
+        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.account_id
+        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::Asset] :asset
-    #
-    # @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]
-      asset = attributes[:asset]
-      if asset.is_a?(Array)
-        asset = Asset.send(*asset)
+        make(attributes.merge({
+          body: [:set_options, op]
+        }))
       end
 
-      raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Stellar::KeyPair)
-      raise ArgumentError, "Bad :authorize" unless authorize == !!authorize # check boolean
-      raise ArgumentError, "Bad :asset" unless asset.type == Stellar::AssetType.asset_type_credit_alphanum4
-
-      atc = AllowTrustOp::Asset.new(:asset_type_credit_alphanum4, asset.code)
+      #
+      # 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::Asset] :asset
+      # @option attributes [Symbol, Boolean] :authorize :full, maintain_liabilities or :none
+      #
+      # @return [Stellar::Operation] the built operation, containing a
+      #                              Stellar::AllowTrustOp body
+      def allow_trust(attributes = {})
+        op = AllowTrustOp.new
+
+        trustor = attributes[:trustor]
+        authorize = attributes[:authorize]
+        asset = attributes[:asset]
+        if asset.is_a?(Array)
+          asset = Asset.send(*asset)
+        end
 
-      op.trustor   = trustor.account_id
-      op.authorize = authorize
-      op.asset     = atc
+        raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Stellar::KeyPair)
 
-      return make(attributes.merge({
-        body:[:allow_trust, op]
-      }))
-    end
+        op.authorize = case authorize
+        when :none, false then 0 # we handle booleans here for the backward compatibility
+        when :full, true then TrustLineFlags.authorized_flag.value
+        when :maintain_liabilities then TrustLineFlags.authorized_to_maintain_liabilities_flag.value
+        else
+          raise ArgumentError, "Bad :authorize, supported values: :full, :maintain_liabilities, :none"
+        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.account_id]
-      }))
-    end
+        raise ArgumentError, "Bad :asset" unless asset.type == Stellar::AssetType.asset_type_credit_alphanum4
 
-    #
-    # 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]
-      }))
-    end
+        atc = AllowTrustOp::Asset.new(:asset_type_credit_alphanum4, asset.code)
 
-    #
-    # Helper method to create an manage data operation
-    #
-    # @param [Hash] attributes the attributes to create the operation with
-    # @option attributes [Integer]  :sequence
-    #
-    # @return [Stellar::Operation] the built operation
-    def self.manage_data(attributes={})
-      op = ManageDataOp.new()
+        op.trustor = trustor.account_id
+        op.asset = atc
 
-      name  = attributes[:name]
-      value = attributes[:value]
+        make(attributes.merge({
+          body: [:allow_trust, op]
+        }))
+      end
 
-      raise ArgumentError, "Invalid :name" unless name.is_a?(String)
-      raise ArgumentError, ":name too long" unless name.bytesize <= 64
+      #
+      # 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 account_merge(attributes = {})
+        destination = attributes[:destination]
+
+        raise ArgumentError, "Bad :destination" unless destination.is_a?(KeyPair)
+
+        # TODO: add source_account support
+        make(attributes.merge({
+          body: [:account_merge, destination.muxed_account]
+        }))
+      end
 
-      if value.present?
-        raise ArgumentError, ":value too long" unless value.bytesize <= 64
+      #
+      # 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 inflation(attributes = {})
+        sequence = attributes[:sequence]
+
+        raise ArgumentError, "Bad :sequence #{sequence}" unless sequence.is_a?(Integer)
+
+        # TODO: add source_account support
+        make(attributes.merge({
+          body: [:inflation]
+        }))
       end
 
-      op.data_name  = name
-      op.data_value = value
+      #
+      # Helper method to create an manage data operation
+      #
+      # @param [Hash] attributes the attributes to create the operation with
+      # @option attributes [Integer]  :sequence
+      #
+      # @return [Stellar::Operation] the built operation
+      def manage_data(attributes = {})
+        op = ManageDataOp.new
 
-      return make(attributes.merge({
-        body:[:manage_data, op]
-      }))
-    end
+        name = attributes[:name]
+        value = attributes[:value]
 
-    def self.bump_sequence(attributes={})
-      op = BumpSequenceOp.new()
+        raise ArgumentError, "Invalid :name" unless name.is_a?(String)
+        raise ArgumentError, ":name too long" unless name.bytesize <= 64
 
-      bump_to = attributes[:bump_to]
+        if value.present?
+          raise ArgumentError, ":value too long" unless value.bytesize <= 64
+        end
 
-      raise ArgumentError, ":bump_to too big" unless bump_to <= MAX_INT64
+        op.data_name = name
+        op.data_value = value
 
-      op.bump_to  = bump_to
+        make(attributes.merge({
+          body: [:manage_data, op]
+        }))
+      end
 
-      return make(attributes.merge({
-        body:[:bump_sequence, op]
-      }))
-    end
+      def bump_sequence(attributes = {})
+        op = BumpSequenceOp.new
+
+        bump_to = attributes[:bump_to]
+
+        raise ArgumentError, ":bump_to too big" unless bump_to <= MAX_INT64
+
+        op.bump_to = bump_to
 
-    private
-    def self.get_asset_amount(values)
-      amount = interpret_amount(values.last)
-      if values[0].is_a?(Stellar::Asset)
-        asset = values.first
-      else
-        asset = Stellar::Asset.send(*values[0...-1])
+        make(attributes.merge({
+          body: [:bump_sequence, op]
+        }))
       end
 
-      return asset, amount
-    end
+      private
+
+      def get_asset_amount(values)
+        amount = interpret_amount(values.last)
+        asset = if values[0].is_a?(Stellar::Asset)
+          values.first
+        else
+          Stellar::Asset.send(*values[0...-1])
+        end
 
-    def self.interpret_amount(amount)
-      case amount
-      when String
-        (BigDecimal(amount) * Stellar::ONE).floor
-      when Integer
-        amount * Stellar::ONE
-      when Numeric
-        (amount * Stellar::ONE).floor
-      else
-        raise ArgumentError, "Invalid amount type: #{amount.class}. Must be String or Numeric"
+        [asset, amount]
       end
-    end
 
+      def interpret_amount(amount)
+        case amount
+        when String
+          (BigDecimal(amount) * Stellar::ONE).floor
+        when Integer
+          amount * Stellar::ONE
+        when Numeric
+          (amount * Stellar::ONE).floor
+        else
+          raise ArgumentError, "Invalid amount type: #{amount.class}. Must be String or Numeric"
+        end
+      end
 
-    def self.interpret_price(price)
-      case price
-      when String
-        bd = BigDecimal.new(price)
-        Price.from_f(bd)
-      when Numeric
-        Price.from_f(price)
-      when Stellar::Price
-        price
-      else
-        raise ArgumentError, "Invalid price type: #{price.class}. Must be String, Numeric, or Stellar::Price"
+      def interpret_price(price)
+        case price
+        when String
+          bd = BigDecimal(price)
+          Price.from_f(bd)
+        when Numeric
+          Price.from_f(price)
+        when Stellar::Price
+          price
+        else
+          raise ArgumentError, "Invalid price type: #{price.class}. Must be String, Numeric, or Stellar::Price"
+        end
       end
     end
   end