digitalbits-base 0.27.1

data/lib/digitalbits/path_payment_strict_receive_result.rb

@@ -0,0 +1,16 @@
+module DigitalBits
+  class PathPaymentStrictReceiveResult
+    # send_amount returns the actual amount paid for the corresponding
+    # PathPaymentOp to this result.
+    #
+    def send_amount
+      s = success!
+      return s.last.amount if s.offers.blank?
+
+      source_asset = s.offers.first.asset_bought
+      source_offers = s.offers.take_while { |o| o.asset_bought == source_asset }
+
+      source_offers.map(&:amount_bought).sum
+    end
+  end
+end

data/lib/digitalbits/price.rb

@@ -0,0 +1,39 @@
+module DigitalBits
+  # reopen class
+  class Price
+    MAX_PRECISION = (2**31) - 1
+
+    def self.from_f(number)
+      best_r = number.to_r.rationalize(1.0e-7)
+
+      if best_r.numerator > MAX_PRECISION || best_r.denominator > MAX_PRECISION
+        raise ArgumentError("Couldn't find price approximation")
+      end
+
+      new({
+        n: best_r.numerator,
+        d: best_r.denominator
+      })
+    end
+
+    def invert
+      self.class.new(n: d, d: n)
+    end
+
+    def to_d
+      n.to_d / d
+    end
+
+    def to_f
+      n.to_f / d
+    end
+
+    def to_s
+      "#{n} / #{d}"
+    end
+
+    def inspect
+      "#<DigitalBits::Price #{self}>"
+    end
+  end
+end

data/lib/digitalbits/signer_key.rb

@@ -0,0 +1,46 @@
+module DigitalBits
+  class SignerKey
+    PREIMAGE_LENGTH = 32
+
+    def self.ed25519(keypair)
+      raise ArgumentError, "Bad keypair" unless keypair.is_a?(KeyPair)
+      new(:signer_key_type_ed25519, keypair.raw_public_key)
+    end
+
+    def self.preauthorized_transaction(tx)
+      new(:signer_key_type_pre_auth_tx, tx.hash)
+    end
+
+    def self.hash_x(preimage)
+      raise ArgumentError, "Must be string" unless preimage.is_a?(String)
+      raise ArgumentError, "Must be 32 bytes" unless preimage.bytesize == PREIMAGE_LENGTH
+
+      hash_x = Digest::SHA256.digest(preimage)
+      new(:signer_key_type_hash_x, hash_x)
+    end
+
+    def to_s
+      case switch
+      when SignerKeyType.signer_key_type_ed25519
+        address = DigitalBits::Convert.pk_to_address(self)
+        "ed25519: #{address}"
+      when SignerKeyType.signer_key_type_pre_auth_tx
+        tx = DigitalBits::Convert.to_hex(pre_auth_tx!)
+        "pre_auth_tx: #{tx}"
+      when SignerKeyType.signer_key_type_hash_x
+        hx = DigitalBits::Convert.to_hex(hash_x!)
+        "hash_x: #{hx}"
+      end
+    end
+
+    def inspect
+      # label = switch.to_s
+      "#<DigitalBits::SignerKey #{self}>"
+    end
+
+    def signature_hint
+      # take last 4 bytes
+      value.to_xdr.slice(-4, 4)
+    end
+  end
+end

data/lib/digitalbits/thresholds.rb

@@ -0,0 +1,37 @@
+module DigitalBits
+  class << Thresholds
+    COMPONENTS = [:master_weight, :low, :medium, :high]
+    VALID_RANGE = 0..255
+
+    def make(thresholds = {})
+      # error if any of the needed components are not provided
+      if COMPONENTS.any? { |c| thresholds[c].blank? }
+        raise ArgumentError, "invalid thresholds hash, must have #{COMPONENTS.inspect} keys, had: #{thresholds.keys.inspect}"
+      end
+
+      # error if any of the needed components are not numbers 0 <= N <= 255
+      COMPONENTS.each do |c|
+        good = true
+
+        good &&= thresholds[c].is_a?(Integer)
+        good &&= VALID_RANGE.include? thresholds[c]
+
+        unless good
+          raise ArgumentError, "invalid #{c.inspect}, must be number in (0..255), got #{thresholds[c].inspect}"
+        end
+      end
+
+      thresholds.values_at(*COMPONENTS).pack("C*")
+    end
+
+    def parse(combined)
+      master_weight, low, medium, high = combined.unpack("C*")
+      {
+        master_weight: master_weight,
+        low: low,
+        medium: medium,
+        high: high
+      }
+    end
+  end
+end

