stellar-sdk 0.4.0 → 0.9.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3c1d917a218343ba852380651053255ddc4aa0293d96cfee5ef4856d5aa9fe2
-  data.tar.gz: 69f8d0f5e220140e02527ff284877a424c284065e3f397a88f28221d2c73af69
+  metadata.gz: 3da720d62d3ed03b2eba1ac3e1bcc733da7013952120bcbc2feb31ec53c2eb90
+  data.tar.gz: d23901b3e1d9b6d3107cdeae940dda89ca19c180efd3c63be07823493c5c147e
 SHA512:
-  metadata.gz: e4cb249129ec6e825c83d54a095e255f27e91ef7d3202efd66bceab1fd6fb06095feb82b6a1f5f56210c7c87e6db0a2e030dd285364152ea904c65c95cb46fd1
-  data.tar.gz: 5e0a36fdd2c0de489a39d8582d54f4495db4dbbaf8079c6656d1e96bac19fac3febc08eb19566f75d12c38b4929f2d76e196a374499bc89246c36a84df43d7c3
+  metadata.gz: c944e5f554aa13148f1268d6a7d5adaf1f61f942234ae6c87eebce880cc9f419edbfecb384bb76129ef41782c6647667ece34b5bb9fab8b18e04a6e7de068532
+  data.tar.gz: dc25b0c39c815dd3817272547d98df7400ad97f55c70e7adc1b72b55661f16d62ea733413b0375c77562586cb025dcbc1b67b049418ac4bb9224e1ae977eaad8

data/CHANGELOG.md

@@ -4,10 +4,29 @@ 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/).
 
-## [Unreleased]
+## [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
+
+## [0.6.0] - 2018-11-27
+### Added
+- Allow setting of memo in `Stellar::Client#send_payment`
+- Optionally send payments through a payment channel with `Stellar::Client#send_payment`
+- Clarify variable names for payment channels in `#send_payment`
+
+## [0.5.0] - 2018-07-10
 ### Changed
-- Update stellar-base to `~> 0.12.0`
+- Update stellar-base to `>= 0.16.0`
+- Update hyperclient, excon, contracts, activesupport
 
 ### Fixed
 - `#create_account`, along with `#send_payment`
 
+### Added
+- `Stellar::Client#change_trust` to create, update, delete a trustline
+- `Stellar::Client#account_merge` to merge accounts

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,16 +42,25 @@ client.send_payment({
 }) 
 ```
 
+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
+```
+
 ## 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,34 +1,51 @@
-require 'hyperclient'
+require "hyperclient"
+require "active_support/core_ext/object/blank"
+require "securerandom"
 
 module Stellar
+  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
-    include Contracts
+    DEFAULT_FEE = 100
 
-    def self.default(options={})
-      new options.merge({
-        horizon:   "https://horizon.stellar.org"
-      })
+    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 = {})
+      new options.merge(
+        horizon: HORIZON_MAINNET_URL
+      )
     end
 
-    def self.default_testnet(options={})
-      new options.merge({
-        horizon:   "https://horizon-testnet.stellar.org",
-        friendbot: "https://horizon-testnet.stellar.org",
-      })
+    def self.default_testnet(options = {})
+      new options.merge(
+        horizon: HORIZON_TESTNET_URL,
+        friendbot: HORIZON_TESTNET_URL
+      )
     end
 
-    def self.localhost(options={})
-      new options.merge({
-        horizon: "http://127.0.0.1:8000"
-      })
+    def self.localhost(options = {})
+      new options.merge(
+        horizon: HORIZON_LOCALHOST_URL
+      )
     end
 
     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
@@ -37,71 +54,106 @@ 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
+
+    # @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
+
+    # @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)
+
+      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 = transaction.to_envelope(account.keypair)
+      submit_transaction(tx_envelope: envelope)
     end
 
     def friendbot(account)
-      raise NotImplementedError
-    end
-
-    Contract Stellar::Account => Any
-    def account_info(account)
-      account_id  = account.address
-      @horizon.account(account_id:account_id)._get
-    end
-
-    Contract ({
-      from:     Stellar::Account,
-      to:       Stellar::Account,
-      amount:   Stellar::Amount
-    }) => Any
-    def send_payment(options={})
-      from     = options[:from]
-      sequence = options[:sequence] || (account_info(from).sequence.to_i + 1)
-
-      payment = Stellar::Transaction.payment({
-        account:     from.keypair,
-        destination: options[:to].keypair,
-        sequence:    sequence,
-        amount:      options[:amount].to_payment,
-      })
-
-      envelope_base64 = payment.to_envelope(from.keypair).to_xdr(:base64)
-      @horizon.transactions._post(tx: envelope_base64)
-    end
-
-    Contract ({
-      account:          Stellar::Account,
-      funder:           Stellar::Account,
-      starting_balance: Integer
-    }) => Any
-    def create_account(options={})
-      funder   = options[:funder]
+      uri = URI.parse(FRIENDBOT_URL)
+      uri.query = "addr=#{account.address}"
+      Faraday.post(uri.to_s)
+    end
+
+    # @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] || 100
-
-      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 ({
-      account:  Maybe[Stellar::Account],
-      limit:    Maybe[Pos],
-      cursor:   Maybe[String]
-    }) => TransactionPage
-    def transactions(options={})
+      fee = options[:fee] || DEFAULT_FEE
+
+      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 = 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 = payment.to_envelope(*to_envelope_args)
+      submit_transaction(tx_envelope: envelope)
+    end
+
+    # @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]
@@ -114,5 +166,134 @@ module Stellar
       TransactionPage.new(resource)
     end
 
+    # @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:,
+      sequence: nil,
+      fee: DEFAULT_FEE,
+      limit: nil
+    )
+      sequence ||= (account_info(source).sequence.to_i + 1)
+
+      args = {
+        account: source.keypair,
+        sequence: sequence,
+        line: asset
+      }
+      args[:limit] = limit unless limit.nil?
+
+      tx = Stellar::Transaction.change_trust(args)
+
+      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: Base64.encode64(tx_envelope.to_xdr))
+    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