revolut-api 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "revolut/api"
+
+require "yaml"
+
+cfg_path                    =   File.join(File.dirname(__FILE__), "../credentials.yml")
+
+if ::File.exists?(cfg_path)
+  cfg                       =   YAML.load_file(cfg_path)
+
+  Revolut::Api.configure do |config|
+    config.user_id          =   cfg["user_id"]
+    config.access_token     =   cfg["access_token"]
+    
+    config.user_agent       =   cfg["user_agent"]
+    
+    config.device_id        =   cfg["device_id"]
+    config.device_model     =   cfg["device_model"]
+    
+    config.api_version      =   cfg["api_version"]
+    config.client_version   =   cfg["client_version"]
+    
+    config.verbose          =   true
+  end
+end
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.config.history.file = File.join(__FILE__, "../.pry_history")
+Pry.start
+
+#require "irb"
+#IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/credentials.yml.example

@@ -0,0 +1,7 @@
+user_id: "foobar-2313221-barfoo-321322-foobar"
+access_token: "foobarbarfoo-token"
+client_version: "5.12.1"
+api_version: "1"
+user_agent: "Revolut/com.revolut.revolut (iPhone; iOS 11.1)"
+device_id: "SOME-DEVICE-ID"
+device_model: "iPhone8,1"

data/lib/revolut/api.rb

@@ -0,0 +1,55 @@
+require "base64"
+require "json"
+require "securerandom"
+
+require "faraday"
+require "faraday_middleware"
+
+require "revolut/api/version"
+
+require "revolut/api/constants"
+require "revolut/api/errors"
+require "revolut/api/utilities"
+require "revolut/api/configuration"
+
+require "revolut/api/response/user"
+require "revolut/api/response/address"
+require "revolut/api/response/wallet"
+require "revolut/api/response/pocket"
+require "revolut/api/response/card_issuer"
+require "revolut/api/response/card"
+require "revolut/api/response/transaction"
+require "revolut/api/response/merchant"
+require "revolut/api/response/quote"
+
+require "revolut/api/base"
+
+require "revolut/api/private/auth"
+require "revolut/api/private/user"
+require "revolut/api/private/exchange"
+require "revolut/api/private/transactions"
+
+require "revolut/api/client"
+require "revolut/api/public/client"
+
+require 'revolut/api/railtie' if defined?(Rails)
+
+module Revolut
+  module Api
+    class << self
+      attr_writer :configuration
+    end
+
+    def self.configuration
+      @configuration  ||=   ::Revolut::Api::Configuration.new
+    end
+
+    def self.reset
+      @configuration    =   ::Revolut::Api::Configuration.new
+    end
+
+    def self.configure
+      yield(configuration)
+    end
+  end
+end

data/lib/revolut/api/base.rb

@@ -0,0 +1,124 @@
+module Revolut
+  module Api
+    class Base
+      attr_accessor :host, :configuration, :headers, :memoized
+    
+      def initialize(host: "api.revolut.com", configuration: ::Revolut::Api.configuration)
+        self.host             =   host
+        
+        self.configuration    =   configuration
+        
+        self.headers          =   {
+          'Host'  =>  self.host
+        }
+        
+        self.memoized         =   {}
+      end
+      
+      include ::Revolut::Api::Errors
+    
+      def to_uri(path)
+        "https://#{self.host}/#{path}"
+      end
+      
+      def check_configuration!
+        %w(user_id access_token user_agent device_id device_model).each do |config_key|
+          raise ::Revolut::Api::MissingConfigurationError, "You need to specify the #{config_key.gsub("_", " ")}!" if ::Revolut::Api.configuration.send(config_key).to_s.empty?
+        end
+      end
+    
+      def quotes(from: [], to: [], endpoint: "quote", options: {})
+        from        =   (from.is_a?(Array) ? from : split_to_array(from)).collect(&:upcase)
+        to          =   (to.is_a?(Array) ? to : split_to_array(to)).collect(&:upcase)
+        args        =   []
+      
+        from.each do |f|
+          to.each do |t|
+            args   <<   "#{f.to_s.upcase}#{t.to_s.upcase}"
+          end
+        end
+
+        params      =   {symbol: args}
+      
+        options[:params_encoder]  =   ::Faraday::FlatParamsEncoder
+      
+        response    =   get(endpoint, params: params, options: options)
+        data        =   []
+      
+        if response && response.is_a?(Array) && response.any?
+          response.each do |hash|
+            data   <<   ::Revolut::Api::Response::Quote.new(hash)
+          end
+        end
+      
+        return data
+      end
+    
+      def split_to_array(string)
+        string.include?(",") ? string.split(",") : [string]
+      end
+    
+      def get(path, params: {}, options: {})
+        request path, method: :get, params: params, options: options
+      end
+
+      def post(path, params: {}, data: {}, options: {})
+        request path, method: :post, params: params, data: data, options: options
+      end
+    
+      def patch(path, params: {}, data: {}, options: {})
+        request path, method: :patch, params: params, data: data, options: options
+      end
+
+      def request(path, method: :get, params: {}, data: {}, options: {})
+        check_configuration! if options.fetch(:check_configuration, true)
+        
+        authenticate      =   options.fetch(:authenticate, true)
+        params_encoder    =   options.fetch(:params_encoder, nil)
+        user_agent        =   options.fetch(:user_agent, self.configuration.user_agent)
+      
+        self.headers.merge!(user_agent: user_agent) unless user_agent.to_s.empty?
+      
+        opts              =   {url: to_uri(path)}
+        opts.merge!(request: { params_encoder: params_encoder }) unless params_encoder.nil?
+  
+        connection        =   Faraday.new(opts) do |builder|
+          builder.headers = self.headers
+          
+          builder.request  :basic_auth, self.configuration.user_id, self.configuration.access_token if authenticate && authable?
+          builder.request  :json
+          
+          builder.response :json
+          builder.response :logger if self.configuration.verbose
+    
+          builder.adapter  :net_http
+        end
+
+        response              =   case method
+          when :get
+            connection.get do |request|
+              request.params  =   params if params && !params.empty?
+            end&.body
+          when :post, :patch
+            connection.send(method) do |request|
+              request.body    =   data
+              request.params  =   params if params && !params.empty?
+            end&.body
+        end
+        
+        error?(response)
+        
+        return response
+      end
+      
+      def authable?
+        !self.configuration.user_id.to_s.empty? && !self.configuration.access_token.to_s.empty?
+      end
+      
+      def log(message)
+        puts "[Revolut::Api] - #{Time.now}: #{message}" if !message.to_s.empty? && self.configuration.verbose
+      end
+    
+    end
+  end
+end