data/lib/digitalbits/transaction.rb

@@ -0,0 +1,37 @@
+module DigitalBits
+  class Transaction
+    include DigitalBits::Concerns::Transaction
+
+    def to_v0
+      ed25519 = if source_account.switch == DigitalBits::CryptoKeyType.key_type_ed25519
+        source_account.ed25519!
+      else
+        source_account.med25519!.ed25519
+      end
+
+      TransactionV0.new(
+        source_account_ed25519: ed25519,
+        seq_num: seq_num,
+        operations: operations,
+        fee: fee,
+        memo: memo,
+        time_bounds: time_bounds,
+        ext: ext
+      )
+    end
+
+    def signature_base
+      tagged_tx = DigitalBits::TransactionSignaturePayload::TaggedTransaction.new(:envelope_type_tx, self)
+      DigitalBits::TransactionSignaturePayload.new(
+        network_id: DigitalBits.current_network_id,
+        tagged_transaction: tagged_tx
+      ).to_xdr
+    end
+
+    def to_envelope(*key_pairs)
+      signatures = key_pairs.map(&method(:sign_decorated))
+
+      TransactionEnvelope.v1(signatures: signatures, tx: self)
+    end
+  end
+end

data/lib/digitalbits/transaction_builder.rb

@@ -0,0 +1,166 @@
+module DigitalBits
+  class TransactionBuilder
+    attr_reader :source_account, :sequence_number, :base_fee, :time_bounds, :memo, :operations
+
+    class << self
+      # This enable user to call shortcut methods, like
+      # TransactionBuilder.payment(...),
+      # TransactionBuilder.manage_data(...) and etc.
+      # It reduces the boilerplate, when you just need to
+      # shoot a single operation in transaction
+      def method_missing(method_name, *args, **kwargs)
+        unless DigitalBits::Operation.respond_to?(method_name)
+          return super
+        end
+
+        op = DigitalBits::Operation.send(method_name, **kwargs)
+
+        new(**kwargs).add_operation(op).build
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        DigitalBits::Operation.respond_to?(method_name) || super
+      end
+    end
+
+    def initialize(
+      source_account:,
+      sequence_number:,
+      base_fee: 100,
+      time_bounds: nil,
+      memo: nil,
+      **_ # ignore any additional parameters without errors
+    )
+      raise ArgumentError, "Bad :source_account" unless source_account.is_a?(DigitalBits::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?(DigitalBits::TimeBounds) || time_bounds.nil?
+      raise ArgumentError, "Bad :base_fee" unless base_fee.is_a?(Integer) && base_fee >= 100
+
+      @source_account = source_account
+      @sequence_number = sequence_number
+      @base_fee = base_fee
+      @time_bounds = time_bounds
+
+      if time_bounds.nil?
+        set_timeout(0)
+      end
+
+      @memo = make_memo(memo)
+      @operations = []
+    end
+
+    def build
+      if @time_bounds.nil?
+        raise "TransactionBuilder.time_bounds must be set during initialization or by calling set_timeout"
+      elsif !@time_bounds.min_time.is_a?(Integer) || !@time_bounds.max_time.is_a?(Integer)
+        raise "TimeBounds.min_time and max_time must be Integers"
+      elsif @time_bounds.max_time != 0 && @time_bounds.min_time > @time_bounds.max_time
+        raise "Timebounds.max_time must be greater than min_time"
+      end
+
+      attrs = {
+        source_account: @source_account.muxed_account,
+        fee: @base_fee * @operations.length,
+        seq_num: @sequence_number,
+        time_bounds: @time_bounds,
+        memo: @memo,
+        operations: @operations,
+        ext: DigitalBits::Transaction::Ext.new(0)
+      }
+
+      @sequence_number += 1
+
+      DigitalBits::Transaction.new(attrs)
+    end
+
+    def build_fee_bump(inner_txe:)
+      if inner_txe.switch == DigitalBits::EnvelopeType.envelope_type_tx_v0
+        inner_txe = DigitalBits::TransactionEnvelope.v1(tx: inner_txe.tx.to_v1, signatures: inner_txe.signatures)
+      elsif inner_txe.switch != DigitalBits::EnvelopeType.envelope_type_tx
+        raise ArgumentError, "Invalid inner transaction type #{inner_txe.switch}"
+      end
+
+      inner_tx = inner_txe.tx
+      inner_ops = inner_tx.operations
+      inner_base_fee_rate = inner_tx.fee.fdiv(inner_ops.length)
+
+      # The fee rate for fee bump is at least the fee rate of the inner transaction
+      if @base_fee < inner_base_fee_rate
+        raise "Insufficient base_fee, it should be at least #{inner_base_fee_rate} stroops."
+      end
+
+      DigitalBits::FeeBumpTransaction.new(
+        fee_source: @source_account.muxed_account,
+        fee: @base_fee * (inner_ops.length + 1),
+        inner_tx: DigitalBits::FeeBumpTransaction::InnerTx.new(:envelope_type_tx, inner_txe.v1!),
+        ext: DigitalBits::FeeBumpTransaction::Ext.new(0)
+      )
+    end
+
+    def add_operation(operation)
+      raise ArgumentError, "Bad operation" unless operation.is_a? DigitalBits::Operation
+      @operations.push(operation)
+      self
+    end
+
+    def clear_operations
+      @operations.clear
+      self
+    end
+
+    def set_source_account(account_kp)
+      raise ArgumentError, "Bad source account" unless account_kp.is_a?(DigitalBits::KeyPair)
+      @source_account = account_kp
+      self
+    end
+
+    def set_sequence_number(seq_num)
+      raise ArgumentError, "Bad sequence number" unless seq_num.is_a?(Integer) && seq_num >= 0
+      @sequence_number = seq_num
+      self
+    end
+
+    def set_timeout(timeout)
+      if !timeout.is_a?(Integer) || timeout < 0
+        raise ArgumentError, "Timeout must be a non-negative integer"
+      end
+
+      if @time_bounds.nil?
+        @time_bounds = DigitalBits::TimeBounds.new(min_time: 0, max_time: nil)
+      end
+
+      @time_bounds.max_time = timeout == 0 ? timeout : Time.now.to_i + timeout
+
+      self
+    end
+
+    def set_memo(memo)
+      @memo = make_memo(memo)
+      self
+    end
+
+    def set_base_fee(base_fee)
+      raise ArgumentError, "Bad base fee" unless base_fee.is_a?(Integer) && base_fee >= 100
+      @base_fee = base_fee
+      self
+    end
+
+    def make_memo(memo)
+      case memo
+      when DigitalBits::Memo
+        memo
+      when nil
+        Memo.new(:memo_none)
+      when Integer
+        Memo.new(:memo_id, memo)
+      when String
+        Memo.new(:memo_text, memo)
+      when Array
+        t, val = *memo
+        Memo.new(:"memo_#{t}", val)
+      else
+        raise ArgumentError, "Bad :memo"
+      end
+    end
+  end
+end

data/lib/digitalbits/transaction_envelope.rb

@@ -0,0 +1,35 @@
+module DigitalBits
+  class TransactionEnvelope
+    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`
+    #
+    # NOTE: this does not do any authorization checks, which requires access to
+    # the current ledger state.
+    #
+    # @param key_pairs [Array<DigitalBits::KeyPair>] The key pairs to check the envelopes signatures against
+    #
+    # @return [Boolean] true if all signatures are from the provided key_pairs and validly sign the tx's hash
+    def signed_correctly?(*key_pairs)
+      return false if signatures.empty?
+
+      tx_hash = tx.hash
+      keys_by_hint = key_pairs.index_by(&:signature_hint)
+
+      signatures.all? do |sig|
+        key_pair = keys_by_hint[sig.hint]
+        break false if key_pair.nil?
+
+        key_pair.verify(sig.signature, tx_hash)
+      end
+    end
+
+    def merge(other)
+      merged_tx = tx.merge(other.tx)
+      merged_tx.signatures = [signatures, other.signatures]
+      merged_tx
+    end
+  end
+end

data/lib/digitalbits/transaction_v0.rb

@@ -0,0 +1,43 @@
+module DigitalBits
+  class TransactionV0
+    include DigitalBits::Concerns::Transaction
+
+    def to_v1
+      Transaction.new(**attributes.except(:source_account_ed25519), source_account: source_account)
+    end
+
+    def to_envelope(*key_pairs)
+      signatures = (key_pairs || []).map(&method(:sign_decorated))
+
+      TransactionEnvelope.v0(signatures: signatures, tx: self)
+    end
+
+    def signature_base_prefix
+      val = DigitalBits::EnvelopeType.envelope_type_tx_v0
+
+      DigitalBits.current_network_id + DigitalBits::EnvelopeType.to_xdr(val)
+    end
+
+    # Backwards Compatibility: Use ENVELOPE_TYPE_TX to sign ENVELOPE_TYPE_TX_V0
+    # we need a Transaction to generate the signature base
+    def signature_base
+      tx = DigitalBits::Transaction.from_xdr(
+        # TransactionV0 is a transaction with the AccountID discriminant
+        # stripped off, we need to put it back to build a valid transaction
+        # which we can use to build a TransactionSignaturePayloadTaggedTransaction
+        DigitalBits::PublicKeyType.to_xdr(DigitalBits::PublicKeyType.public_key_type_ed25519) + to_xdr
+      )
+
+      tagged_tx = DigitalBits::TransactionSignaturePayload::TaggedTransaction.new(:envelope_type_tx, tx)
+
+      DigitalBits::TransactionSignaturePayload.new(
+        network_id: DigitalBits.current_network_id,
+        tagged_transaction: tagged_tx
+      ).to_xdr
+    end
+
+    def source_account
+      DigitalBits::MuxedAccount.ed25519(source_account_ed25519)
+    end
+  end
+end

data/lib/digitalbits/trust_line_flags.rb

@@ -0,0 +1,53 @@
+module DigitalBits
+  class TrustLineFlags
+    # Converts an array of DigitalBits::TrustLineFlags members into
+    # an integers suitable for use in in a SetTrustLineFlagsOp.
+    #
+    # @param flags [Array<DigitalBits::TrustLineFlags>] the flags to combine
+    #
+    # @return [Fixnum] the combined result
+    def self.make_mask(flags)
+      normalize(flags).map(&:value).inject(&:|) || 0
+    end
+
+    # Converts an integer used in SetTrustLineFlagsOp on the set/clear flag options
+    # into an array of DigitalBits::TrustLineFlags members
+    #
+    #  @param combined [Fixnum]
+    #  @return [Array<DigitalBits::AccountFlags>]
+    def self.parse_mask(combined)
+      members.values.select { |m| (m.value & combined) != 0 }
+    end
+
+    # Converts each element of the input array to DigitalBits::TrustLineFlags instance.
+    #
+    # @param [Array<DigitalBits::TrustLineFlags,Symbol,#to_s>] input
+    # @return [Array<DigitalBits::TrustLineFlags>]
+    # @raise [TypeError] if any element of the input cannot be converted
+    def self.normalize(input)
+      input.map do |val|
+        case val
+        when DigitalBits::TrustLineFlags
+          val
+        when ->(_) { members.key?(val.to_s) }
+          from_name(val.to_s)
+        when ->(_) { members.key?("#{val}_flag") }
+          from_name("#{val}_flag")
+        else
+          raise TypeError, "unknown trustline flag: #{val}"
+        end
+      end
+    end
+
+    def self.set_clear_masks(flags)
+      set_flags = []
+      clear_flags = []
+
+      Hash(flags).each do |flag, value|
+        value.present? ? set_flags.push(flag) : clear_flags.push(flag)
+      end
+
+      {set_flags: make_mask(set_flags), clear_flags: make_mask(clear_flags)}
+    end
+  end
+end