vault_of_satoshi 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1e875eb3e886544c86750cb12fb43185006a3d5
+  data.tar.gz: b5137743d6835cea4f328bc5db12438bc3ff818a
+SHA512:
+  metadata.gz: 80af280d1bfc293b2b7fc611078e6cb279293cf300a9b5071434ceb68b25865fc98154b4d913336c74080ef67b34d96a06bc0841b42d413ac3659fc3ae21fc84
+  data.tar.gz: 0d17e8956ef6cc1cc5414c49f36b2c2bbdca9eb575560b8dc8b6458b1fd84ba6d43f24d0f9fcfa31e945bcf94498e25a5a7b17fe93e89a7de1409fb661784665

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+api_key.txt
+api_secret.txt

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vault_of_satoshi.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Frank Bonetti
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+## Installation
+  
+  gem install 'vault_of_satoshi'
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/vault_of_satoshi.rb

@@ -0,0 +1,15 @@
+require 'httparty'
+require 'openssl'
+require 'base64'
+require 'uri'
+require 'date'
+require 'active_support/core_ext/hash'
+require 'ostruct'
+
+require 'vault_of_satoshi/version' unless defined?(VaultOfSatoshi::VERSION)
+require 'vault_of_satoshi/api/base'
+require 'vault_of_satoshi/api/client'
+require 'vault_of_satoshi/api/error'
+require 'vault_of_satoshi/api/info'
+require 'vault_of_satoshi/api/public'
+require 'vault_of_satoshi/api/trade'

data/lib/vault_of_satoshi/api/base.rb

@@ -0,0 +1,94 @@
+module VaultOfSatoshi
+  module API
+    class Base
+      include HTTParty
+      base_uri 'https://api.vaultofsatoshi.com'
+
+      CRYPTO_CURRENCIES = [:BTC, :LTC, :PPC, :DOGE, :FTC, :XPM, :QRK]
+      FIAT_CURRENCIES = [:CAD, :USD]
+      ALL_CURRENCIES = CRYPTO_CURRENCIES + FIAT_CURRENCIES
+
+      def initialize(api_key, api_secret)
+        @api_key = api_key
+        @api_secret = api_secret
+      end
+
+      def inspect
+        "#<#{self.class}:#{self.object_id}>"
+      end
+
+      private
+
+      def nonce
+        sprintf("%0.6f", Time.now.to_f).gsub('.', '')
+      end
+
+      def headers(endpoint, params)
+        {
+          "Api-Key"  => @api_key,
+          "Api-Sign" => generate_api_sign(endpoint, params)
+        }
+      end
+
+      def generate_api_sign(endpoint, params)
+        data = params.to_param
+        Base64.strict_encode64(OpenSSL::HMAC.hexdigest('sha512', @api_secret, endpoint + 0.chr + data))
+      end
+
+      def parse_data(data, options = {})
+        data = OpenStruct.new(data)
+
+        [*options[:unix_timestamps]].each do |unix_timestamp|
+          data[unix_timestamp] = parse_unix_timestamp(data[unix_timestamp])
+        end
+
+        [*options[:microsecond_timestamps]].each do |microsecond_timestamp|
+          data[microsecond_timestamp] = parse_microsecond_timestamp(data[microsecond_timestamp])
+        end
+
+        [*options[:currency_objects]].each do |currency_object|
+          data[currency_object] = parse_currency_object(data[currency_object])
+        end
+
+        [*options[:booleans]].each do |boolean|
+          data[boolean] = parse_boolean(data[boolean])
+        end
+
+        data
+      end
+
+      def parse_unix_timestamp(seconds_since_epoch)
+        DateTime.strptime(seconds_since_epoch.to_s, "%s")
+      end
+
+      def parse_microsecond_timestamp(micro_seconds_since_epoch)
+        seconds_since_epoch = BigDecimal.new(micro_seconds_since_epoch.to_s) / 1_000_000
+        DateTime.strptime(seconds_since_epoch.to_s("F"), "%s")
+      end
+
+      def parse_currency_object(object)
+        BigDecimal.new(object["value"]).round(object["precision"])
+      end
+
+      def parse_boolean(int)
+        int.to_i == 1
+      end
+
+      # Accepts a date_input in the form of a unix timestamp, Date object, or Time object
+      def date_input_to_microseconds(date_input)
+        DateTime.strptime(date_input.to_f.to_s, '%s').strftime("%s").to_i * 1_000_000
+      end
+
+      def generate_currency_object(number)
+        precision = 8
+        value = sprintf("%0.#{precision}f", number)
+        {
+          precision: precision,
+          value: value,
+          value_int: value.gsub('.', '').to_i
+        }
+      end
+
+    end
+  end
+end

data/lib/vault_of_satoshi/api/client.rb

@@ -0,0 +1,18 @@
+module VaultOfSatoshi
+  module API
+    class Client
+      attr_reader :public, :info, :trade
+
+      def initialize(api_key, api_secret)
+        @public = VaultOfSatoshi::API::Public.new
+        @info = VaultOfSatoshi::API::Info.new(api_key, api_secret)
+        @trade = VaultOfSatoshi::API::Trade.new(api_key, api_secret)
+      end
+
+      def inspect
+        "#<#{self.class}:#{self.object_id}>"
+      end
+
+    end
+  end
+end

