digitalbits-base 0.27.1

data/lib/digitalbits/convert.rb

@@ -0,0 +1,32 @@
+module DigitalBits
+  #
+  # Generic format conversion module
+  #
+  module Convert
+    require "base64"
+
+    def to_hex(string)
+      string.unpack1("H*")
+    end
+
+    def from_hex(hex_string)
+      [hex_string].pack("H*")
+    end
+
+    def to_base64(string)
+      Base64.strict_encode64(string)
+    end
+
+    def from_base64(base64_string)
+      Base64.strict_decode64(base64_string)
+    end
+
+    ## Converts a DigitalBits::PublicKey instance (or any typedef of it such as
+    # DigitalBits::AccountID) to an address
+    def pk_to_address(pk)
+      DigitalBits::Util::StrKey.check_encode(:account_id, pk.ed25519!)
+    end
+
+    extend self
+  end
+end

data/lib/digitalbits/dsl.rb

@@ -0,0 +1,93 @@
+module DigitalBits
+  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
+    #   DigitalBits::ClaimPredicate { before_relative_time(1.hour) & ~before_relative_time(5.minutes) }
+    #
+    # @example not fulfilled starting from today midnight until tomorrow midnight,
+    #   DigitalBits::ClaimPredicate { before_absolute_time(Date.today.end_of_day) | ~before_absolute_time(Date.tomorrow.end_of_day) }
+    #
+    # @example always fulfilled
+    #   DigitalBits::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 [DigitalBits::Asset] instance of the DigitalBits::Asset
+    # @raise [TypeError] if subject cannot be converted to DigitalBits::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 DigitalBits::Asset"
+      end
+    end
+
+    # Generates DigitalBits::Keypair from subject, use DigitalBits::Client.to_keypair as shortcut.
+    # @param subject [String|DigitalBits::Account|DigitalBits::PublicKey|DigitalBits::SignerKey|DigitalBits::Keypair] subject.
+    # @return [DigitalBits::Keypair] DigitalBits::Keypair instance.
+    # @raise [TypeError] if subject cannot be converted to DigitalBits::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 DigitalBits::KeyPair"
+      end
+    end
+
+    # Provides conversion from different input types into the SignerKey to use in ManageData operation.
+    # @param input [String|zDigitalBits::Account|DigitalBits::PublicKey|DigitalBits::SignerKey|DigitalBits::Keypair] subject.
+    # @return [DigitalBits::SignerKey] DigitalBits::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(DigitalBits::Convert.from_base64(input))
+      when /^[0-9a-f]{64}$/
+        SignerKey.hash_x(DigitalBits::Convert.from_hex(input))
+      when /^.{32}$/
+        SignerKey.hash_x(input)
+      else
+        SignerKey.ed25519(KeyPair(input))
+      end
+    end
+  end
+
+  include DSL
+end

data/lib/digitalbits/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/digitalbits/factories.rb

