stellar-base 0.23.1 → 0.27.0

data/lib/stellar/compat.rb

@@ -1,21 +1,9 @@
-require "active_support/deprecation"
-
-Stellar::Deprecation ||= ActiveSupport::Deprecation.new("next release", "stellar-base")
-
 class << Stellar::Operation
-  alias manage_offer manage_sell_offer
-  alias create_passive_offer create_passive_sell_offer
-
-  deprecate deprecator: Stellar::Deprecation,
-            manage_offer: :manage_sell_offer,
-            create_passive_offer: :create_passive_sell_offer
-end
-
-class << Stellar::Transaction
-  alias manage_offer manage_sell_offer
-  alias create_passive_offer create_passive_sell_offer
+  alias_method :manage_offer, :manage_sell_offer
+  alias_method :create_passive_offer, :create_passive_sell_offer
 
   deprecate deprecator: Stellar::Deprecation,
             manage_offer: :manage_sell_offer,
-            create_passive_offer: :create_passive_sell_offer
+            create_passive_offer: :create_passive_sell_offer,
+            allow_trust: :set_trust_line_flags
 end

data/lib/stellar/concerns/transaction.rb

@@ -19,7 +19,7 @@ module Stellar::Concerns
     end
 
     def merge(other)
-      cloned = Marshal.load Marshal.dump(self)
+      cloned = from_xdr(to_xdr)
       cloned.operations += other.to_operations
       cloned
     end
@@ -32,9 +32,10 @@ module Stellar::Concerns
     #
     # @return [Array<Operation>] the operations
     def to_operations
-      # FIXME: what was the purpose of this?
-      # cloned = Marshal.load Marshal.dump(operations)
-      operations.each do |op|
+      codec = XDR::VarArray[Stellar::Operation]
+      ops = respond_to?(:operations) ? operations : inner_tx.value.tx.operations
+      cloned = codec.from_xdr(codec.to_xdr(ops))
+      cloned.each do |op|
         op.source_account ||= source_account
       end
     end

data/lib/stellar/dsl.rb

@@ -0,0 +1,93 @@
+module Stellar
+  module DSL
+    module_function
+
+    # Constructs a new ClaimPredicate using DSL
+    #
+    # @example fulfilled during [T+5min, T+60min] period, where T refers to claimable balance entry creation time
+    #   Stellar::ClaimPredicate { before_relative_time(1.hour) & ~before_relative_time(5.minutes) }
+    #
+    # @example not fulfilled starting from today midnight until tomorrow midnight,
+    #   Stellar::ClaimPredicate { before_absolute_time(Date.today.end_of_day) | ~before_absolute_time(Date.tomorrow.end_of_day) }
+    #
+    # @example always fulfilled
+    #   Stellar::ClaimPredicate { }
+    def ClaimPredicate(&block)
+      return ClaimPredicate.unconditional unless block
+      ClaimPredicate.compose(&block)
+    end
+
+    def Claimant(destination, &block)
+      Claimant.new(
+        ClaimantType.claimant_type_v0,
+        Claimant::V0.new(
+          destination: KeyPair(destination).account_id,
+          predicate: ClaimPredicate(&block)
+        )
+      )
+    end
+
+    # @param [Asset, String, nil] subject
+    # @return [Stellar::Asset] instance of the Stellar::Asset
+    # @raise [TypeError] if subject cannot be converted to Stellar::Asset
+    def Asset(subject = nil)
+      case subject
+      when Asset
+        subject
+      when nil, /^(XLM[-:])?native$/
+        Asset.native
+      when /^([0-9A-Z]{1,4})[-:](G[A-Z0-9]{55})$/
+        Asset.alphanum4($1, KeyPair($2))
+      when /^([0-9A-Z]{5,12})[-:](G[A-Z0-9]{55})$/
+        Asset.alphanum12($1, KeyPair($2))
+      else
+        raise TypeError, "Cannot convert #{subject.inspect} to Stellar::Asset"
+      end
+    end
+
+    # Generates Stellar::Keypair from subject, use Stellar::Client.to_keypair as shortcut.
+    # @param subject [String|Stellar::Account|Stellar::PublicKey|Stellar::SignerKey|Stellar::Keypair] subject.
+    # @return [Stellar::Keypair] Stellar::Keypair instance.
+    # @raise [TypeError] if subject cannot be converted to Stellar::KeyPair
+    def KeyPair(subject = nil)
+      case subject
+      when ->(subj) { subj.respond_to?(:to_keypair) }
+        subject.to_keypair
+      when PublicKey
+        KeyPair.from_public_key(subject.value)
+      when SignerKey
+        KeyPair.from_raw_seed(subject.value)
+      when /^G[A-Z0-9]{55}$/
+        KeyPair.from_address(subject.to_str)
+      when /^S[A-Z0-9]{55}$/
+        KeyPair.from_seed(subject.to_str)
+      when /^.{32}$/
+        KeyPair.from_raw_seed(subject.to_str)
+      when nil
+        KeyPair.random
+      else
+        raise TypeError, "cannot convert #{subject.inspect} to Stellar::KeyPair"
+      end
+    end
+
+    # Provides conversion from different input types into the SignerKey to use in ManageData operation.
+    # @param input [String|zStellar::Account|Stellar::PublicKey|Stellar::SignerKey|Stellar::Keypair] subject.
+    # @return [Stellar::SignerKey] Stellar::Keypair instance.
+    def SignerKey(input = nil)
+      case input
+      when Transaction
+        SignerKey.pre_auth_tx(input.hash)
+      when /^[0-9A-Za-z+\/=]{44}$/
+        SignerKey.hash_x(Stellar::Convert.from_base64(input))
+      when /^[0-9a-f]{64}$/
+        SignerKey.hash_x(Stellar::Convert.from_hex(input))
+      when /^.{32}$/
+        SignerKey.hash_x(input)
+      else
+        SignerKey.ed25519(KeyPair(input))
+      end
+    end
+  end
+
+  include DSL
+end

