cryptoprocessing 0.6.1

data/lib/cryptoprocessing/cli.rb

@@ -0,0 +1,203 @@
+require 'cryptoprocessing'
+require 'thor'
+require 'json/ext'
+
+module Cryptoprocessing
+  class CLI < Thor
+    class_option :verbose, :type => :boolean
+    class_option :api_endpoint
+    class_option :api_namespace
+    class_option :access_token
+
+    def initialize(*args)
+      super
+      config = {}
+      config[:api_endpoint] = options[:api_endpoint] if options[:api_endpoint]
+      config[:api_namespace] = options[:api_namespace] if options[:api_namespace]
+      config[:access_token] = options[:access_token] if options[:access_token]
+
+      @client = Cryptoprocessing::Client.new(config)
+    end
+
+    desc "register EMAIL PASSWORD", "Register user at Cryptoprocessing with EMAIL and PASSWORD"
+
+    def register(email, password)
+      output = []
+      response = @client.register({:email => email, :password => password})
+      output << response['message']
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "login EMAIL PASSWORD", "Login user to Cryptoprocessing using EMAIL and PASSWORD"
+
+    def login(email, password)
+      output = []
+      response = @client.login({:email => email, :password => password})
+      output << response['message']
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "create_account CURRENCY NAME", "Create account for user with NAME"
+
+    def create_account(currency, name)
+      output = []
+      response = @client.create_account({:currency => currency, :name => name})
+      output << "Account with ID #{response['account_id']} created."
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "account ACCOUNT_ID", "Get account info by ACCOUNT_ID"
+
+    def account(account_id, currency = nil)
+      output = []
+      response = @client.account(account_id,{:currency => currency})
+      output << "Account #{account_id} info:"
+      output << JSON.pretty_generate(response['data'])
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "create_address NAME", "Add address to NAME"
+
+    def create_address(account_id, name = nil)
+      output = []
+      response = @client.create_address(account_id, {:name => name})
+      output << "Address with ID #{response['id']} created."
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "addresses ACCOUNT_ID", "Addresses for ACCOUNT_ID"
+
+    def addresses(account_id)
+      output = []
+      response = @client.addresses(account_id)
+      if response.kind_of?(Array) and response.length == 0
+        output << "No addresses for account #{account_id}."
+      elsif response['addresses'].kind_of?(Array) && response['transactions'].length > 0
+        output << "Addresses for account #{account_id}:"
+        output << JSON.pretty_generate(response)
+      else
+        output << "No addresses for account #{account_id}."
+      end
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "address ACCOUNT_ID ADDRESS", "Show address info for ACCOUNT_ID and ADDRESS"
+
+    def address(account_id, address)
+      output = []
+      response = @client.address(account_id, address)
+      output << "Address #{address} for account #{account_id} info:"
+      output << JSON.pretty_generate(response)
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "transactions ACCOUNT_ID", "List transactions by ACCOUNT_ID"
+
+    def transactions(account_id)
+      output = []
+      response = @client.transactions(account_id)
+      if response.kind_of?(Array) and response.length == 0
+        output << "No transactions for account #{account_id} and address #{account_id}."
+      elsif response['transactions'].kind_of?(Array) && response['transactions'].length > 0
+        output << "Transactions for account #{account_id}:"
+        output << JSON.pretty_generate(response['transactions'])
+      else
+        output << "No transactions for account #{account_id}."
+      end
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "transactions_by_address ACCOUNT_ID ADDRESS", "List transactions from ACCOUNT_ID with address ADDRESS"
+
+    def transactions_by_address(account_id, address)
+      output = []
+      response = @client.transactions_by_address(account_id, address)
+      if response.kind_of?(Array) and response.length == 0
+        output << "No transactions for account #{account_id} and address #{address}."
+      elsif response['transactions'].kind_of?(Array) && response['transactions'].length > 0
+        output << "Transactions for account #{account_id} and address #{address}:"
+        output << JSON.pretty_generate(response['transactions'])
+      else
+        output << "No transactions for account #{account_id} and address #{address}."
+      end
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "send_raw_transaction RAW_TRANSACTION_ID DESCRIPTION", "Send RAW_TRANSACTION_ID with DESCRIPTION"
+
+    def send_raw_transaction(raw_transaction_id, description = nil)
+      output = []
+      response = @client.send_raw_transaction({
+                                                  :raw_transactions_id => raw_transaction_id,
+                                                  :description => description
+                                              })
+      output << response['message']
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "create_transaction ACCOUNT_ID FROM TO AMOUNT DESCRIPTION IDEM", "Create transaction record"
+
+    def create_transaction(account_id, from_address, to_address, amount, description = nil, idem = nil)
+      output = []
+      response = @client.create_transaction(account_id, {
+          :from => [from_address],
+          :to => [{:amount => amount, :address => to_address}],
+          :description => description,
+          :idem => idem
+      })
+      output << response['message']
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "callbacks ACCOUNT_ID ADDRESS", "List callbacks from ACCOUNT_ID with address ADDRESS"
+
+    def callbacks(account_id)
+      output = []
+      response = @client.callbacks(account_id)
+      output << response['message']
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "create_callback ACCOUNT_ID ADDRESS", "Create callback for ACCOUNT_ID with address ADDRESS"
+
+    def create_callback(account_id, address)
+      output = []
+      response = @client.create_callback(account_id, address)
+      output << response['message']
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "trackers ACCOUNT_ID ADDRESS", "List transactions from ACCOUNT_ID with address ADDRESS"
+
+    def trackers(account_id)
+      output = []
+      response = @client.trackers(account_id)
+      output << response['message']
+      output = output.join("\n")
+      puts output
+    end
+
+    desc "create_tracker ACCOUNT_ID ADDRESS", "List transactions from ACCOUNT_ID with address ADDRESS"
+
+    def create_tracker(account_id, address)
+      output = []
+      response = @client.create_tracker(account_id, address)
+      output << response['message']
+      output = output.join("\n")
+      puts output
+    end
+  end
+end

