stellar-sdk 0.8.0 → 0.9.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7c9a8f80386d8ae7e790f4cd5198968433c692417c2de7fd87d8d934d966e6a
-  data.tar.gz: d31590ea3a3a2d469f4f0fc5fe59232696c7d090a4ab70415d823fed3a9228b1
+  metadata.gz: 3da720d62d3ed03b2eba1ac3e1bcc733da7013952120bcbc2feb31ec53c2eb90
+  data.tar.gz: d23901b3e1d9b6d3107cdeae940dda89ca19c180efd3c63be07823493c5c147e
 SHA512:
-  metadata.gz: 45d62b035a05bdcdf5f93bf696e67e490a7f87df4b4e64b43503eb7e91a0b7dcfe7d4b8556119a0db9021ed32c8f2bf98684470bf58dae383d78fb44e67f8324
-  data.tar.gz: 919b5641f08bd77ada6f39b0eac25e89a4aa8b66d27c7b32bdbfa2efe26b701551612d7b997750185124f6de3252a5013390982032c771a26103d3e2dc367b66
+  metadata.gz: c944e5f554aa13148f1268d6a7d5adaf1f61f942234ae6c87eebce880cc9f419edbfecb384bb76129ef41782c6647667ece34b5bb9fab8b18e04a6e7de068532
+  data.tar.gz: dc25b0c39c815dd3817272547d98df7400ad97f55c70e7adc1b72b55661f16d62ea733413b0375c77562586cb025dcbc1b67b049418ac4bb9224e1ae977eaad8

data/README.md

@@ -7,19 +7,18 @@ This library helps you to integrate your application into the [Stellar network](
 
 ## 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.
 

data/lib/stellar-sdk.rb

@@ -1,8 +1,7 @@
-require 'stellar-base'
-require 'contracts'
+require "stellar-base"
+require_relative "./stellar/version"
 
 module Stellar
-
   autoload :Account
   autoload :Amount
   autoload :Client

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,35 +1,40 @@
-require 'hyperclient'
+require "hyperclient"
 require "active_support/core_ext/object/blank"
-require 'securerandom'
+require "securerandom"
 
 module Stellar
-  class InvalidSep10ChallengeError < StandardError; end
+  class AccountRequiresMemoError < StandardError
+    attr_reader :account_id, :operation_index
 
-  class Client
-    include Contracts
-    C = Contracts
+    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
       )
@@ -37,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
@@ -49,40 +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,
+          "X-Client-Version" => VERSION
         }
-      end
+      }
     end
 
-    Contract Or[Stellar::Account, String] => Any
+    # @param [Stellar::Account|String] account_or_address
     def account_info(account_or_address)
-      if account_or_address.is_a?(Stellar::Account)
-        account_id = account_or_address.address
+      account_id = if account_or_address.is_a?(Stellar::Account)
+        account_or_address.address
       else
-        account_id = account_or_address
+        account_or_address
       end
-      @horizon.account(account_id:account_id)._get
+      @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)
@@ -91,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)
+      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
 
-    Contract ({
-      from:     Stellar::Account,
-      to:       Stellar::Account,
-      amount:   Stellar::Amount
-    }) => Any
-    def send_payment(options={})
-      from_account     = options[:from]
+    # @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]
@@ -167,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:,
@@ -186,27 +183,79 @@ 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: 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
 
-    Contract(C::KeywordArgs[
-      server: Stellar::KeyPair,
-      client: Stellar::KeyPair,
-      anchor_name: String,
-      timeout: C::Optional[Integer]
-    ] => String)
     # 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.
@@ -219,10 +268,6 @@ module Stellar
       )
     end
 
-    Contract(C::KeywordArgs[
-      challenge: String,
-      server: Stellar::KeyPair
-    ] => C::Bool)    
     # DEPRECATED: this function has been moved to Stellar::SEP10::read_challenge_tx and
     # will be removed in the next major version release.
     #
@@ -233,18 +278,14 @@ module Stellar
     #
     # @return [Boolean]
     def verify_challenge_tx(challenge:, server:)
-      Stellar::SEP10.verify_challenge_tx(challenge_tx: challenge, server: server)
+      Stellar::SEP10.verify_challenge_tx(challenge_xdr: challenge, server: server)
       true
     end
 
-    Contract(C::KeywordArgs[
-      transaction_envelope: Stellar::TransactionEnvelope,
-      keypair: Stellar::KeyPair
-    ] => C::Bool)
     # 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 transaction_envelope [Stellar::TransactionEnvelope]
     # @param keypair [Stellar::KeyPair]
     #
     # @return [Boolean]
@@ -254,6 +295,5 @@ module Stellar
         tx_envelope: transaction_envelope, keypair: keypair
       )
     end
-    
   end
 end