digitalbits-sdk 0.27.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6792d096cad91255c2b26fc1d91559e94d12ce0e934d61d561232ee2f32eb2c4
+  data.tar.gz: a1d4158baa655e722b14ce91b53ad13f64211fe537f2f113d35440305555803f
+SHA512:
+  metadata.gz: b87bbaf3c2e65e4e3b06cb426316367a2547868e586adac5c35c572e53ff6210bba9d76d15da6747374b0bc036ec47726828f04135eec2589744008ea3c4b459
+  data.tar.gz: 2e148b6aa7cea4bf74f1bb8d9d43d04d6cb65aa1c0df3350d9689663efa4b661ab119b90317c98408978abd4cd1f53399fb9080eb114be44fea16202ae545b96

data/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2021 XDB Foundation
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,60 @@
+# DigitalBIts SDK for Ruby: Frontier Integration and Higher Level Abstractions
+[
+This library helps you to integrate your application into the [DigitalBits network](http://digitalbits.io).
+
+## Installation
+
+Add this lines to your application's Gemfile:
+
+```ruby
+gem 'digitalbits-sdk'
+```
+
+And then execute:
+
+    $ bundle
+
+Also requires libsodium. Installable via `brew install libsodium` on OS X.
+
+## Usage
+
+See [examples](examples).
+
+A simple payment from the root account to some random accounts
+
+```ruby
+require 'digitalbits-sdk'
+
+account   = DigitalBits::Account.master
+client    = DigitalBits::Client.default_testnet()
+recipient = DigitalBits::Account.random
+
+client.send_payment({
+  from:   account,
+  to:     recipient,
+  amount: DigitalBits::Amount.new(100_000_000)
+})
+```
+
+Be sure to set the network when submitting to the public network (more information in [digitalbits-base](https://www.github.com/xdbfoundation/ruby-digitalbits-base)):
+
+```ruby
+DigitalBits.default_network = DigitalBits::Networks::PUBLIC
+```
+
+## Development
+
+- Install and activate [rvm](https://rvm.io/rvm/install)
+- Ensure your `bundler` version is up-to-date: `gem install bundler`
+- Run `bundle install`
+- Copy `spec/config.yml.sample` to `spec/config.yml`
+- Replace anything in `spec/config.yml` especially if you will re-record specs
+- `bundle exec rspec spec`
+
+## Contributing
+
+1. Fork it ( https://github.com/xdbfoundation/ruby-digitalbits-sdk/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/digitalbits-sdk.rb

@@ -0,0 +1,21 @@
+require "digitalbits-base"
+
+module DigitalBits
+  module SDK
+    VERSION = ::DigitalBits::VERSION
+  end
+
+  autoload :Account
+  autoload :Amount
+  autoload :Client
+  autoload :SEP10
+
+  module Frontier
+    extend ActiveSupport::Autoload
+
+    autoload :Problem
+    autoload :Result
+  end
+
+  autoload :TransactionPage
+end

data/lib/digitalbits/account.rb

@@ -0,0 +1,89 @@
+require "toml-rb"
+require "uri"
+require "faraday"
+require "json"
+
+module DigitalBits
+  class Account
+    delegate :address, to: :keypair
+
+    def self.random
+      keypair = DigitalBits::KeyPair.random
+      new(keypair)
+    end
+
+    def self.from_seed(seed)
+      keypair = DigitalBits::KeyPair.from_seed(seed)
+      new(keypair)
+    end
+
+    def self.from_address(address)
+      keypair = DigitalBits::KeyPair.from_address(address)
+      new(keypair)
+    end
+
+    def self.lookup(federated_name)
+      _, domain = federated_name.split("*")
+      if domain.nil?
+        raise InvalidFederationAddress.new
+      end
+
+      domain_req = Faraday.new("https://#{domain}/.well-known/digitalbits.toml").get
+
+      unless domain_req.status == 200
+        raise InvalidDigitalBitsDomain.new("Domain does not contain digitalbits.toml file")
+      end
+
+      fed_server_url = TomlRB.parse(domain_req.body)["FEDERATION_SERVER"]
+      if fed_server_url.nil?
+        raise InvalidDigitalBitsTOML.new("Invalid DigitalBits TOML file")
+      end
+
+      unless fed_server_url&.match?(URI::DEFAULT_PARSER.make_regexp)
+        raise InvalidFederationURL.new("Invalid Federation Server URL")
+      end
+
+      lookup_req = Faraday.new(fed_server_url).get { |req|
+        req.params[:q] = federated_name
+        req.params[:type] = "name"
+      }
+
+      unless lookup_req.status == 200
+        raise AccountNotFound.new("Account not found")
+      end
+
+      JSON.parse(lookup_req.body)["account_id"]
+    end
+
+    def self.master
+      keypair = DigitalBits::KeyPair.from_raw_seed("allmylifemyhearthasbeensearching")
+      new(keypair)
+    end
+
+    attr_reader :keypair
+
+    # @param [DigitalBits::KeyPair] keypair
+    def initialize(keypair)
+      @keypair = keypair
+    end
+
+    def to_keypair
+      keypair
+    end
+  end
+
+  class AccountNotFound < StandardError
+  end
+
+  class InvalidDigitalBitsTOML < StandardError
+  end
+
+  class InvalidFederationAddress < StandardError
+  end
+
+  class InvalidDigitalBitsDomain < StandardError
+  end
+
+  class InvalidFederationURL < StandardError
+  end
+end

data/lib/digitalbits/amount.rb

@@ -0,0 +1,36 @@
+module DigitalBits
+  class Amount
+    attr_reader :amount
+    attr_reader :asset
+
+    # @param [Fixnum] amount
+    # @param [DigitalBits::Asset] asset
+    def initialize(amount, asset = DigitalBits::Asset.native)
+      # TODO: how are we going to handle decimal considerations?
+
+      @amount = amount
+      @asset = asset
+    end
+
+    # @return [Array(Symbol, Fixnum)] in case of a native asset
+    # @return [Array(Symbol, String, DigitalBits::KeyPair, Fixnum)] in case of alphanum asset
+    def to_payment
+      case asset.type
+      when AssetType.asset_type_native
+        [:native, amount]
+      when AssetType.asset_type_credit_alphanum4
+        keypair = KeyPair.from_public_key(asset.issuer.value)
+        [:alphanum4, asset.code, keypair, amount]
+      when AssetType.asset_type_credit_alphanum12
+        keypair = KeyPair.from_public_key(asset.issuer.value)
+        [:alphanum12, asset.code, keypair, amount]
+      else
+        raise "Unknown asset type: #{asset.type}"
+      end
+    end
+
+    def inspect
+      "#<DigitalBits::Amount #{asset}(#{amount})>"
+    end
+  end
+end

data/lib/digitalbits/client.rb

@@ -0,0 +1,298 @@
+require "hyperclient"
+require "active_support/core_ext/object/blank"
+require "securerandom"
+
+module DigitalBits
+  class AccountRequiresMemoError < StandardError
+    attr_reader :account_id, :operation_index
+
+    def initialize(message, account_id, operation_index)
+      super(message)
+      @account_id = account_id
+      @operation_index = operation_index
+    end
+  end
+
+  class Client
+    DEFAULT_FEE = 100
+
+    FRONTIER_LOCALHOST_URL = "http://127.0.0.1:8000"
+    FRONTIER_MAINNET_URL = "https://frontier.livenet.digitalbits.io"
+    FRONTIER_TESTNET_URL = "https://frontier.testnet.digitalbits.io"
+    FRIENDBOT_URL = "https://friendbot.testnet.digitalbits.io".freeze
+
+    def self.default(options = {})
+      new options.merge(
+        frontier: FRONTIER_MAINNET_URL
+      )
+    end
+
+    def self.default_testnet(options = {})
+      new options.merge(
+        frontier: FRONTIER_TESTNET_URL,
+        friendbot: FRONTIER_TESTNET_URL
+      )
+    end
+
+    def self.localhost(options = {})
+      new options.merge(
+        frontier: FRONTIER_LOCALHOST_URL
+      )
+    end
+
+    attr_reader :frontier
+
+    # @option options [String] :frontier The Frontier server URL.
+    def initialize(options)
+      @options = options
+      @frontier = Hyperclient.new(options[:frontier]) { |client|
+        client.faraday_block = lambda do |conn|
+          conn.use Faraday::Response::RaiseError
+          conn.use FaradayMiddleware::FollowRedirects
+          conn.request :url_encoded
+          conn.response :hal_json, content_type: /\bjson$/
+          conn.adapter :excon
+        end
+        client.headers = {
+          "Accept" => "application/hal+json,application/problem+json,application/json",
+          "X-Client-Name" => "ruby-digitalbits-sdk",
+          "X-Client-Version" => VERSION
+        }
+      }
+    end
+
+    # @param [DigitalBits::Account|String] account_or_address
+    def account_info(account_or_address)
+      account_id = if account_or_address.is_a?(DigitalBits::Account)
+        account_or_address.address
+      else
+        account_or_address
+      end
+      @frontier.account(account_id: account_id)._get
+    end
+
+    # @option options [DigitalBits::Account] :account
+    # @option options [DigitalBits::Account] :destination
+    def account_merge(options = {})
+      account = options[:account]
+      destination = options[:destination]
+      sequence = options[:sequence] || (account_info(account).sequence.to_i + 1)
+
+      transaction = DigitalBits::TransactionBuilder.account_merge(
+        source_account: destination.keypair,
+        sequence_number: sequence,
+        destination: destination.keypair
+      )
+
+      envelope = transaction.to_envelope(account.keypair)
+      submit_transaction(tx_envelope: envelope)
+    end
+
+    def friendbot(account)
+      uri = URI.parse(FRIENDBOT_URL)
+      uri.query = "addr=#{account.address}"
+      Faraday.post(uri.to_s)
+    end
+
+    # @option options [DigitalBits::Account] :account
+    # @option options [DigitalBits::Account] :funder
+    # @option options [Integer] :starting_balance
+    def create_account(options = {})
+      funder = options[:funder]
+      sequence = options[:sequence] || (account_info(funder).sequence.to_i + 1)
+      # In the future, the fee should be grabbed from the network's last transactions,
+      # instead of using a hard-coded default value.
+      fee = options[:fee] || DEFAULT_FEE
+
+      payment = DigitalBits::TransactionBuilder.create_account(
+        source_account: funder.keypair,
+        sequence_number: sequence,
+        base_fee: fee,
+        destination: options[:account].keypair,
+        starting_balance: options[:starting_balance]
+      )
+      envelope = payment.to_envelope(funder.keypair)
+      submit_transaction(tx_envelope: envelope)
+    end
+
+    # @option options [DigitalBits::Account] :from The source account
+    # @option options [DigitalBits::Account] :to The destination account
+    # @option options [DigitalBits::Amount] :amount The amount to send
+    def send_payment(options = {})
+      from_account = options[:from]
+      tx_source_account = options[:transaction_source] || from_account
+      op_source_account = from_account if tx_source_account.present?
+
+      sequence = options[:sequence] ||
+        (account_info(tx_source_account).sequence.to_i + 1)
+
+      payment = DigitalBits::TransactionBuilder.new(
+        source_account: tx_source_account.keypair,
+        sequence_number: sequence
+      ).add_operation(
+        DigitalBits::Operation.payment(
+          source_account: op_source_account.keypair,
+          destination: options[:to].keypair,
+          amount: options[:amount].to_payment
+        )
+      ).set_memo(options[:memo]).set_timeout(0).build
+
+      signers = [tx_source_account, op_source_account].uniq(&:address)
+      to_envelope_args = signers.map(&:keypair)
+
+      envelope = payment.to_envelope(*to_envelope_args)
+      submit_transaction(tx_envelope: envelope)
+    end
+
+    # @option options [DigitalBits::Account] :account
+    # @option options [Integer] :limit
+    # @option options [Integer] :cursor
+    # @return [DigitalBits::TransactionPage]
+    def transactions(options = {})
+      args = options.slice(:limit, :cursor)
+
+      resource = if options[:account]
+        args = args.merge(account_id: options[:account].address)
+        @frontier.account_transactions(args)
+      else
+        @frontier.transactions(args)
+      end
+
+      TransactionPage.new(resource)
+    end
+
+    # @param [Array(Symbol,String,DigitalBits::KeyPair|DigitalBits::Account)] asset
+    # @param [DigitalBits::Account] source
+    # @param [Integer] sequence
+    # @param [Integer] fee
+    # @param [Integer] limit
+    def change_trust(
+      asset:,
+      source:,
+      sequence: nil,
+      fee: DEFAULT_FEE,
+      limit: nil
+    )
+      sequence ||= (account_info(source).sequence.to_i + 1)
+
+      op_args = {
+        account: source.keypair,
+        sequence: sequence,
+        line: asset
+      }
+      op_args[:limit] = limit unless limit.nil?
+
+      tx = DigitalBits::TransactionBuilder.change_trust(
+        source_account: source.keypair,
+        sequence_number: sequence,
+        **op_args
+      )
+
+      envelope = tx.to_envelope(source.keypair)
+      submit_transaction(tx_envelope: envelope)
+    end
+
+    # @param [DigitalBits::TransactionEnvelope] tx_envelope
+    # @option options [Boolean] :skip_memo_required_check (false)
+    def submit_transaction(tx_envelope:, options: {skip_memo_required_check: false})
+      unless options[:skip_memo_required_check]
+        check_memo_required(tx_envelope)
+      end
+      @frontier.transactions._post(tx: tx_envelope.to_xdr(:base64))
+    end
+
+    # Required by SEP-0029
+    # @param [DigitalBits::TransactionEnvelope] tx_envelope
+    def check_memo_required(tx_envelope)
+      tx = tx_envelope.tx
+
+      if tx.is_a?(DigitalBits::FeeBumpTransaction)
+        tx = tx.inner_tx.v1!.tx
+      end
+
+      # Check transactions where the .memo field is nil or of type MemoType.memo_none
+      if !tx.memo.nil? && tx.memo.type != DigitalBits::MemoType.memo_none
+        return
+      end
+
+      destinations = Set.new
+      ot = DigitalBits::OperationType
+
+      tx.operations.each_with_index do |op, idx|
+        destination = case op.body.type
+        when ot.payment, ot.path_payment_strict_receive, ot.path_payment_strict_send
+          op.body.value.destination
+        when ot.account_merge
+          # There is no AccountMergeOp, op.body is an Operation object
+          # and op.body.value is a PublicKey (or AccountID) object.
+          op.body.value
+        else
+          next
+        end
+
+        if destinations.include?(destination) || destination.switch == DigitalBits::CryptoKeyType.key_type_muxed_ed25519
+          next
+        end
+
+        destinations.add(destination)
+        kp = DigitalBits::KeyPair.from_public_key(destination.value)
+
+        begin
+          info = account_info(kp.address)
+        rescue Faraday::ResourceNotFound
+          # Don't raise an error if its a 404, but throw one otherwise
+          next
+        end
+        if info.data["config.memo_required"] == "MQ=="
+          # MQ== is the base64 encoded string for the string "1"
+          raise AccountRequiresMemoError.new("account requires memo", destination, idx)
+        end
+      end
+    end
+
+    # DEPRECATED: this function has been moved DigitalBits::SEP10.build_challenge_tx and
+    # will be removed in the next major version release.
+    #
+    # A wrapper function for DigitalBits::SEP10::build_challenge_tx.
+    #
+    # @param server [DigitalBits::KeyPair] Keypair for server's signing account.
+    # @param client [DigitalBits::KeyPair] Keypair for the account whishing to authenticate with the server.
+    # @param anchor_name [String] Anchor's name to be used in the manage_data key.
+    # @param timeout [Integer] Challenge duration (default to 5 minutes).
+    #
+    # @return [String] A base64 encoded string of the raw TransactionEnvelope xdr struct for the transaction.
+    def build_challenge_tx(server:, client:, anchor_name:, timeout: 300)
+      DigitalBits::SEP10.build_challenge_tx(
+        server: server, client: client, anchor_name: anchor_name, timeout: timeout
+      )
+    end
+
+    # DEPRECATED: this function has been moved to DigitalBits::SEP10::read_challenge_tx and
+    # will be removed in the next major version release.
+    #
+    # A wrapper function for DigitalBits::SEP10.verify_challenge_transaction
+    #
+    # @param challenge [String] SEP0010 transaction challenge in base64.
+    # @param server [DigitalBits::KeyPair] DigitalBits::KeyPair for server where the challenge was generated.
+    #
+    # @return [Boolean]
+    def verify_challenge_tx(challenge:, server:)
+      DigitalBits::SEP10.verify_challenge_tx(challenge_xdr: challenge, server: server)
+      true
+    end
+
+    # DEPRECATED: this function has been moved to DigitalBits::SEP10::verify_tx_signed_by and
+    # will be removed in the next major version release.
+    #
+    # @param transaction_envelope [DigitalBits::TransactionEnvelope]
+    # @param keypair [DigitalBits::KeyPair]
+    #
+    # @return [Boolean]
+    #
+    def verify_tx_signed_by(transaction_envelope:, keypair:)
+      DigitalBits::SEP10.verify_tx_signed_by(
+        tx_envelope: transaction_envelope, keypair: keypair
+      )
+    end
+  end
+end

data/lib/digitalbits/frontier/problem.rb

@@ -0,0 +1,45 @@
+module DigitalBits
+  module Frontier
+    class Problem
+      def initialize(attributes)
+        @attributes = attributes.reverse_merge({
+          type: "about:blank",
+          title: "Unknown Error",
+          status: 500
+        })
+
+        @meta = @attributes.except!(:type, :title, :status, :detail, :instance)
+      end
+
+      # @return [String]
+      def type
+        @attributes[:type]
+      end
+
+      # @return [String]
+      def title
+        @attributes[:title]
+      end
+
+      # @return [Integer]
+      def status
+        @attributes[:status]
+      end
+
+      # @return [String]
+      def detail
+        @attributes[:detail]
+      end
+
+      # @return [String]
+      def instance
+        @attributes[:instance]
+      end
+
+      # @return [{String => Object}]
+      def meta
+        @attributes[:instance]
+      end
+    end
+  end
+end

data/lib/digitalbits/sep10.rb

@@ -0,0 +1,274 @@
+module DigitalBits
+  class InvalidSep10ChallengeError < StandardError; end
+
+  class SEP10
+    include DigitalBits::DSL
+
+    # Helper method to create a valid challenge transaction which you can use for DigitalBits Web Authentication.
+    #
+    # @example
+    #   server = DigitalBits::KeyPair.random # SIGNING_KEY from your digitalbits.toml
+    #   user = DigitalBits::KeyPair.from_address('G...')
+    #   DigitalBits::SEP10.build_challenge_tx(server: server, client: user, domain: 'example.com', timeout: 300)
+    #
+    # @param server [DigitalBits::KeyPair] server's signing keypair (SIGNING_KEY in service's digitalbits.toml)
+    # @param client [DigitalBits::KeyPair] account trying to authenticate with the server
+    # @param domain [String] service's domain to be used in the manage_data key
+    # @param timeout [Integer] challenge duration (default to 5 minutes)
+    #
+    # @return [String] A base64 encoded string of the raw TransactionEnvelope xdr struct for the transaction.
+    #
+    def self.build_challenge_tx(server:, client:, domain: nil, timeout: 300, **options)
+      if domain.blank? && options.key?(:anchor_name)
+        ActiveSupport::Deprecation.new("next release", "digitalbits-sdk").warn <<~MSG
+          SEP-10 v2.0.0 requires usage of service home domain instead of anchor name in the challenge transaction.
+          Please update your implementation to use `DigitalBits::SEP10.build_challenge_tx(..., home_domain: 'example.com')`.
+          Using `anchor_name` parameter makes your service incompatible with SEP10-2.0 clients, support for this parameter
+          is deprecated and will be removed in the next major release of digitalbits-base.
+        MSG
+        domain = options[:anchor_name]
+      end
+
+      now = Time.now.to_i
+      time_bounds = DigitalBits::TimeBounds.new(
+        min_time: now,
+        max_time: now + timeout
+      )
+
+      tb = DigitalBits::TransactionBuilder.new(
+        source_account: server,
+        sequence_number: 0,
+        time_bounds: time_bounds
+      )
+
+      # The value must be 64 bytes long. It contains a 48 byte
+      # cryptographic-quality random string encoded using base64 (for a total of
+      # 64 bytes after encoding).
+      tb.add_operation(
+        DigitalBits::Operation.manage_data(
+          name: "#{domain} auth",
+          value: SecureRandom.base64(48),
+          source_account: client
+        )
+      )
+
+      if options.key?(:auth_domain)
+        tb.add_operation(
+          DigitalBits::Operation.manage_data(
+            name: "web_auth_domain",
+            value: options[:auth_domain],
+            source_account: server
+          )
+        )
+      end
+
+      tb.build.to_envelope(server).to_xdr(:base64)
+    end
+
+    # Reads a SEP 10 challenge transaction and returns the decoded transaction envelope and client account ID contained within.
+    #
+    # It also verifies that transaction is signed by the server.
+    #
+    # It does not verify that the transaction has been signed by the client or
+    # that any signatures other than the servers on the transaction are valid.
+    # Use either {.verify_challenge_tx_threshold} or {.verify_challenge_tx_signers} to completely verify
+    # the signed challenge
+    #
+    # @example
+    #   sep10 = DigitalBits::SEP10
+    #   server = DigitalBits::KeyPair.random # this should be the SIGNING_KEY from your digitalbits.toml
+    #   challenge = sep10.build_challenge_tx(server: server, client: user, domain: domain, timeout: timeout)
+    #   envelope, client_address = sep10.read_challenge_tx(server: server, challenge_xdr: challenge)
+    #
+    # @param challenge_xdr [String] SEP0010 transaction challenge in base64.
+    # @param server [DigitalBits::KeyPair] keypair for server where the challenge was generated.
+    #
+    # @return [Array(DigitalBits::TransactionEnvelope, String)]
+    def self.read_challenge_tx(server:, challenge_xdr:, **options)
+      envelope = DigitalBits::TransactionEnvelope.from_xdr(challenge_xdr, "base64")
+      transaction = envelope.tx
+
+      if transaction.seq_num != 0
+        raise InvalidSep10ChallengeError, "The transaction sequence number should be zero"
+      end
+
+      if transaction.source_account != server.muxed_account
+        raise InvalidSep10ChallengeError, "The transaction source account is not equal to the server's account"
+      end
+
+      if transaction.operations.size < 1
+        raise InvalidSep10ChallengeError, "The transaction should contain at least one operation"
+      end
+
+      auth_op, *rest_ops = transaction.operations
+      client_account_id = auth_op.source_account
+
+      auth_op_body = auth_op.body.value
+
+      if client_account_id.blank?
+        raise InvalidSep10ChallengeError, "The transaction's operation should contain a source account"
+      end
+
+      if auth_op.body.arm != :manage_data_op
+        raise InvalidSep10ChallengeError, "The transaction's first operation should be manageData"
+      end
+
+      if options.key?(:domain) && auth_op_body.data_name != "#{options[:domain]} auth"
+        raise InvalidSep10ChallengeError, "The transaction's operation data name is invalid"
+      end
+
+      if auth_op_body.data_value.unpack1("m").size != 48
+        raise InvalidSep10ChallengeError, "The transaction's operation value should be a 64 bytes base64 random string"
+      end
+
+      rest_ops.each do |op|
+        body = op.body
+
+        if body.arm != :manage_data_op
+          raise InvalidSep10ChallengeError, "The transaction has operations that are not of type 'manageData'"
+        elsif op.source_account != server.muxed_account
+          raise InvalidSep10ChallengeError, "The transaction has operations that are unrecognized"
+        else
+          op_params = body.value
+          if op_params.data_name == "web_auth_domain" && options.key?(:auth_domain) && op_params.data_value != options[:auth_domain]
+            raise InvalidSep10ChallengeError, "The transaction has 'manageData' operation with 'web_auth_domain' key and invalid value"
+          end
+        end
+      end
+
+      unless verify_tx_signed_by(tx_envelope: envelope, keypair: server)
+        raise InvalidSep10ChallengeError, "The transaction is not signed by the server"
+      end
+
+      time_bounds = transaction.time_bounds
+      now = Time.now.to_i
+
+      if time_bounds.blank? || !now.between?(time_bounds.min_time, time_bounds.max_time)
+        raise InvalidSep10ChallengeError, "The transaction has expired"
+      end
+
+      # Mirror the return type of the other SDK's and return a string
+      client_kp = DigitalBits::KeyPair.from_public_key(client_account_id.ed25519!)
+
+      [envelope, client_kp.address]
+    end
+
+    # Verifies that for a SEP 10 challenge transaction all signatures on the transaction
+    # are accounted for and that the signatures meet a threshold on an account. A
+    # transaction is verified if it is signed by the server account, and all other
+    # signatures match a signer that has been provided as an argument, and those
+    # signatures meet a threshold on the account.
+    #
+    # @param server [DigitalBits::KeyPair] keypair for server's account.
+    # @param challenge_xdr [String] SEP0010 challenge transaction in base64.
+    # @param signers [{String => Integer}] The signers of client account.
+    # @param threshold [Integer] The medThreshold on the client account.
+    #
+    # @raise InvalidSep10ChallengeError if the transaction has unrecognized signatures (only server's
+    #   signing key and keypairs found in the `signing` argument are recognized) or total weight of
+    #   the signers does not meet the `threshold`
+    #
+    # @return [<String>] subset of input signers who have signed `challenge_xdr`
+    def self.verify_challenge_tx_threshold(server:, challenge_xdr:, signers:, threshold:)
+      signers_found = verify_challenge_tx_signers(
+        server: server, challenge_xdr: challenge_xdr, signers: signers.keys
+      )
+
+      total_weight = signers.values_at(*signers_found).sum
+
+      if total_weight < threshold
+        raise InvalidSep10ChallengeError, "signers with weight #{total_weight} do not meet threshold #{threshold}."
+      end
+
+      signers_found
+    end
+
+    # Verifies that for a SEP 10 challenge transaction all signatures on the transaction are accounted for.
+    #
+    # A transaction is verified if it is signed by the server account, and all other signatures match a signer
+    # that has been provided as an argument. Additional signers can be provided that do not have a signature,
+    # but all signatures must be matched to a signer for verification to succeed.
+    #
+    # If verification succeeds a list of signers that were found is returned, excluding the server account ID.
+    #
+    # @param server [DigitalBits::Keypair]  server's signing key
+    # @param challenge_xdr [String] SEP0010 transaction challenge transaction in base64.
+    # @param signers [<String>] The signers of client account.
+    #
+    # @raise InvalidSep10ChallengeError one or more signatures in the transaction are not identifiable
+    #   as the server account or one of the signers provided in the arguments
+    #
+    # @return [<String>] subset of input signers who have signed `challenge_xdr`
+    def self.verify_challenge_tx_signers(server:, challenge_xdr:, signers:)
+      raise InvalidSep10ChallengeError, "no signers provided" if signers.empty?
+
+      te, _ = read_challenge_tx(server: server, challenge_xdr: challenge_xdr)
+
+      # ignore non-G signers and server's own address
+      client_signers = signers.select { |s| s =~ /G[A-Z0-9]{55}/ && s != server.address }.to_set
+      raise InvalidSep10ChallengeError, "at least one regular signer must be provided" if client_signers.empty?
+
+      # verify all signatures in one pass
+      client_signers.add(server.address)
+      signers_found = verify_tx_signatures(tx_envelope: te, signers: client_signers)
+
+      # ensure server signed transaction and remove it
+      unless signers_found.delete?(server.address)
+        raise InvalidSep10ChallengeError, "Transaction not signed by server: #{server.address}"
+      end
+
+      # Confirm we matched signatures to the client signers.
+      if signers_found.empty?
+        raise InvalidSep10ChallengeError, "Transaction not signed by any client signer."
+      end
+
+      # Confirm all signatures were consumed by a signer.
+      if signers_found.size != te.signatures.length - 1
+        raise InvalidSep10ChallengeError, "Transaction has unrecognized signatures."
+      end
+
+      signers_found
+    end
+
+    # Verifies every signer passed matches a signature on the transaction exactly once,
+    # returning a list of unique signers that were found to have signed the transaction.
+    #
+    # @param tx_envelope [DigitalBits::TransactionEnvelope] SEP0010 transaction challenge transaction envelope.
+    # @param signers [<String>] The signers of client account.
+    #
+    # @return [Set<DigitalBits::KeyPair>]
+    def self.verify_tx_signatures(tx_envelope:, signers:)
+      signatures = tx_envelope.signatures
+      if signatures.empty?
+        raise InvalidSep10ChallengeError, "Transaction has no signatures."
+      end
+
+      tx_hash = tx_envelope.tx.hash
+      to_keypair = DigitalBits::DSL.method(:KeyPair)
+      keys_by_hint = signers.map(&to_keypair).index_by(&:signature_hint)
+
+      tx_envelope.signatures.each.with_object(Set.new) do |sig, result|
+        key = keys_by_hint.delete(sig.hint)
+        result.add(key.address) if key&.verify(sig.signature, tx_hash)
+      end
+    end
+
+    # Verifies if a DigitalBits::TransactionEnvelope was signed by the given DigitalBits::KeyPair
+    #
+    # @example
+    #   DigitalBits::SEP10.verify_tx_signed_by(tx_envelope: envelope, keypair: keypair)
+    #
+    # @param tx_envelope [DigitalBits::TransactionEnvelope]
+    # @param keypair [DigitalBits::KeyPair]
+    #
+    # @return [Boolean]
+    def self.verify_tx_signed_by(tx_envelope:, keypair:)
+      tx_hash = tx_envelope.tx.hash
+      tx_envelope.signatures.any? do |sig|
+        next if sig.hint != keypair.signature_hint
+
+        keypair.verify(sig.signature, tx_hash)
+      end
+    end
+  end
+end

data/lib/digitalbits/transaction_page.rb

@@ -0,0 +1,25 @@
+module DigitalBits
+  class TransactionPage
+    include Enumerable
+
+    # @param [Hyperclient::Link] resource
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def each
+      @resource.records.each do |tx|
+        yield tx if block_given?
+      end
+    end
+
+    # @return [DigitalBits::TransactionPage]
+    def next_page
+      self.class.new(@resource.next)
+    end
+
+    def next_page!
+      @resource = @resource.next
+    end
+  end
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: digitalbits-sdk
+version: !ruby/object:Gem::Version
+  version: 0.27.1
+platform: ruby
+authors:
+- XDB Foundation
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: digitalbits-base
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.27.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.27.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.71.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.71.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hyperclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: toml-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- lib/digitalbits-sdk.rb
+- lib/digitalbits/account.rb
+- lib/digitalbits/amount.rb
+- lib/digitalbits/client.rb
+- lib/digitalbits/frontier/problem.rb
+- lib/digitalbits/sep10.rb
+- lib/digitalbits/transaction_page.rb
+homepage: https://github.com/xdbfoundation/ruby-digitalbits-sdk
+licenses:
+- Apache-2.0
+metadata:
+  bug_tracker_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/issues
+  changelog_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/blob/v0.27.1/sdk/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/digitalbits-sdk/0.27.1/
+  github_repo: ssh://github.com/xdbfoundation/ruby-digitalbits-sdk
+  homepage_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/tree/main/sdk
+  source_code_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/tree/v0.27.1/sdk
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: DigitalBits client library
+test_files: []