stellar-base 0.24.0 → 0.28.0

data/lib/stellar/ext/xdr.rb

@@ -39,11 +39,12 @@ XDR::DSL::Union.redefine_method(:switch) do |switch, arm = nil|
   end
 end
 
-# XDR::Union generates an attribute method for each `arm`, but lacks the
-# actual `attribute(attr)` method those generated methods delegate to.
-# We follow the semantics of the bang variant `XDR::Union#attribute!` method,
-# except that calls to `raise` are replaced with early returns of nil.
-XDR::Union.define_method(:attribute) do |attr|
-  return unless @arm.to_s == attr
-  get
+# XDR::Union delegates missing methods to the underlying value
+XDR::Union.define_method(:method_missing) do |name, *args|
+  return super(name, *args) unless value&.respond_to?(name)
+  value&.public_send(name, *args)
+end
+
+XDR::Union.define_method(:respond_to_missing?) do |*args|
+  value&.respond_to?(*args)
 end

data/lib/stellar/key_pair.rb

@@ -6,6 +6,11 @@ module Stellar
         from_raw_seed seed_bytes
       end
 
+      def from_address(address)
+        pk_bytes = Util::StrKey.check_decode(:account_id, address)
+        from_public_key(pk_bytes)
+      end
+
       def from_raw_seed(seed_bytes)
         secret_key = RbNaCl::SigningKey.new(seed_bytes)
         public_key = secret_key.verify_key
@@ -17,11 +22,6 @@ module Stellar
         new(public_key)
       end
 
-      def from_address(address)
-        pk_bytes = Util::StrKey.check_decode(:account_id, address)
-        from_public_key(pk_bytes)
-      end
-
       def random
         secret_key = RbNaCl::SigningKey.generate
         public_key = secret_key.verify_key
@@ -40,11 +40,21 @@ module Stellar
 
     extend FactoryMethods
 
+    # @param [RbNaCl::VerifyKey] public_key
+    # @param [RbNaCl::SigningKey, nil] secret_key
     def initialize(public_key, secret_key = nil)
       @public_key = public_key
       @secret_key = secret_key
     end
 
+    def address
+      Util::StrKey.check_encode(:account_id, raw_public_key)
+    end
+
+    def seed
+      Util::StrKey.check_encode(:seed, raw_seed)
+    end
+
     def account_id
       Stellar::AccountID.new :public_key_type_ed25519, raw_public_key
     end
@@ -61,16 +71,17 @@ module Stellar
       Stellar::SignerKey.new :signer_key_type_ed25519, raw_public_key
     end
 
-    def raw_public_key
-      @public_key.to_bytes
-    end
-
     def signature_hint
       # take last 4 bytes
       account_id.to_xdr.slice(-4, 4)
     end
 
+    def raw_public_key
+      @public_key.to_bytes
+    end
+
     def raw_seed
+      raise "no private key" if @secret_key.nil?
       @secret_key.to_bytes
     end
 
@@ -82,25 +93,13 @@ module Stellar
       @public_key
     end
 
-    def address
-      pk_bytes = raw_public_key
-      Util::StrKey.check_encode(:account_id, pk_bytes)
-    end
-
-    def seed
-      raise "no private key" if @secret_key.nil?
-      # TODO: improve the error class above
-      seed_bytes = raw_seed
-      Util::StrKey.check_encode(:seed, seed_bytes)
-    end
-
     def sign?
       !@secret_key.nil?
     end
 
     def sign(message)
-      raise "no private key" if @secret_key.nil?
-      # TODO: improve the error class above
+      raise NotImplementedError, "no private key, signing is not available" unless sign?
+
       @secret_key.sign(message)
     end
 

data/lib/stellar/ledger_key.rb

@@ -4,6 +4,8 @@ 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
@@ -12,7 +14,7 @@ module Stellar
         field, value = options.first
         case field
         when nil
-          account(account_id: Stellar.KeyPair(account_id).account_id)
+          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
@@ -20,7 +22,7 @@ module Stellar
         when :data_name
           data(account_id: account_id, data_name: value.to_s)
         when :asset
-          trust_line(account_id: account_id, asset: Stellar.Asset(value))
+          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

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/operation.rb

@@ -3,8 +3,14 @@ require "bigdecimal"
 module Stellar
   class Operation
     MAX_INT64 = 2**63 - 1