@@ -0,0 +1,59 @@
+FactoryBot.define do
+  factory :digitalbits_ledger, class: Hyperclient::Resource do
+    initialize_with { new(attributes.stringify_keys, nil, nil) }
+
+    id { "ec168d452542589dbc2d0eb6d58c74b9bb2ccb93bba879a3b3fa73fdfa730182" }
+    paging_token { "12884901888" }
+    hash { "ec168d452542589dbc2d0eb6d58c74b9bb2ccb93bba879a3b3fa73fdfa730182" }
+    prev_hash { "fe0f6bea5f341344fdb5bc6fc4ad719dd63071d9203e9a1e7f17c68ea1ecebde" }
+    sequence { 3 }
+    transaction_count { 1 }
+    operation_count { 3 }
+    closed_at { "2015-09-30T17:15:54Z" }
+    total_coins { "100000000000.0000000" }
+    fee_pool { "0.0000300" }
+    base_fee_in_stroops { 100 }
+    base_reserve_in_stroops { 100000000 }
+    max_tx_set_size { 500 }
+    protocol_version { 1 }
+    header_xdr { "AAAAAf4Pa+pfNBNE/bW8b8StcZ3WMHHZID6aHn8Xxo6h7OveT8tCuFMOgNdZYJOIRVDug1f8O8Px/nC6paZHVl6SYykAAAAAVgwYygAAAAAAAAAAxAXcAjsE7UPy10Zx5GA7wF8NZPwXAURqCwJYjORMFD1ShdgmDrQnA6TSdmQnqUysyyhS7Px10zUmUf01qfuKPgAAAAMN4Lazp2QAAAAAAAAAAAEsAAAAAAAAAAAAAAAAAAAAZAX14QAAAAH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" }
+  end
+
+  factory :digitalbits_transaction, class: Hyperclient::Resource do
+    initialize_with { new(attributes.stringify_keys, nil, nil) }
+
+    memo { "hello world" }
+    id { "3389e9f0f1a65f19736cacf544c2e825313e8447f569233bb8db39aa607c8889" }
+    paging_token { "12884905984" }
+    hash { "3389e9f0f1a65f19736cacf544c2e825313e8447f569233bb8db39aa607c8889" }
+    ledger { 3 }
+    created_at { "2015-09-30T17:15:54Z" }
+    source_account { "GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7" }
+    source_account_sequence { "1" }
+    fee_paid { 300 }
+    operation_count { 3 }
+    envelope_xdr { "AAAAAAGUcmKO5465JxTSLQOQljwk2SfqAJmZSG6JH6wtqpwhAAABLAAAAAAAAAABAAAAAAAAAAEAAAALaGVsbG8gd29ybGQAAAAAAwAAAAAAAAAAAAAAABbxCy3mLg3hiTqX4VUEEp60pFOrJNxYM1JtxXTwXhY2AAAAAAvrwgAAAAAAAAAAAQAAAAAW8Qst5i4N4Yk6l+FVBBKetKRTqyTcWDNSbcV08F4WNgAAAAAN4Lazj4x61AAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLaqcIQAAAEBKwqWy3TaOxoGnfm9eUjfTRBvPf34dvDA0Nf+B8z4zBob90UXtuCqmQqwMCyH+okOI3c05br3khkH0yP4kCwcE" }
+    result_xdr { "AAAAAAAAASwAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAFAAAAAAAAAAA=" }
+    result_meta_xdr { "AAAAAAAAAAMAAAACAAAAAAAAAAMAAAAAAAAAABbxCy3mLg3hiTqX4VUEEp60pFOrJNxYM1JtxXTwXhY2AAAAAAvrwgAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAGUcmKO5465JxTSLQOQljwk2SfqAJmZSG6JH6wtqpwhDeC2s5t4PNQAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAEAAAADAAAAAAAAAAABlHJijueOuScU0i0DkJY8JNkn6gCZmUhuiR+sLaqcIQAAAAAL68IAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAAW8Qst5i4N4Yk6l+FVBBKetKRTqyTcWDNSbcV08F4WNgAAAAAL68IAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAW8Qst5i4N4Yk6l+FVBBKetKRTqyTcWDNSbcV08F4WNg3gtrObeDzUAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAAAAAAAAZRyYo7njrknFNItA5CWPCTZJ+oAmZlIbokfrC2qnCEAAAAAC+vCAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=" }
+    fee_meta_xdr { "AAAAAgAAAAMAAAABAAAAAAAAAAABlHJijueOuScU0i0DkJY8JNkn6gCZmUhuiR+sLaqcIQ3gtrOnZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAABlHJijueOuScU0i0DkJY8JNkn6gCZmUhuiR+sLaqcIQ3gtrOnY/7UAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAA==" }
+    memo_type { "text" }
+    signatures do
+      ["SsKlst02jsaBp35vXlI300Qbz39+HbwwNDX/gfM+MwaG/dFF7bgqpkKsDAsh/qJDiN3NOW695IZB9Mj+JAsHBA=="]
+    end
+  end
+
+  factory :digitalbits_operation, class: Hyperclient::Resource do
+    initialize_with { new(attributes.stringify_keys, nil, nil) }
+
+    id { "12884905985" }
+    paging_token { "12884905985" }
+    source_account { "GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7" }
+    type { "create_account" }
+    type_i { 0 }
+    created_at { "2015-09-30T17:15:54Z" }
+    transaction_hash { "3389e9f0f1a65f19736cacf544c2e825313e8447f569233bb8db39aa607c8889" }
+    starting_balance { "20.0000000" }
+    funder { "GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7" }
+    account { "GALPCCZN4YXA3YMJHKL6CVIECKPLJJCTVMSNYWBTKJW4K5HQLYLDMZTB" }
+  end
+end

