stellar-base 0.23.0.rc2 → 0.25.0

data/lib/stellar/account_flags.rb

@@ -4,7 +4,7 @@ module Stellar
     # Converts an array of Stellar::AccountFlags members into
     # an Integer suitable for use in a SetOptionsOp.
     #
-    # @param flags=nil [Array<Stellar::AccountFlags>] the flags to combine
+    # @param flags [Array<Stellar::AccountFlags>] the flags to combine
     #
     # @return [Fixnum] the combined result
     def self.make_mask(flags = nil)

data/lib/stellar/asset.rb

@@ -6,14 +6,24 @@ module Stellar
       new(:asset_type_native)
     end
 
+    # @param code   [String] asset code
+    # @param issuer [#to_keypair] asset issuer
+    #
+    # @return [Stellar::Asset::AlphaNum4] asset4 representation
     def self.alphanum4(code, issuer)
+      issuer = issuer.to_keypair if issuer.respond_to?(:to_keypair)
       raise ArgumentError, "Bad :issuer" unless issuer.is_a?(KeyPair)
       code = normalize_code(code, 4)
       an = AlphaNum4.new({asset_code: code, issuer: issuer.account_id})
       new(:asset_type_credit_alphanum4, an)
     end
 
+    # @param code   [String] asset code
+    # @param issuer [#to_keypair] asset issuer
+    #
+    # @return [Stellar::Asset::AlphaNum4] asset4 representation
     def self.alphanum12(code, issuer)
+      issuer = issuer.to_keypair if issuer.respond_to?(:to_keypair)
       raise ArgumentError, "Bad :issuer" unless issuer.is_a?(KeyPair)
       code = normalize_code(code, 12)
       an = AlphaNum12.new({asset_code: code, issuer: issuer.account_id})

data/lib/stellar/{version.rb → base/version.rb}

@@ -1,5 +1,5 @@
 module Stellar
   module Base
-    VERSION = "0.23.0.rc2"
+    VERSION = "0.25.0"
   end
 end

data/lib/stellar/claim_predicate.rb

