stellar-sdk 0.7.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3390d577fe288a6397d9f1c2844729023abc68b3147584211794d1d0eed294b2
-  data.tar.gz: 01ce41b3d2a9be6ea02196e14639a379955b584744435a622d7091840426358e
+  metadata.gz: 6ba0c7588160128f44661f6d2d76ae5222a480da069a632381996ea3e96673a4
+  data.tar.gz: 6125026b196da359d48636cbf6f4e11492f2b197745fa1c035d9957ca169c405
 SHA512:
-  metadata.gz: c740fe9977ea1dd2ae41ce0f2c4001eec2142d3adafe2739a2ec7deed9ba60f31419ad1f63c8d63b91cbc565146f855f5041f4171e2e324bda8770f1eae7d12b
-  data.tar.gz: 563d52017e9767190f0bd09d1fdf0dfe17903dfb55820b53ca24be6eabd2e4cc8d3896a6bf4148ee6f2fcdbec89fecba08ec7b012a5d2258bf6fd354bbac28d0
+  metadata.gz: 0d5a62b7b0e532bd2c6c7e29c0628911cc37e3aabc81bc9301918fe34c2ea932d81fca416f5d989852ab4900e2a17b4ba4780fdf500eb5520687165526a54523
+  data.tar.gz: 29f8a8feeba48b840406515e056640c2c13eab8b4b32b585af47c32c95e300987506f69f7c656d010588f34187bf6e3433e83d992194ff0d032b173361e7347b