data/lib/revolut/api/client.rb

@@ -0,0 +1,29 @@
+module Revolut
+  module Api
+    class Client < ::Revolut::Api::Base
+    
+      def initialize(host: "api.revolut.com", configuration: ::Revolut::Api.configuration)
+        super(host: host, configuration: configuration)
+      
+        set_headers
+      end
+    
+      def set_headers
+        self.headers.merge!({
+          'X-Client-Version'  =>  self.configuration.client_version,
+          'X-Api-Version'     =>  self.configuration.api_version,
+          'X-Device-Id'       =>  self.configuration.device_id,
+          'X-Device-Model'    =>  self.configuration.device_model
+        })
+        
+        self.headers.delete_if { |key, value| value.to_s.empty? }
+      end
+      
+      include ::Revolut::Api::Private::Auth
+      include ::Revolut::Api::Private::User
+      include ::Revolut::Api::Private::Exchange
+      include ::Revolut::Api::Private::Transactions
+    
+    end
+  end
+end

data/lib/revolut/api/configuration.rb

@@ -0,0 +1,26 @@
+module Revolut
+  module Api
+    class Configuration
+      attr_accessor :user_id, :access_token, :user_agent
+      attr_accessor :device_id, :device_model
+      attr_accessor :api_version, :client_version
+      attr_accessor :verbose
+    
+      def initialize
+        self.user_id          =   nil
+        self.access_token     =   nil
+        
+        self.user_agent       =   "Revolut/com.revolut.revolut (iPhone; iOS 11.1)"
+      
+        self.device_id        =   SecureRandom.uuid
+        self.device_model     =   "iPhone8,1"
+      
+        self.api_version      =   "1"
+        self.client_version   =   "5.12.1"
+      
+        self.verbose          =   false
+      end
+      
+    end
+  end
+end

data/lib/revolut/api/constants.rb

@@ -0,0 +1,26 @@
+module Revolut
+  module Api
+    class Constants
+    
+      CRYPTOS       =   [
+        'BTC',
+        'LTC',
+        'ETH',
+        'XRP'
+      ]
+    
+      BASE_UNITS    =   {
+        fiat:       100.0,
+        crypto:     100_000_000.0
+      }
+    
+      TIME          =   {
+        epoch_base: 1_000,
+        one_month:  2629746
+      }
+    
+      PUBLIC_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.2 Safari/605.1.15"
+        
+    end
+  end
+end

data/lib/revolut/api/errors.rb

@@ -0,0 +1,20 @@
+module Revolut
+  module Api
+    class MissingConfigurationError < StandardError; end
+    class AuthorizationError < StandardError; end
+    
+    module Errors
+      MAPPING = {
+        "The request should be authorized." => -> { raise ::Revolut::Api::AuthorizationError.new("Authorization failed!") },
+      }
+      
+      def error?(response)
+        if response.is_a?(Hash) && response.has_key?("message")
+          message   =   response.fetch("message", nil)
+          ::Revolut::Api::Errors::MAPPING.fetch(message, nil)&.call
+        end
+      end
+    end
+
+  end
+end