data/lib/cryptoprocessing/client.rb

@@ -0,0 +1,108 @@
+require 'cryptoprocessing/authentication'
+require 'cryptoprocessing/configurable'
+require 'cryptoprocessing/connection'
+require 'cryptoprocessing/client/accounts'
+require 'cryptoprocessing/client/addresses'
+require 'cryptoprocessing/client/callbacks'
+require 'cryptoprocessing/client/trackers'
+require 'cryptoprocessing/client/transactions'
+require 'cryptoprocessing/client/coinbase_wallet'
+
+module Cryptoprocessing
+
+  # Cryptoprocessing API client masks default currency with BTC.
+  # But default currency can be simply overridden with blockchain_type property.
+  class Client
+    include Cryptoprocessing::Authentication
+    include Cryptoprocessing::Configurable
+    include Cryptoprocessing::Connection
+    include Cryptoprocessing::Client::Accounts
+    include Cryptoprocessing::Client::Callbacks
+    include Cryptoprocessing::Client::Addresses
+    include Cryptoprocessing::Client::Trackers
+    include Cryptoprocessing::Client::Transactions
+
+    include Cryptoprocessing::Client::CoinbaseWallet
+
+    attr_writer :logger
+
+    def initialize(options = {})
+      # Use options passed in, but fall back to module defaults
+      Cryptoprocessing::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || Cryptoprocessing.instance_variable_get(:"@#{key}"))
+      end
+
+      # login_from_netrc unless user_authenticated? || application_authenticated?
+    end
+
+    # Text representation of the client, masking tokens and passwords
+    #
+    # @return [String]
+    def inspect
+      inspected = super
+
+      # mask password
+      inspected = inspected.gsub! @password, "*******" if @password
+      # Only show last 4 of token, secret
+      if @access_token
+        inspected = inspected.gsub! @access_token, "#{'*'*36}#{@access_token[36..-1]}"
+      end
+
+      inspected
+    end
+
+    # @!attribute [rw] logger
+    # @return [Logger] The logger.
+    def self.logger
+      @logger ||= rails_logger || default_logger
+    end
+
+    # Create and configure a logger
+    # @return [Logger]
+    def self.default_logger
+      logger = Logger.new($stdout)
+      logger.level = Logger::WARN
+      logger
+    end
+
+    # Check to see if client is being used in a Rails environment and get the logger if present.
+    # Setting the ENV variable 'GOOGLE_API_USE_RAILS_LOGGER' to false will force the client
+    # to use its own logger.
+    #
+    # @return [Logger]
+    def self.rails_logger
+      if 'true' == ENV.fetch('CRYPTOPROCESSING_USE_RAILS_LOGGER', 'true') &&
+          defined?(::Rails) &&
+          ::Rails.respond_to?(:logger) &&
+          !::Rails.logger.nil?
+        ::Rails.logger
+      else
+        nil
+      end
+    end
+
+    # Set username for authentication
+    #
+    # @param value [String] Cryptoprocessing username
+    def email=(value)
+      reset_agent
+      @email = value
+    end
+
+    # Set password for authentication
+    #
+    # @param value [String] Cryptoprocessing password
+    def password=(value)
+      reset_agent
+      @password = value
+    end
+
+    # Set access token for authentication
+    #
+    # @param value [String] 40 character Cryptoprocessing access token
+    def access_token=(value)
+      reset_agent
+      @access_token = value
+    end
+  end
+end

