digitalbits-base 0.27.1

data/generated/digitalbits/upgrade_entry_meta.rb

@@ -0,0 +1,20 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct UpgradeEntryMeta
+#   {
+#       LedgerUpgrade upgrade;
+#       LedgerEntryChanges changes;
+#   };
+#
+# ===========================================================================
+module Digitalbits
+  class UpgradeEntryMeta < XDR::Struct
+    attribute :upgrade, LedgerUpgrade
+    attribute :changes, LedgerEntryChanges
+  end
+end

data/lib/digitalbits-base.rb

@@ -0,0 +1,51 @@
+require "xdr"
+require "rbnacl"
+require "digest/sha2"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/kernel/reporting"
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+require "active_support/core_ext/module/delegation"
+require "active_support/deprecation"
+
+require_relative "digitalbits/ext/xdr"
+
+# See ../generated for code-gen'ed files
+silence_warnings do
+  require "digitalbits-base-generated"
+end
+DigitalBits.load_all!
+
+require_relative "digitalbits/version"
+
+DigitalBits::ONE = 1_0000000
+DigitalBits::Deprecation = ActiveSupport::Deprecation.new("next release", "digitalbits-base")
+
+# extensions onto the generated files must be loaded manually, below
+
+require_relative "./digitalbits/account_flags"
+require_relative "./digitalbits/asset"
+require_relative "./digitalbits/claim_predicate"
+require_relative "./digitalbits/key_pair"
+require_relative "./digitalbits/ledger_key"
+require_relative "./digitalbits/networks"
+require_relative "./digitalbits/operation"
+require_relative "./digitalbits/path_payment_strict_receive_result"
+require_relative "./digitalbits/price"
+require_relative "./digitalbits/signer_key"
+require_relative "./digitalbits/thresholds"
+require_relative "./digitalbits/trust_line_flags"
+
+require_relative "./digitalbits/concerns/transaction"
+require_relative "./digitalbits/fee_bump_transaction"
+require_relative "./digitalbits/transaction"
+require_relative "./digitalbits/transaction_builder"
+require_relative "./digitalbits/transaction_envelope"
+require_relative "./digitalbits/transaction_v0"
+
+require_relative "./digitalbits/util/strkey"
+require_relative "./digitalbits/convert"
+
+require_relative "./digitalbits/dsl"
+
+require_relative "./digitalbits/compat"

data/lib/digitalbits/account_flags.rb

@@ -0,0 +1,26 @@
+module DigitalBits
+  class AccountFlags
+    #
+    # Converts an array of DigitalBits::AccountFlags members into
+    # an Integer suitable for use in a SetOptionsOp.
+    #
+    # @param flags [Array<DigitalBits::AccountFlags>] the flags to combine
+    #
+    # @return [Fixnum] the combined result
+    def self.make_mask(flags = nil)
+      flags ||= []
+
+      flags.map(&:value).inject(&:|) || 0
+    end
+
+    #
+    # Converts an integer used in SetOptionsOp on the set/clear flag options
+    # into an array of DigitalBits::AccountFlags members
+    #
+    #  @param combined [Fixnum]
+    #  @return [Array<DigitalBits::AccountFlags>]
+    def self.parse_mask(combined)
+      members.values.select { |m| (m.value & combined) != 0 }
+    end
+  end
+end

data/lib/digitalbits/asset.rb

@@ -0,0 +1,81 @@
+module DigitalBits
+  class Asset
+    TYPES = %i[native alphanum4 alphanum12]
+
+    def self.native
+      new(:asset_type_native)
+    end
+
+    # @param code   [String] asset code
+    # @param issuer [#to_keypair] asset issuer
+    #
+    # @return [DigitalBits::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 [DigitalBits::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})
+      new(:asset_type_credit_alphanum12, an)
+    end
+
+    def to_s
+      case switch
+      when AssetType.asset_type_native
+        "native"
+      when AssetType.asset_type_credit_alphanum4
+        anum = alpha_num4!
+        issuer_address = DigitalBits::Convert.pk_to_address(anum.issuer)
+        "#{anum.asset_code}/#{issuer_address}"
+      when AssetType.asset_type_credit_alphanum12
+        anum = alpha_num12!
+        issuer_address = DigitalBits::Convert.pk_to_address(anum.issuer)
+        "#{anum.asset_code}/#{issuer_address}"
+      end
+    end
+
+    def inspect
+      # label = switch.to_s
+      "#<DigitalBits::Asset #{self}>"
+    end
+
+    def code
+      case switch
+      when AssetType.asset_type_credit_alphanum4
+        alpha_num4!.asset_code
+      when AssetType.asset_type_credit_alphanum12
+        alpha_num12!.asset_code
+      else
+        raise "#{switch} assets do not have a code"
+      end
+    end
+
+    def issuer
+      case switch
+      when AssetType.asset_type_credit_alphanum4
+        alpha_num4!.issuer
+      when AssetType.asset_type_credit_alphanum12
+        alpha_num12!.issuer
+      else
+        raise "#{switch} assets do not have a isuuer"
+      end
+    end
+
+    def self.normalize_code(code, length)
+      raise ArgumentError, "Invalid asset code: #{code}, must be <= #{length} bytes" if code.length > length
+
+      code.ljust(length, "\x00")
+    end
+  end
+end

data/lib/digitalbits/base.rb

@@ -0,0 +1 @@
+require "digitalbits-base"

data/lib/digitalbits/claim_predicate.rb

@@ -0,0 +1,197 @@
+# frozen_string_literals: true
+require "active_support/core_ext/integer/time"
+require "active_support/core_ext/string/conversions"
+
+module DigitalBits
+  # Represents claim predicate on DigitalBits network.
+  #
+  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 DigitalBits::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 DigitalBits::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 digitalbits-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/digitalbits/compat.rb

@@ -0,0 +1,9 @@
+class << DigitalBits::Operation
+  alias_method :manage_offer, :manage_sell_offer
+  alias_method :create_passive_offer, :create_passive_sell_offer
+
+  deprecate deprecator: DigitalBits::Deprecation,
+            manage_offer: :manage_sell_offer,
+            create_passive_offer: :create_passive_sell_offer,
+            allow_trust: :set_trust_line_flags
+end

data/lib/digitalbits/concerns/transaction.rb

@@ -0,0 +1,50 @@
+module DigitalBits::Concerns
+  module Transaction
+    # Returns the string of bytes that, when hashed, provide the value which
+    # should be signed to create a valid digitalbits transaction signature
+    def signature_base
+      signature_base_prefix + to_xdr
+    end
+
+    def sign(key_pair)
+      key_pair.sign(hash)
+    end
+
+    def sign_decorated(key_pair)
+      key_pair.sign_decorated(hash)
+    end
+
+    def hash
+      Digest::SHA256.digest(signature_base)
+    end
+
+    def merge(other)
+      cloned = from_xdr(to_xdr)
+      cloned.operations += other.to_operations
+      cloned
+    end
+
+    #
+    # Extracts the operations from this single transaction,
+    # setting the source account on the extracted operations.
+    #
+    # Useful for merging transactions.
+    #
+    # @return [Array<Operation>] the operations
+    def to_operations
+      codec = XDR::VarArray[DigitalBits::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
+
+    def apply_defaults
+      self.operations ||= []
+      self.fee ||= 100
+      self.memo ||= DigitalBits::Memo.new(:memo_none)
+      self.ext ||= DigitalBits::Transaction::Ext.new 0
+    end
+  end
+end