+    TRUST_LINE_FLAGS_MAPPING = {
+      full: Stellar::TrustLineFlags.authorized_flag,
+      maintain_liabilities: Stellar::TrustLineFlags.authorized_to_maintain_liabilities_flag,
+      clawback_enabled: Stellar::TrustLineFlags.trustline_clawback_enabled_flag
+    }.freeze
 
     class << self
+      include Stellar::DSL
       #
       # Construct a new Stellar::Operation from the provided
       # source account and body
@@ -16,16 +22,17 @@ module Stellar
       # @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
+        if source_account && !source_account.is_a?(Stellar::KeyPair)
+          raise ArgumentError, "Bad :source_account"
         end
 
-        op
+        body = Stellar::Operation::Body.new(*attributes[:body])
+
+        Stellar::Operation.new(
+          body: body,
+          source_account: source_account&.muxed_account
+        )
       end
 
       #
@@ -233,7 +240,7 @@ module Stellar
 
       def begin_sponsoring_future_reserves(sponsored:, **attributes)
         op = BeginSponsoringFutureReservesOp.new(
-          sponsored_id: Stellar.KeyPair(sponsored).account_id
+          sponsored_id: KeyPair(sponsored).account_id
         )
 
         make(attributes.merge(body: [:begin_sponsoring_future_reserves, op]))
@@ -247,10 +254,10 @@ module Stellar
       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 = Stellar.KeyPair(sponsored).account_id
+        account_id = KeyPair(sponsored).account_id
         key, value = key_fields.first
         op = if key == :signer
-          RevokeSponsorshipOp.signer(account_id: account_id, signer_key: Stellar.SignerKey(value))
+          RevokeSponsorshipOp.signer(account_id: account_id, signer_key: SignerKey(value))
         else
           RevokeSponsorshipOp.ledger_key(LedgerKey.from(account_id: account_id, **key_fields))
         end
@@ -299,7 +306,7 @@ module Stellar
         op = ManageBuyOfferOp.new({
           buying: buying,
           selling: selling,
-          amount: amount,
+          buy_amount: amount,
           price: price,
           offer_id: offer_id
         })
@@ -370,11 +377,31 @@ module Stellar
         }))
       end
 
+      # @param asset [Stellar::Asset]
+      # @param trustor [Stellar::KeyPair]
+      # @param flags [{String, Symbol, Stellar::TrustLineFlags => true, false}] flags to to set or clear
+      # @param source_account [Stellar::KeyPair]  source account (default is `nil`, which will use the source account of transaction)
+      def set_trust_line_flags(asset:, trustor:, flags: {}, source_account: nil)
+        op = Stellar::SetTrustLineFlagsOp.new
+        op.trustor = KeyPair(trustor).account_id
+        op.asset = Asset(asset)
+        op.attributes = Stellar::TrustLineFlags.set_clear_masks(flags)
+
+        make(
+          source_account: source_account,
+          body: [:set_trust_line_flags, op]
+        )
+      end
+
+      # DEPRECATED in favor of `set_trustline_flags`
       #
       # Helper method to create a valid AllowTrustOp, wrapped
       # in the necessary XDR structs to be included within a
       # transactions `operations` array.
       #
+      # @deprecated Use `set_trustline_flags` operation
+      #   See {https://github.com/stellar/stellar-protocol/blob/master/core/cap-0035.md#allow-trust-operation-1 CAP-35 description}
+      #   for more details
       # @param [Hash] attributes the attributes to create the operation with
       # @option attributes [Stellar::KeyPair] :trustor
       # @option attributes [Stellar::Asset] :asset
@@ -386,7 +413,8 @@ module Stellar
         op = AllowTrustOp.new
 
         trustor = attributes[:trustor]
-        authorize = attributes[:authorize]
+        # we handle booleans here for the backward compatibility
+        authorize = attributes[:authorize].yield_self { |value| value == true ? :full : value }
         asset = attributes[:asset]
         if asset.is_a?(Array)
           asset = Asset.send(*asset)
@@ -394,20 +422,21 @@ module Stellar
 
         raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Stellar::KeyPair)
 
-        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
+        allowed_flags = TRUST_LINE_FLAGS_MAPPING.slice(:full, :maintain_liabilities)
+
+        # we handle booleans here for the backward compatibility
+        op.authorize = if allowed_flags.key?(authorize)
+          allowed_flags[authorize].value
+        elsif [:none, false].include?(authorize)
+          0
         else
           raise ArgumentError, "Bad :authorize, supported values: :full, :maintain_liabilities, :none"
         end
 
         raise ArgumentError, "Bad :asset" unless asset.type == Stellar::AssetType.asset_type_credit_alphanum4
 