data/lib/vault_of_satoshi/api/error.rb

@@ -0,0 +1,7 @@
+module VaultOfSatoshi
+  module API
+    class Error < StandardError
+
+    end
+  end
+end

data/lib/vault_of_satoshi/api/info.rb

@@ -0,0 +1,179 @@
+module VaultOfSatoshi
+  module API
+    class Info < Base
+
+      def initialize(api_key, api_secret)
+        super
+      end
+
+      def currency(params = {})
+        params.slice!(:currency)
+        params.merge!(nonce: nonce)
+        endpoint = "/info/currency"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        if params[:currency]
+          parse_data(response["data"], booleans: [:virtual, :tradeable])
+        else
+          response["data"].map do |element|
+            parse_data(element, booleans: [:virtual, :tradeable])
+          end
+        end
+      end
+
+      def account
+        params = {nonce: nonce}
+        endpoint = "/info/account"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        response["data"]["trade_fee"] = parse_data(response["data"]["trade_fee"], currency_objects: CRYPTO_CURRENCIES)
+        response["data"]["monthly_volume"] = parse_data(response["data"]["monthly_volume"], currency_objects: CRYPTO_CURRENCIES)
+
+        response["data"]["wallets"].each do |currency_code, wallet|
+          response["data"]["wallets"][currency_code] = parse_data(
+            wallet, currency_objects: [:balance, :daily_withdrawal_limit, :monthly_withdrawal_limit]
+          )
+        end
+        response["data"]["wallets"] = parse_data(response["data"]["wallets"])
+
+        parse_data(response["data"], unix_timestamps: [:created, :last_login])
+      end
+
+      def balance(params = {})
+        params.slice!(:currency)
+        params.merge!(nonce: nonce)
+        endpoint = "/info/balance"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        if params[:currency]
+          parse_currency_object(response["data"])
+        else
+          parse_data(response["data"], currency_objects: ALL_CURRENCIES)
+        end
+      end
+
+      def wallet_address(params = {})
+        params.slice!(:currency)
+        params.merge!(nonce: nonce)
+        endpoint = "/info/wallet_address"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_data(response["data"])
+      end
+
+      def wallet_history(params = {})
+        params.slice!(:currency, :count, :after)
+        params[:after] = date_input_to_microseconds(params[:after])
+        params.merge!(nonce: nonce)
+        endpoint = "/info/wallet_history"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_options = {
+          currency_objects: :units,
+          microsecond_timestamps: :transfer_date
+        }
+        response["data"].map do |element|
+          parse_data(element, parse_options)
+        end
+      end
+
+      def ticker(params = {})
+        params.slice!(:order_currency, :payment_currency)
+        params.merge!(nonce: nonce)
+        endpoint = "/info/ticker"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_options = {
+          unix_timestamps: :date,
+          currency_objects: [
+            :opening_price, :closing_price, :min_price, :max_price,
+            :average_price, :units_traded, :volume_1day, :volume_7day
+          ]
+        }
+        parse_data(response["data"], parse_options)
+      end
+
+      def quote(params = {})
+        params.slice!(:type, :order_currency, :units, :payment_currency, :price)
+        params[:units] = generate_currency_object(params[:units]) if params[:units]
+        params[:price] = generate_currency_object(params[:price]) if params[:price]
+        params.merge!(nonce: nonce)
+        endpoint = "/info/quote"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_options = {currency_objects: [:rate, :subtotal, :fee, :total]}
+        parse_data(response["data"], parse_options)
+      end
+
+      def orderbook(params = {})
+        params.slice!(:order_currency, :payment_currency, :group_orders, :round, :count)
+        params[:group_orders] = [1, "1", true, nil].include?(params[:group_orders]) ? 1 : 0
+        params.merge!(nonce: nonce)
+        endpoint = "/info/orderbook"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        response["data"]["bids"].map! do |bid_object|
+          parse_data(bid_object, currency_objects: [:price, :quantity])
+        end
+        response["data"]["asks"].map! do |ask_object|
+          parse_data(ask_object, currency_objects: [:price, :quantity])
+        end
+        parse_data(response["data"], microsecond_timestamps: :timestamp)
+      end
+
+      def orders(params = {})
+        params.slice!(:count, :after, :open_only)
+        params[:after] = date_input_to_microseconds(params[:after])
+        params.merge!(nonce: nonce)
+        endpoint = "/info/orders"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_options = {
+          microsecond_timestamps: [:order_date, :date_completed],
+          currency_objects: [:units, :units_remaining, :price, :fee, :total]
+        }
+
+        response["data"].map do |element|
+          parse_data(element, parse_options)
+        end
+      end
+
+      def order_detail(params = {})
+        params.slice!(:order_id)
+        params.merge!(nonce: nonce)
+        endpoint = "/info/order_detail"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_options = {
+          microsecond_timestamps: :transaction_date,
+          currency_objects: [:units_traded, :price, :fee, :total]
+        }
+
+        response["data"].map do |element|
+          parse_data(element, parse_options)
+        end
+      end
+
+    end
+  end
+end