@@ -0,0 +1,198 @@
+# frozen_string_literals: true
+require "active_support/core_ext/integer/time"
+require "active_support/core_ext/string/conversions"
+
+module Stellar
+  # Represents claim predicate on Stellar network.
+  #
+  # @see https://developers.stellar.org/docs/glossary/claimable-balance/
+  class ClaimPredicate
+    module FactoryMethods
+      # Constructs an `unconditional` claim predicate.
+      #
+      # This predicate will be always fulfilled.
+      #
+      # @return [ClaimPredicate] `unconditional` claim predicate
+      def unconditional
+        ClaimPredicate.new(ClaimPredicateType::UNCONDITIONAL)
+      end
+
+      # Constructs a `before_relative_time` claim predicate.
+      #
+      # This predicate will be fulfilled if the closing time of the ledger that includes
+      # the Stellar::CreateClaimableBalance operation plus this relative time delta (in seconds)
+      # is less than the current time.
+      #
+      # @param seconds [#to_int|#to_i] seconds since `closeTime` of the ledger in which
+      #                                the ClaimableBalanceEntry was created.
+      # @return [ClaimPredicate] `before_relative_time` claim predicate
+      def before_relative_time(seconds)
+        ClaimPredicate.new(ClaimPredicateType::BEFORE_RELATIVE_TIME, Integer(seconds))
+      end
+
+      # Constructs an `before_absolute_time` claim predicate.
+      #
+      # This predicate will be fulfilled if the closing time of the ledger that includes
+      # the Stellar::CreateClaimableBalance operation is less than provided timestamp.
+      #
+      # @param timestamp [#to_time|#to_int|#to_i] time value or timestamp
+      #
+      # @return [ClaimPredicate] `before_absolute_time` claim predicate.
+      def before_absolute_time(timestamp)
+        timestamp = timestamp.to_time if timestamp.respond_to?(:to_time)
+
+        ClaimPredicate.new(ClaimPredicateType::BEFORE_ABSOLUTE_TIME, Integer(timestamp))
+      end
+
+      # Constructs either relative or absolute time predicate based on the type of the input.
+      #
+      # If input is an instance of `ActiveSupport::Duration` class it will be handled as a relative time
+      # (seconds since close time of the ledger), otherwise it will be treated as an absolute time.
+      #
+      # It is intended to work with time helpers provided by ActiveSupport, like `1.day` (relative)
+      # or `2.weeks.from_now` (absolute).
+      #
+      # @example relative time
+      #   ClaimPredicate.before(2.days + 15.seconds)
+      #
+      # @example absolute time
+      #   ClaimPredicate.before(5.hours.from_now)
+      #
+      # @param time [ActiveSupport::Duration|#to_time|#to_i] duration since ledger close time or absolute time value
+      #
+      # @return [ClaimPredicate] `before_relative_time` or `before_absolute_time` claim predicate.
+      def before(time)
+        ActiveSupport::Duration === time ? before_relative_time(time.to_i) : before_absolute_time(time)
+      end
+
+      # Constructs a negated predicate from either relative or absolute time based on the type of the input.
+      #
+      # @see #before
+      # @param (see #before)
+      # @return (see #before)
+      def after(time)
+        ~before(time)
+      end
+
+      # Compose a complex predicate by calling DSL methods from the block.
+      #
+      # @example
+      #   ClaimPredicate.compose {
+      #     after(15.minutes) & before(1.day) | after(1.week.from_now) & before(1.week.from_now + 1.day)
+      #   }
+      #
+      # @yieldreturn [ClaimPredicate|nil]
+      # @return [ClaimPredicate] `not(before_relative_time)` or `not(before_absolute_time)` claim predicate.
+      def compose(&block)
+        result = instance_eval(&block)
+        result.nil? ? unconditional : result
+      end
+    end
+
+    extend FactoryMethods
+
+    # Constructs an `and` claim predicate.
+    #
+    # This predicate will be fulfilled if both `self` and `other` predicates are fulfilled.
+    #
+    # @param other [ClaimPredicate] another predicate
+    #
+    # @return [ClaimPredicate] `and` claim predicate
+    def and(other)
+      raise TypeError, "no conversion from #{other.class.name} to ClaimPredicate" unless ClaimPredicate === other
+      ClaimPredicate.new(ClaimPredicateType::AND, [self, other])
+    end
+    alias_method :&, :and
+
+    # Constructs an `or` claim predicate.
+    #
+    # This predicate will be fulfilled if either of `self` or `other` predicates is fulfilled.
+    #
+    # @param other [ClaimPredicate] another predicate.
+    #
+    # @return [ClaimPredicate] `or` claim predicate
+    def or(other)
+      raise TypeError, "no conversion from #{other.class.name} to ClaimPredicate" unless ClaimPredicate === other
+      ClaimPredicate.new(ClaimPredicateType::OR, [self, other])
+    end
+    alias_method :|, :or
+
+    # Constructs a `not` claim predicate.
+    #
+    # This predicate will be fulfilled if `self` is not fulfilled.
+    #
+    # @return [ClaimPredicate] `not` claim predicate
+    def not
+      ClaimPredicate.new(ClaimPredicateType::NOT, self)
+    end
+    alias_method :~@, :not
+
+    # Evaluates the predicate value for provided inputs.
+    #
+    # @param created_at [#to_time|#to_int] closing time of the ledger containing CreateClaimableBalance operation
+    # @param claiming_at [#to_time|#to_int|ActiveSupport::Duration] time point to evaluate predicate at, either
+    #   absolute time or duration relative to `created_at`. In reality predicate will be evaluated by stellar-core
+    #   using the closing time of a ledger containing ClaimClaimableBalance operation, in either successful
+    #   or failed state.
+    #
+    # @return [Boolean] `true` if this predicate would allow claiming the balance, `false` otherwise
+    def evaluate(created_at, claiming_at)
+      created_at = created_at.to_time if created_at.respond_to?(:to_time)
+      claiming_at = created_at + claiming_at if claiming_at.is_a?(ActiveSupport::Duration)
+      claiming_at = claiming_at.to_time if claiming_at.respond_to?(:to_time)
+
+      return false if claiming_at < created_at
+
+      case switch
+      when ClaimPredicateType::UNCONDITIONAL
+        true
+      when ClaimPredicateType::BEFORE_RELATIVE_TIME
+        Integer(claiming_at) < Integer(created_at) + value
+      when ClaimPredicateType::BEFORE_ABSOLUTE_TIME
+        Integer(claiming_at).to_i < value
+      when ClaimPredicateType::AND
+        value[0].evaluate(created_at, claiming_at) && value[1].evaluate(created_at, claiming_at)
+      when ClaimPredicateType::OR
+        value[0].evaluate(created_at, claiming_at) || value[1].evaluate(created_at, claiming_at)
+      when ClaimPredicateType::NOT
+        !value.evaluate(created_at, claiming_at)
+      else
+        raise ArgumentError, "evaluation is not implemented for #{switch.name} predicate"
+      end
+    end
+
+    def describe
+      case switch
+      when ClaimPredicateType::UNCONDITIONAL
+        "always"
+      when ClaimPredicateType::BEFORE_RELATIVE_TIME
+        dur = ActiveSupport::Duration.build(value)
+        "less than #{dur.inspect} since creation"
+      when ClaimPredicateType::BEFORE_ABSOLUTE_TIME
+        "before #{Time.at(value).to_formatted_s(:db)}"
+      when ClaimPredicateType::AND
+        value.map(&:describe).join(" and ")
+      when ClaimPredicateType::OR
+        "(" << value.map(&:describe).join(" or ") << ")"
+      when ClaimPredicateType::NOT
+        case value.switch
+        when ClaimPredicateType::UNCONDITIONAL
+          "never"
+        when ClaimPredicateType::BEFORE_RELATIVE_TIME
+          dur = ActiveSupport::Duration.build(value.value)
+          "#{dur.inspect} or more since creation"
+        when ClaimPredicateType::BEFORE_ABSOLUTE_TIME
+          "after #{Time.at(value.value).to_formatted_s(:db)}"
+        else
+          "not (#{value.describe})"
+        end
+      else
+        raise ArgumentError, "evaluation is not implemented for #{switch.name} predicate"
+      end
+    end
+
+    def inspect
+      "#<ClaimPredicate: #{describe}>"
+    end
+  end
+end

data/lib/stellar/compat.rb

@@ -1,19 +1,6 @@
-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,

data/lib/stellar/concerns/transaction.rb

@@ -32,9 +32,8 @@ 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|
+      cloned = Marshal.load Marshal.dump(operations)
+      cloned.each do |op|
         op.source_account ||= source_account
       end
     end

data/lib/stellar/dsl.rb

@@ -0,0 +1,89 @@
+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
+
+    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.
+    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