data/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.9.0](https://github.com/stellar/ruby-stellar-sdk/compare/v0.9.0...v0.8.0)
+### Added
+- Stellar Protocol 13 support
+  - Fee-Bump transactions ([CAP-0015](https://github.com/stellar/stellar-protocol/blob/master/core/cap-0015.md))
+  - Multiplexed accounts ([CAP-0027](https://github.com/stellar/stellar-protocol/blob/master/core/cap-0027.md))
+  - Fine-Grained control on trustline authorization ([CAP-0018](https://github.com/stellar/stellar-protocol/blob/master/core/cap-0018.md))
+## [0.8.0](https://github.com/stellar/ruby-stellar-sdk/compare/v0.7.0...v0.8.0)
+### Added
+- SEP-10 Multisig Support [#69](https://github.com/stellar/ruby-stellar-sdk/pull/69)
+- `X-Client-Name` and `X-Client-Version` headers
+
 ## [0.7.0] - 2019-04-26
 ### Added
 - Friendbot support

data/README.md

@@ -1,27 +1,24 @@
 # Ruby Stellar
 
-[![Build Status](https://travis-ci.org/stellar/ruby-stellar-sdk.svg)](https://travis-ci.org/stellar/ruby-stellar-sdk)
-[![Code Climate](https://codeclimate.com/github/stellar/ruby-stellar-sdk/badges/gpa.svg)](https://codeclimate.com/github/stellar/ruby-stellar-sdk)
-
-*STATUS:  this library is very early and incomplete.  The examples provided do not work, yet*
+[![Build Status](https://travis-ci.org/bloom-solutions/ruby-stellar-sdk.svg)](https://travis-ci.org/bloom-solutions/ruby-stellar-sdk)
+[![Code Climate](https://codeclimate.com/github/bloom-solutions/ruby-stellar-sdk/badges/gpa.svg)](https://codeclimate.com/github/bloom-solutions/ruby-stellar-sdk)
 
 This library helps you to integrate your application into the [Stellar network](http://stellar.org).
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this lines to your application's Gemfile:
 
 ```ruby
 gem 'stellar-sdk'
+gem 'xdr', git: 'https://github.com/stellar/ruby-xdr.git', tag: 'v3.0.1'
 ```
 
 And then execute:
 
     $ bundle
-
-Or install it yourself as:
-
-    $ gem install stellar-sdk
+    
+**Note** we need to add such explicit `xdr` dependency, because version 3.0.1 is not on RubyGems yet. When it's published, you can remove this line
 
 Also requires libsodium. Installable via `brew install libsodium` on OS X.
 
@@ -45,7 +42,7 @@ client.send_payment({
 }) 
 ```
 
-Be sure to set the network when submitting to the public network (more information in [stellar-base](https://www.github.com/stellar/ruby-stellar-base)):
+Be sure to set the network when submitting to the public network (more information in [stellar-base](https://www.github.com/bloom-solutions/ruby-stellar-base)):
 
 ```ruby
 Stellar.default_network = Stellar::Networks::PUBLIC
@@ -53,14 +50,17 @@ Stellar.default_network = Stellar::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
-- `rspec spec`
+- `bundle exec rspec spec`
 
 ## Contributing
 
 1. Sign the [Contributor License Agreement](https://docs.google.com/forms/d/1g7EF6PERciwn7zfmfke5Sir2n10yddGGSXyZsq98tVY/viewform?usp=send_form)
-2. Fork it ( https://github.com/stellar/ruby-stellar-lib/fork )
+2. Fork it ( https://github.com/bloom-solutions/ruby-stellar-lib/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`)

data/lib/stellar-sdk.rb

@@ -1,12 +1,11 @@
-require 'stellar-base'
-require 'contracts'
+require "stellar-base"
+require_relative "./stellar/version"
 
 module Stellar
-
   autoload :Account
-  autoload :AccountInfo
   autoload :Amount
   autoload :Client
+  autoload :SEP10
 
   module Horizon
     extend ActiveSupport::Autoload

data/lib/stellar/account.rb

@@ -1,12 +1,10 @@
-require 'toml-rb'
-require 'uri'
-require 'faraday'
-require 'json'
+require "toml-rb"
+require "uri"
+require "faraday"
+require "json"
 
 module Stellar
   class Account
-    include Contracts
-
     delegate :address, to: :keypair
 
     def self.random
@@ -25,7 +23,7 @@ module Stellar
     end
 
     def self.lookup(federated_name)
-      _, domain = federated_name.split('*')
+      _, domain = federated_name.split("*")
       if domain.nil?
         raise InvalidFederationAddress.new
       end
@@ -33,25 +31,25 @@ module Stellar
       domain_req = Faraday.new("https://#{domain}/.well-known/stellar.toml").get
 
       unless domain_req.status == 200
-        raise InvalidStellarDomain.new('Domain does not contain stellar.toml file')
+        raise InvalidStellarDomain.new("Domain does not contain stellar.toml file")
       end
-      
+
       fed_server_url = TomlRB.parse(domain_req.body)["FEDERATION_SERVER"]
       if fed_server_url.nil?
-        raise InvalidStellarTOML.new('Invalid Stellar TOML file')
+        raise InvalidStellarTOML.new("Invalid Stellar TOML file")
       end
 
-      unless fed_server_url =~ URI::regexp
-        raise InvalidFederationURL.new('Invalid Federation Server URL')
+      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 do |req|
+      lookup_req = Faraday.new(fed_server_url).get { |req|
         req.params[:q] = federated_name
-        req.params[:type] = 'name'
-      end
+        req.params[:type] = "name"
+      }
 
       unless lookup_req.status == 200
-        raise AccountNotFound.new('Account not found')
+        raise AccountNotFound.new("Account not found")
       end
 
       JSON.parse(lookup_req.body)["account_id"]
@@ -64,7 +62,7 @@ module Stellar
 
     attr_reader :keypair
 
-    Contract Stellar::KeyPair => Any
+    # @param [Stellar::KeyPair] keypair
     def initialize(keypair)
       @keypair = keypair
     end
@@ -84,4 +82,4 @@ module Stellar
 
   class InvalidFederationURL < StandardError
   end
-end
+end

data/lib/stellar/amount.rb

@@ -1,25 +1,21 @@
 module Stellar
   class Amount
-    include Contracts
-
     attr_reader :amount
     attr_reader :asset
 
-    Contract Pos, Asset => Any
-    def initialize(amount, asset=Stellar::Asset.native())
+    # @param [Fixnum] amount
+    # @param [Stellar::Asset] asset
+    def initialize(amount, asset = Stellar::Asset.native)
       # TODO: how are we going to handle decimal considerations?
-      
+
       @amount = amount
-      @asset  = asset
+      @asset = asset
     end
 
-
-    Contract None => Or[
-      [Or[:alphanum4, :alphanum12], String, KeyPair, Pos],
-      [:native, Pos],
-    ]
+    # @return [Array(Symbol, Fixnum)] in case of a native asset
+    # @return [Array(Symbol, String, Stellar::KeyPair, Fixnum)] in case of alphanum asset
     def to_payment
-      case asset.type 
+      case asset.type
       when AssetType.asset_type_native
         [:native, amount]
       when AssetType.asset_type_credit_alphanum4
@@ -34,7 +30,7 @@ module Stellar
     end
 
     def inspect
-      "#<Stellar::Amount #{asset}(#{amount})>" 
+      "#<Stellar::Amount #{asset}(#{amount})>"
     end
   end
 end

data/lib/stellar/client.rb

@@ -1,32 +1,40 @@
-require 'hyperclient'
+require "hyperclient"
 require "active_support/core_ext/object/blank"
+require "securerandom"
 
 module Stellar
-  class Client
-    include Contracts
-    C = Contracts
+  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
 
-    HORIZON_LOCALHOST_URL = 'http://127.0.0.1:8000'
-    HORIZON_MAINNET_URL = 'https://horizon.stellar.org'
-    HORIZON_TESTNET_URL = 'https://horizon-testnet.stellar.org'
-    FRIENDBOT_URL = 'https://friendbot.stellar.org'.freeze
+    HORIZON_LOCALHOST_URL = "http://127.0.0.1:8000"
+    HORIZON_MAINNET_URL = "https://horizon.stellar.org"
+    HORIZON_TESTNET_URL = "https://horizon-testnet.stellar.org"
+    FRIENDBOT_URL = "https://friendbot.stellar.org".freeze
 
-    def self.default(options={})
+    def self.default(options = {})
       new options.merge(
         horizon: HORIZON_MAINNET_URL
       )
     end
 
-    def self.default_testnet(options={})
+    def self.default_testnet(options = {})
       new options.merge(
-        horizon:   HORIZON_TESTNET_URL,
-        friendbot: HORIZON_TESTNET_URL,
+        horizon: HORIZON_TESTNET_URL,
+        friendbot: HORIZON_TESTNET_URL
       )
     end
 
-    def self.localhost(options={})
+    def self.localhost(options = {})
       new options.merge(
         horizon: HORIZON_LOCALHOST_URL
       )
@@ -34,10 +42,10 @@ module Stellar
 
     attr_reader :horizon
 
-    Contract ({horizon: String}) => Any
+    # @option options [String] :horizon The Horizon server URL.
     def initialize(options)
       @options = options
-      @horizon = Hyperclient.new(options[:horizon]) do |client|
+      @horizon = Hyperclient.new(options[:horizon]) { |client|
         client.faraday_block = lambda do |conn|
           conn.use Faraday::Response::RaiseError
           conn.use FaradayMiddleware::FollowRedirects
@@ -46,34 +54,39 @@ module Stellar
           conn.adapter :excon
         end
         client.headers = {
-          'Accept' => 'application/hal+json,application/problem+json,application/json'
+          "Accept" => "application/hal+json,application/problem+json,application/json",
+          "X-Client-Name" => "ruby-stellar-sdk",
+          "X-Client-Version" => VERSION
         }
-      end
+      }
     end
 
-    Contract Stellar::Account => Any
-    def account_info(account)
-      account_id  = account.address
-      @horizon.account(account_id:account_id)._get
+    # @param [Stellar::Account|String] account_or_address
+    def account_info(account_or_address)
+      account_id = if account_or_address.is_a?(Stellar::Account)
+        account_or_address.address
+      else
+        account_or_address
+      end
+      @horizon.account(account_id: account_id)._get
     end
 
-    Contract ({
-      account:     Stellar::Account,
-      destination: Stellar::Account
-    }) => Any
-    def account_merge(options={})
-      account     = options[:account]
+    # @option options [Stellar::Account] :account
+    # @option options [Stellar::Account] :destination
+    def account_merge(options = {})
+      account = options[:account]
       destination = options[:destination]
-      sequence    = options[:sequence] || (account_info(account).sequence.to_i + 1)
+      sequence = options[:sequence] || (account_info(account).sequence.to_i + 1)
 
-      transaction = Stellar::Transaction.account_merge({
-        account:     account.keypair,
-        destination: destination.keypair,
-        sequence:    sequence
-      })
+      transaction = Stellar::TransactionBuilder.new(
+        source_account: destination.keypair,
+        sequence_number: sequence
+      ).add_operation(
+        Stellar::Operation.account_merge(destination: destination.keypair)
+      ).set_timeout(0).build
 
-      envelope_base64 = transaction.to_envelope(account.keypair).to_xdr(:base64)
-      @horizon.transactions._post(tx: envelope_base64)
+      envelope = transaction.to_envelope(account.keypair)
+      submit_transaction(tx_envelope: envelope)
     end
 
     def friendbot(account)
@@ -82,70 +95,65 @@ module Stellar
       Faraday.post(uri.to_s)
     end
 
-    Contract ({
-      account:          Stellar::Account,
-      funder:           Stellar::Account,
-      starting_balance: Integer
-    }) => Any
-    def create_account(options={})
-      funder   = options[:funder]
+    # @option options [Stellar::Account] :account
+    # @option options [Stellar::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 = Stellar::Transaction.create_account({
-        account:          funder.keypair,
-        destination:      options[:account].keypair,
-        sequence:         sequence,
-        starting_balance: options[:starting_balance],
-        fee: fee,
-      })
-
-      envelope_base64 = payment.to_envelope(funder.keypair).to_xdr(:base64)
-      @horizon.transactions._post(tx: envelope_base64)
-    end
-
-    Contract ({
-      from:     Stellar::Account,
-      to:       Stellar::Account,
-      amount:   Stellar::Amount
-    }) => Any
-    def send_payment(options={})
-      from_account     = options[:from]
+      payment = Stellar::TransactionBuilder.new(
+        source_account: funder.keypair,
+        sequence_number: sequence,
+        base_fee: fee
+      ).add_operation(
+        Stellar::Operation.create_account({
+          destination: options[:account].keypair,
+          starting_balance: options[:starting_balance]
+        })
+      ).set_timeout(0).build
+
+      envelope = payment.to_envelope(funder.keypair)
+      submit_transaction(tx_envelope: envelope)
+    end
+
+    # @option options [Stellar::Account] :from The source account
+    # @option options [Stellar::Account] :to The destination account
+    # @option options [Stellar::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_details = {
-        destination: options[:to].keypair,
-        sequence:    sequence,
-        amount:      options[:amount].to_payment,
-        memo:        options[:memo],
-      }
-
-      payment_details[:account] = tx_source_account.keypair
-      if op_source_account.present?
-        payment_details[:source_account] = op_source_account.keypair
-      end
-
-      payment = Stellar::Transaction.payment(payment_details)
+      payment = Stellar::TransactionBuilder.new(
+        source_account: tx_source_account.keypair,
+        sequence_number: sequence
+      ).add_operation(
+        Stellar::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_base64 = payment.to_envelope(*to_envelope_args).to_xdr(:base64)
-      @horizon.transactions._post(tx: envelope_base64)
+      envelope = payment.to_envelope(*to_envelope_args)
+      submit_transaction(tx_envelope: envelope)
     end
 
-    Contract ({
-      account:  Maybe[Stellar::Account],
-      limit:    Maybe[Pos],
-      cursor:   Maybe[String]
-    }) => TransactionPage
-    def transactions(options={})
+    # @option options [Stellar::Account] :account
+    # @option options [Integer] :limit
+    # @option options [Integer] :cursor
+    # @return [Stellar::TransactionPage]
+    def transactions(options = {})
       args = options.slice(:limit, :cursor)
 
       resource = if options[:account]
@@ -158,13 +166,11 @@ module Stellar
       TransactionPage.new(resource)
     end
 
-    Contract(C::KeywordArgs[
-      asset: [Symbol, String, Xor[Stellar::KeyPair, Stellar::Account]],
-      source: Stellar::Account,
-      sequence: Maybe[Integer],
-      fee: Maybe[Integer],
-      limit: Maybe[Integer],
-    ] => Any)
+    # @param [Array(Symbol,String,Stellar::KeyPair|Stellar::Account)] asset
+    # @param [Stellar::Account] source
+    # @param [Integer] sequence
+    # @param [Integer] fee
+    # @param [Integer] limit
     def change_trust(
       asset:,
       source:,
@@ -177,15 +183,117 @@ module Stellar
       args = {
         account: source.keypair,
         sequence: sequence,
-        line: asset,
+        line: asset
       }
-      args[:limit] = limit if !limit.nil?
+      args[:limit] = limit unless limit.nil?
 
       tx = Stellar::Transaction.change_trust(args)
 
-      envelope_base64 = tx.to_envelope(source.keypair).to_xdr(:base64)
-      horizon.transactions._post(tx: envelope_base64)
+      envelope = tx.to_envelope(source.keypair)
+      submit_transaction(tx_envelope: envelope)
+    end
+
+    # @param [Stellar::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
+      @horizon.transactions._post(tx: tx_envelope.to_xdr(:base64))
+    end
+
+    # Required by SEP-0029
+    # @param [Stellar::TransactionEnvelope] tx_envelope
+    def check_memo_required(tx_envelope)
+      tx = tx_envelope.tx
+
+      if tx.is_a?(Stellar::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 != Stellar::MemoType.memo_none
+        return
+      end
+
+      destinations = Set.new
+      ot = Stellar::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 == Stellar::CryptoKeyType.key_type_muxed_ed25519
+          next
+        end
+
+        destinations.add(destination)
+        kp = Stellar::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 Stellar::SEP10.build_challenge_tx and
+    # will be removed in the next major version release.
+    #
+    # A wrapper function for Stellar::SEP10::build_challenge_tx.
+    #
+    # @param server [Stellar::KeyPair] Keypair for server's signing account.
+    # @param client [Stellar::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)
+      Stellar::SEP10.build_challenge_tx(
+        server: server, client: client, anchor_name: anchor_name, timeout: timeout
+      )
+    end
+
+    # DEPRECATED: this function has been moved to Stellar::SEP10::read_challenge_tx and
+    # will be removed in the next major version release.
+    #
+    # A wrapper function for Stellar::SEP10.verify_challenge_transaction
+    #
+    # @param challenge [String] SEP0010 transaction challenge in base64.
+    # @param server [Stellar::KeyPair] Stellar::KeyPair for server where the challenge was generated.
+    #
+    # @return [Boolean]
+    def verify_challenge_tx(challenge:, server:)
+      Stellar::SEP10.verify_challenge_tx(challenge_xdr: challenge, server: server)
+      true
     end
 
+    # DEPRECATED: this function has been moved to Stellar::SEP10::verify_tx_signed_by and
+    # will be removed in the next major version release.
+    #
+    # @param transaction_envelope [Stellar::TransactionEnvelope]
+    # @param keypair [Stellar::KeyPair]
+    #
+    # @return [Boolean]
+    #
+    def verify_tx_signed_by(transaction_envelope:, keypair:)
+      Stellar::SEP10.verify_tx_signed_by(
+        tx_envelope: transaction_envelope, keypair: keypair
+      )
+    end
   end
 end