data/lib/digitalbits/fee_bump_transaction.rb

@@ -0,0 +1,21 @@
+module DigitalBits
+  class FeeBumpTransaction
+    include DigitalBits::Concerns::Transaction
+
+    def to_envelope(*key_pairs)
+      signatures = (key_pairs || []).map(&method(:sign_decorated))
+
+      TransactionEnvelope.fee_bump(signatures: signatures, tx: self)
+    end
+
+    def signature_base_prefix
+      val = DigitalBits::EnvelopeType.envelope_type_tx_fee_bump
+
+      DigitalBits.current_network_id + DigitalBits::EnvelopeType.to_xdr(val)
+    end
+
+    def source_account
+      source_account_ed25519
+    end
+  end
+end

data/lib/digitalbits/key_pair.rb

@@ -0,0 +1,126 @@
+module DigitalBits
+  class KeyPair
+    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(DigitalBits.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 address
+      Util::StrKey.check_encode(:account_id, raw_public_key)
+    end
+
+    def seed
+      Util::StrKey.check_encode(:seed, raw_seed)
+    end
+
+    def account_id
+      DigitalBits::AccountID.new :public_key_type_ed25519, raw_public_key
+    end
+
+    def muxed_account
+      DigitalBits::MuxedAccount.new :key_type_ed25519, raw_public_key
+    end
+
+    def public_key
+      DigitalBits::PublicKey.new :public_key_type_ed25519, raw_public_key
+    end
+
+    def signer_key
+      DigitalBits::SignerKey.new :signer_key_type_ed25519, raw_public_key
+    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
+
+    def rbnacl_signing_key
+      @secret_key
+    end
+
+    def rbnacl_verify_key
+      @public_key
+    end
+
+    def sign?
+      !@secret_key.nil?
+    end
+
+    def sign(message)
+      raise NotImplementedError, "no private key, signing is not available" unless sign?
+
+      @secret_key.sign(message)
+    end
+
+    def sign_decorated(message)
+      raw_signature = sign(message)
+      DigitalBits::DecoratedSignature.new({
+        hint: signature_hint,
+        signature: raw_signature
+      })
+    end
+
+    def verify(signature, message)
+      @public_key.verify(signature, message)
+    rescue RbNaCl::LengthError
+      false
+    rescue RbNaCl::BadSignatureError
+      false
+    end
+
+    def to_keypair
+      self
+    end
+  end
+end

data/lib/digitalbits/ledger_key.rb

@@ -0,0 +1,32 @@
+require "digitalbits/convert"
+require "digitalbits/dsl"
+
+module DigitalBits
+  class LedgerKey
+    class << self
+      include DigitalBits::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(DigitalBits::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/digitalbits/muxed_account.rb

@@ -0,0 +1,16 @@
+module DigitalBits
+  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/digitalbits/networks.rb

@@ -0,0 +1,43 @@
+module DigitalBits
+  # Provides a container for well-known network passphrases, such as the main network and SDF test network
+  module Networks
+    PUBLIC = "LiveNet Global DigitalBits Network ; February 2021"
+    TESTNET = "TestNet Global DigitalBits Network ; December 2020"
+  end
+
+  # Configures the default digitalbits network passphrase for the current process.  Unless otherwise
+  # specified in a method that needs the passphrase, this value will be used.
+  #
+  # NOTE:  This method is not thread-safe.  It's best to just call this at startup once and use the other
+  #        methods of specifying a network if you need two threads in the same process to communicate with
+  #        different networks
+  #
+  # @see DigitalBits.on_network
+  mattr_accessor :default_network, default: Networks::TESTNET
+
+  # DigitalBits network passphrase selected for current thread
+  #
+  # @see DigitalBits.current_network
+  # @see DigitalBits.on_network
+  thread_mattr_accessor :network
+
+  # Returns the passphrase for the network currently active per-thread with a fallback to `DigitalBits.default_network`
+  def self.current_network
+    network.presence || default_network
+  end
+
+  # Returns the id for the currently configured network, suitable for use in generating
+  # a signature base string or making the root account's keypair.
+  def self.current_network_id
+    Digest::SHA256.digest(current_network)
+  end
+
+  # Executes the provided block in the context of the provided network.
+  def self.on_network(passphrase, &block)
+    old = network
+    self.network = passphrase
+    block.call
+  ensure
+    self.network = old
+  end
+end