data/lib/vault_of_satoshi/api/public.rb

@@ -0,0 +1,44 @@
+module VaultOfSatoshi
+  module API
+    class Public < Base
+
+      def initialize
+      end
+
+      def ticker(params = {})
+        params.slice!(:order_currency, :payment_currency)
+        endpoint = "/public/ticker"
+
+        response = self.class.get(endpoint, query: params).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_options = {
+          timestamps: :date,
+          currency_objects: [
+            :opening_price, :closing_price, :min_price, :max_price,
+            :average_price, :units_traded, :volume_1day, :volume_7day
+          ]
+        }
+        parse_data(response["data"], parse_options)
+      end
+
+      def orderbook(params = {})
+        params.slice!(:order_currency, :payment_currency, :group_orders, :round, :count)
+        params[:group_orders] = [1, "1", true, nil].include?(params[:group_orders]) ? 1 : 0
+        endpoint = "/public/orderbook"
+
+        response = self.class.get(endpoint, query: params).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        response["data"]["bids"].map! do |bid_object|
+          parse_data(bid_object, currency_objects: [:price, :quantity])
+        end
+        response["data"]["asks"].map! do |ask_object|
+          parse_data(ask_object, currency_objects: [:price, :quantity])
+        end
+        parse_data(response["data"], timestamps: :timestamp)
+      end
+
+    end
+  end
+end

data/lib/vault_of_satoshi/api/trade.rb

@@ -0,0 +1,35 @@
+module VaultOfSatoshi
+  module API
+    class Trade < Base
+
+      def initialize(api_key, api_secret)
+        super
+      end
+
+      def place(params = {})
+        params.slice!(:type, :order_currency, :units, :payment_currency, :price)
+        params[:units] = generate_currency_object(params[:units])
+        params[:price] = generate_currency_object(params[:price])
+        params.merge!(nonce: nonce)
+        endpoint = "/trade/place"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_data(response["data"])
+      end
+
+      def cancel(params = {})
+        params.slice!(:order_id)
+        params.merge!(nonce: nonce)
+        endpoint = "/trade/cancel"
+
+        response = self.class.post(endpoint, body: params.to_param, headers: headers(endpoint, params)).parsed_response
+        raise VaultOfSatoshi::API::Error.new(response["message"]) if response["status"] == "error"
+
+        parse_data(response["data"])
+      end
+
+    end
+  end
+end

data/lib/vault_of_satoshi/version.rb

@@ -0,0 +1,3 @@
+module VaultOfSatoshi
+  VERSION = "0.9.0"
+end

data/spec/api/info_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe VaultOfSatoshi::API::Info do
+
+  let(:api_client) { VaultOfSatoshi::API::Client.new(File.read("./api_key.txt"), File.read("./api_secret.txt")) }
+
+  describe "#currency" do
+    it "should return a list of currencies when no params are provided" do
+      data = api_client.info.currency
+      data.map(&:code).sort.should == VaultOfSatoshi::API::Base::ALL_CURRENCIES.map(&:to_s).sort
+      data.detect { |x| x.code == "BTC" }.virtual.should == true
+    end
+
+    it "should return one currency when the currency param is provided" do
+      data = api_client.info.currency(currency: "BTC")
+      data.code.should == "BTC"
+    end
+  end
+
+  describe "#account" do
+    it "should return the expected fields" do
+      data = api_client.info.account
+      data.to_h.keys.should include(:created, :account_id, :trade_fee, :monthly_volume, :wallets)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'vault_of_satoshi'

data/vault_of_satoshi.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vault_of_satoshi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vault_of_satoshi"
+  spec.version       = VaultOfSatoshi::VERSION
+  spec.author        = "Frank Bonetti"
+  spec.email         = "frank.r.bonetti@gmail.com"
+  spec.description   = "A Ruby wrapper for the Vault of Satoshi API"
+  spec.summary       = "A Ruby wrapper for the Vault of Satoshi API"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3.5"
+  spec.add_development_dependency "rake", "~> 1.3.5"
+  spec.add_development_dependency 'httparty', "~> 0.13.0"
+  spec.add_development_dependency 'active_support', "~> 3.0.0"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: vault_of_satoshi
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Frank Bonetti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: A Ruby wrapper for the Vault of Satoshi API
+email: frank.r.bonetti@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vault_of_satoshi.rb
+- lib/vault_of_satoshi/api/base.rb
+- lib/vault_of_satoshi/api/client.rb
+- lib/vault_of_satoshi/api/error.rb
+- lib/vault_of_satoshi/api/info.rb
+- lib/vault_of_satoshi/api/public.rb
+- lib/vault_of_satoshi/api/trade.rb
+- lib/vault_of_satoshi/version.rb
+- spec/api/info_spec.rb
+- spec/spec_helper.rb
+- vault_of_satoshi.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: A Ruby wrapper for the Vault of Satoshi API
+test_files:
+- spec/api/info_spec.rb
+- spec/spec_helper.rb