data/lib/stellar/ext/xdr.rb

@@ -0,0 +1,50 @@
+require "active_support/core_ext/string/inflections"
+require "xdr"
+
+# For every member of XDR::Enum define constant on the corresponding enum type class.
+# Constant name is a member name stripped of the common prefix with enum type name.
+XDR::DSL::Enum.redefine_method(:seal) do
+  names = [members.keys.first, name.demodulize.underscore + "_"].join(" ")
+  common_prefix = /\A(.*_).* \1.*\Z/.match(names)&.values_at(1)&.first
+  members.each do |name, value|
+    unless common_prefix.nil?
+      full_name, name = [name, name.delete_prefix(common_prefix)]
+      singleton_class.alias_method(name, full_name)
+    end
+    const_set(name.upcase, value)
+  end
+  self.sealed = true
+end
+
+XDR::DSL::Union.redefine_method(:switch) do |switch, arm = nil|
+  raise ArgumentError, "`switch_on` not defined yet" if switch_type.nil?
+
+  switch = normalize_switch_declaration(switch)
+  self.switches = switches.merge(switch => arm)
+
+  unless arm.nil?
+    define_singleton_method(arm) do |*args, **kwargs|
+      value_type = arms[arm]
+      value = if value_type.valid?(args.first)
+        args.first
+      elsif value_type.ancestors.include?(XDR::Struct)
+        value_type.new(kwargs)
+      elsif value_type.ancestors.include?(XDR::Union)
+        value_type.new(*args[0..1])
+      else
+        args.first
+      end
+      new(switch, value)
+    end
+  end
+end
+
+# 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

@@ -1,44 +1,58 @@
 module Stellar
   class KeyPair
-    def self.from_seed(seed)
-      seed_bytes = Util::StrKey.check_decode(:seed, seed)
-      from_raw_seed seed_bytes
-    end
-
-    def self.from_raw_seed(seed_bytes)
-      secret_key = RbNaCl::SigningKey.new(seed_bytes)
-      public_key = secret_key.verify_key
-      new(public_key, secret_key)
-    end
-
-    def self.from_public_key(pk_bytes)
-      public_key = RbNaCl::VerifyKey.new(pk_bytes)
-      new(public_key)
-    end
-
-    def self.from_address(address)
-      pk_bytes = Util::StrKey.check_decode(:account_id, address)
-      from_public_key(pk_bytes)
-    end
-
-    def self.random
-      secret_key = RbNaCl::SigningKey.generate
-      public_key = secret_key.verify_key
-      new(public_key, secret_key)
-    end
-
-    def self.from_network_passphrase(passphrase)
-      network_id = Digest::SHA256.digest(passphrase)
-      from_raw_seed network_id
+    module FactoryMethods
+      def from_seed(seed)
+        seed_bytes = Util::StrKey.check_decode(:seed, seed)
+        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
+        new(public_key, secret_key)
+      end
+
+      def from_public_key(pk_bytes)
+        public_key = RbNaCl::VerifyKey.new(pk_bytes)
+        new(public_key)
+      end
+
+      def random
+        secret_key = RbNaCl::SigningKey.generate
+        public_key = secret_key.verify_key
+        new(public_key, secret_key)
+      end
+
+      def from_network_passphrase(passphrase)
+        network_id = Digest::SHA256.digest(passphrase)
+        from_raw_seed network_id
+      end
+
+      def master
+        from_raw_seed(Stellar.current_network_id)
+      end
+    end
+
+    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 self.master
-      from_raw_seed(Stellar.current_network_id)
+    def address
+      Util::StrKey.check_encode(:account_id, raw_public_key)
     end
 
-    def initialize(public_key, secret_key = nil)
-      @public_key = public_key
-      @secret_key = secret_key
+    def seed
+      Util::StrKey.check_encode(:seed, raw_seed)
     end
 
     def account_id
@@ -57,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
 
@@ -78,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
 
@@ -115,5 +118,9 @@ module Stellar
     rescue RbNaCl::BadSignatureError
       false
     end
+
+    def to_keypair
+      self
+    end
   end
 end

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

@@ -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
 
       #
@@ -168,7 +175,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 +206,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)
@@ -242,7 +306,7 @@ module Stellar
         op = ManageBuyOfferOp.new({
           buying: buying,
           selling: selling,
-          amount: amount,
+          buy_amount: amount,
           price: price,
           offer_id: offer_id
         })
@@ -313,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
@@ -329,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)
@@ -337,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]
@@ -435,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)