data/lib/revolut/api/private/auth.rb

@@ -0,0 +1,49 @@
+module Revolut
+  module Api
+    module Private
+      module Auth
+      
+        def signin(phone:, password:)
+          data          =     {
+            phone:    phone,
+            password: password
+          }
+          
+          options       =     {
+            check_configuration: false,
+            authenticate:        false
+          }
+          
+          post("signin", data: data, options: options)
+        end
+      
+        def confirm_signin(phone:, code:)
+          data          =     {
+            phone:    phone,
+            code:     code.gsub("-", "")
+          }
+          
+          options       =     {
+            check_configuration: false,
+            authenticate:        false
+          }
+          
+          response      =   post("signin/confirm", data: data, options: options)
+          
+          auth_data     =   {id: response&.dig("user", "id"), access_token: response&.fetch("accessToken", nil)}
+          auth_data.delete_if { |key, value| value.to_s.empty? }
+          
+          if !auth_data.empty?
+            self.configuration.user_id        =   auth_data.fetch(:id, nil)
+            self.configuration.access_token   =   auth_data.fetch(:access_token, nil)
+          else
+            auth_data   =   nil
+          end
+          
+          return auth_data
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/private/exchange.rb

@@ -0,0 +1,91 @@
+module Revolut
+  module Api
+    module Private
+      module Exchange
+
+        def exchange(from:, to:, amount:, side: :sell)
+          status, success   =   nil, nil
+          transactions      =   []
+          error             =   {}
+          from              =   from.to_s.upcase
+          to                =   to.to_s.upcase
+
+          if amount.eql?(:all)
+            pocket          =   self.wallet.pocket(from)
+
+            if pocket
+              amount        =   pocket.balance
+              log "Will exchange total balance #{from} to #{to}. Balance: #{amount}."
+            end
+          end
+      
+          if !from.to_s.empty? && !to.to_s.empty? && !amount.nil?
+            log "Will exchange #{amount} #{from} to #{to}"
+
+            payload             =   {
+              "fromCcy"         =>    from,
+              "toCcy"           =>    to,
+              "rateTimestamp"   =>    Time.now.utc.to_i,
+            }
+
+            if side.eql?(:sell)
+              payload.merge!("fromAmount" => ::Revolut::Api::Utilities.convert_to_integer_amount(from, amount))
+            elsif side.eql?(:buy)
+              payload.merge!("toAmount" => ::Revolut::Api::Utilities.convert_to_integer_amount(to, amount))
+            end
+
+            data                =   post("exchange", data: payload.to_json)
+
+            if data && data.is_a?(Array) && data.any?
+              data.each do |response|
+                transactions   <<   ::Revolut::Api::Response::Transaction.new(response)
+              end
+
+              complete_count    =   0
+              pending_count     =   0
+
+              transactions.each do |transaction|
+                complete_count +=   1 if transaction.completed?
+                pending_count  +=   1 if transaction.pending?
+              end
+
+              success           =   (complete_count == data.count || pending_count == data.count)
+              status            =   :completed if complete_count == data.count
+              status            =   :pending   if pending_count == data.count
+
+              log "Successfully exchanged #{amount} #{from} to #{to}!"            if status.eql?(:completed)
+              log "Exchange from #{amount} #{from} to #{to} is currently pending" if status.eql?(:pending)
+
+            elsif data && data.is_a?(Hash)
+              error_message     =   data.fetch("message", nil)
+              error_code        =   data.fetch("code", nil)
+
+              status            =   :failed
+              success           =   false
+              error[:message]   =   error_message if !error_message.to_s.empty?
+              error[:code]      =   error_code    if !error_code.to_s.empty?
+
+              log "Error occurred while trying to exchange #{amount} #{from} to #{to}. Error (#{error_code}): #{error_message}"
+            end
+          else
+            log "Missing some data required for the exchange. From: #{from}. To: #{to}. Amount: #{amount}."
+          end
+
+          return {status: status, success: success, transactions: transactions, error: error}
+        end
+
+        def quote(from:, to:, amount:, side: :sell)
+          params      =   {
+            amount: ::Revolut::Api::Utilities.convert_to_integer_amount(from, amount),
+            side:   side.to_s.upcase
+          }
+
+          endpoint    =   "quote/#{from.to_s.upcase}#{to.to_s.upcase}"
+
+          return ::Revolut::Api::Response::Quote.new(get(endpoint, params: params))
+        end
+
+      end
+    end
+  end
+end