-        atc = AllowTrustOp::Asset.new(:asset_type_credit_alphanum4, asset.code)
-
         op.trustor = trustor.account_id
-        op.asset = atc
+        op.asset = AssetCode.new(:asset_type_credit_alphanum4, asset.code)
 
         make(attributes.merge({
           body: [:allow_trust, op]
@@ -492,6 +521,47 @@ module Stellar
         }))
       end
 
+      def clawback(source_account:, from:, amount:)
+        asset, amount = get_asset_amount(amount)
+
+        if amount == 0
+          raise ArgumentError, "Amount can not be zero"
+        end
+
+        if amount < 0
+          raise ArgumentError, "Negative amount is not allowed"
+        end
+
+        op = ClawbackOp.new(
+          amount: amount,
+          from: from.muxed_account,
+          asset: asset
+        )
+
+        make({
+          source_account: source_account,
+          body: [:clawback, op]
+        })
+      end
+
+      # Helper method to create clawback claimable balance operation
+      #
+      # @param [Stellar::KeyPair] source_account the attributes to create the operation with
+      # @param [String] balance_id `ClaimableBalanceID`, serialized in hex
+      #
+      # @return [Stellar::Operation] the built operation
+      def clawback_claimable_balance(source_account:, balance_id:)
+        balance_id = Stellar::ClaimableBalanceID.from_xdr(balance_id, :hex)
+        op = ClawbackClaimableBalanceOp.new(balance_id: balance_id)
+
+        make(
+          source_account: source_account,
+          body: [:clawback_claimable_balance, op]
+        )
+      rescue XDR::ReadError
+        raise ArgumentError, "Claimable balance id '#{balance_id}' is invalid"
+      end
+
       private
 
       def get_asset_amount(values)

data/lib/stellar/transaction.rb

@@ -29,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

@@ -1,5 +1,7 @@
 module Stellar
   class TransactionBuilder
+    include Stellar::DSL
+
     attr_reader :source_account, :sequence_number, :base_fee, :time_bounds, :memo, :operations
 
     class << self
@@ -29,21 +31,20 @@ module Stellar
       base_fee: 100,
       time_bounds: nil,
       memo: nil,
+      enable_muxed_accounts: 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
       raise ArgumentError, "Bad :time_bounds" unless time_bounds.is_a?(Stellar::TimeBounds) || time_bounds.nil?
       raise ArgumentError, "Bad :base_fee" unless base_fee.is_a?(Integer) && base_fee >= 100
 
-      @source_account = source_account
+      @source_account = Account(source_account)
       @sequence_number = sequence_number
       @base_fee = base_fee
       @time_bounds = time_bounds
+      @enable_muxed_accounts = enable_muxed_accounts
 
-      if time_bounds.nil?
-        set_timeout(0)
-      end
+      set_timeout(0) if time_bounds.nil?
 
       @memo = make_memo(memo)
       @operations = []
@@ -59,7 +60,7 @@ module Stellar
       end
 
       attrs = {
-        source_account: @source_account.muxed_account,
+        source_account: source_muxed_account,
         fee: @base_fee * @operations.length,
         seq_num: @sequence_number,
         time_bounds: @time_bounds,
@@ -90,7 +91,7 @@ module Stellar
       end
 
       Stellar::FeeBumpTransaction.new(
-        fee_source: @source_account.muxed_account,
+        fee_source: source_muxed_account,
         fee: @base_fee * (inner_ops.length + 1),
         inner_tx: Stellar::FeeBumpTransaction::InnerTx.new(:envelope_type_tx, inner_txe.v1!),
         ext: Stellar::FeeBumpTransaction::Ext.new(0)
@@ -162,5 +163,17 @@ module Stellar
         raise ArgumentError, "Bad :memo"
       end
     end
+
+    def source_muxed_account
+      if with_muxed_accounts?
+        @source_account.muxed_account
+      else
+        @source_account.base_account
+      end
+    end
+
+    def with_muxed_accounts?
+      @enable_muxed_accounts
+    end
   end
 end

data/lib/stellar/transaction_envelope.rb

@@ -1,13 +1,7 @@
 module Stellar
   class TransactionEnvelope
-    # Delegates any undefined method to the currently set arm
-    def method_missing(method, *args, &block)
-      value&.public_send(method, *args) || super
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      %w[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`
@@ -19,23 +13,19 @@ module Stellar
     #
     # @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]