data/lib/cryptoprocessing/client/accounts.rb

@@ -0,0 +1,43 @@
+require 'cryptoprocessing/models/account'
+
+module Cryptoprocessing
+  class Client
+
+    # Methods for the Commits API
+    #
+    # @see https://api.cryptoprocessing.io/#db40c5d3-078d-af2a-63e0-fd616f56e433
+    module Accounts
+
+      # Get account info
+      #
+      # @param [String] id
+      # @return [Array<Cryptoprocessing::Account>] A list of accounts
+      # @see https://api.cryptoprocessing.io/#4df50869-9044-21b6-bb27-a718f30e0040
+      def account(id, options = {})
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        out = nil
+        get("/v1/#{currency}/accounts/#{id}", options) do |resp|
+          out = Cryptoprocessing::Account.new(self, resp.data['data'])
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+
+      # Create account for given currency and with given name
+      #
+      # Создаем аккаунт
+      #
+      # @return [Cryptoprocessing::Account]
+      # @see https://api.cryptoprocessing.io/#7b3bacaf-aa8e-77ad-4d0d-f834b10ebc95
+      def create_account(options = {})
+        options[:currency] = blockchain_type unless options[:currency]
+        out = nil
+        post("/v1/accounts", options) do |resp|
+          out = Cryptoprocessing::Account.new(self, resp.data.merge(options))
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+    end
+  end
+end

data/lib/cryptoprocessing/client/addresses.rb

@@ -0,0 +1,56 @@
+require 'cryptoprocessing/models/address'
+
+module Cryptoprocessing
+  class Client
+
+    # Methods for addresses
+    #
+    # @return [Cryptoprocessing::Address]
+    # @see https://api.cryptoprocessing.io/#be1b38bb-7702-51c6-192f-91cf3a506ae8
+    module Addresses
+
+      # Get address info
+      #
+      # @param [String] account_id
+      # @param [String] address
+      # @return [Cryptoprocessing::Address]
+      # @see https://api.cryptoprocessing.io/#55759d22-b04b-1a63-ca8d-6b881b0212b2
+      def address(account_id, address, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        get("/v1/#{currency}/accounts/#{account_id}/addresses/#{address}", options) do |resp|
+          out = Cryptoprocessing::Address.new(self, resp.data)
+        end
+        out
+      end
+
+      # Get addresses list
+      #
+      # @param [String] account_id
+      # @return [Array<Cryptoprocessing::Address>] A list of addresses
+      # @see https://api.cryptoprocessing.io/#b826594e-db0d-4efe-04e9-c1286e6f8948
+      def addresses(account_id, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        get("/v1/#{currency}/accounts/#{account_id}/addresses", options) do |resp|
+          out = resp.data['addresses'].map { |item| Cryptoprocessing::Address.new(self, item) }
+        end
+        out
+      end
+
+      # Create address for account
+      #
+      # @param [String] account_id
+      # @return [Cryptoprocessing::Address]
+      # @see https://api.cryptoprocessing.io/#d6486a95-a5cb-4d4b-0369-0c7af040bc4d
+      def create_address(account_id, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        post("/v1/#{currency}/accounts/#{account_id}/addresses", options) do |resp|
+          out = Cryptoprocessing::Address.new(self, resp.data)
+        end
+        out
+      end
+    end
+  end
+end

data/lib/cryptoprocessing/client/api_errors.rb

@@ -0,0 +1,7 @@
+module Cryptoprocessing
+  class APIError < RuntimeError
+  end
+
+  class BadRequestError < APIError
+  end
+end

data/lib/cryptoprocessing/client/api_response.rb

@@ -0,0 +1,39 @@
+module Cryptoprocessing
+  class APIResponse
+    attr_reader :received_at
+    attr_accessor :client
+    attr_accessor :method
+    attr_accessor :params
+
+    def initialize(resp)
+      @received_at = Time.now
+      @response = resp
+    end
+
+    def raw
+      @response
+    end
+
+    def body
+      raise NotImplementedError
+    end
+
+    alias_method :data, :body
+
+    def body=(body)
+      raise NotImplementedError
+    end
+
+    def headers
+      raise NotImplementedError
+    end
+
+    def status
+      raise NotImplementedError
+    end
+
+    def has_more?
+      body.has_key?('pagination') && body['pagination']['next_uri'] != nil
+    end
+  end
+end