uphold 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fcbac48fdf6ca84355f80032f2405c44635195a0
+  data.tar.gz: bec84be91e397bee706526eb50fdc3282e45ba68
+SHA512:
+  metadata.gz: 2afa7286c1b900357966625ed1f273344d616f9374bba8b8909e4936ec7ece0527a3d129963ef2bc5a802290f272458075c1e870c231a1576f026d1617a0c3f5
+  data.tar.gz: 4451d2528a39b13e61ac18704afecd1e7ad8730efb3ed508fa62f7e0db246b9acfc2f35be19a6bf9c91cc9db9e37c56a2a7594d7092df3c6035d14f7590b1b6f

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.env
+tags
+.tags
+path
+.ruby-version

data/.rubocop.yml

@@ -0,0 +1,32 @@
+AllCops:
+  Include:
+    - '**/Rakefile'
+    - '**/config.ru'
+  Exclude:
+    - 'path/**/*'
+    - 'bin/**/*'
+    - 'vendor/**/*'
+
+Metrics/LineLength:
+  Enabled: false
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DotPosition:
+  EnforcedStyle: trailing
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+Style/RegexpLiteral:
+  MaxSlashes: 0

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.1.5
+  - 2.0.0
+  - ruby-head
+  - jruby-1.6.8
+  - rbx-2.2.10
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-1.6.8
+    - rvm: rbx-2.2.10

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'pry'
+
+group :test do
+  gem 'codeclimate-test-reporter', require: false
+  gem 'vcr'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Group Buddies
+
+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,335 @@
+# Uphold
+
+[![Gem Version](https://badge.fury.io/rb/uphold-ruby.svg)](http://badge.fury.io/rb/uphold)
+[![Build Status](https://travis-ci.org/subvisual/uphold-ruby.svg?branch=master)](https://travis-ci.org/subvisual/uphold-ruby)
+[![Code Climate](https://codeclimate.com/github/subvisual/uphold-ruby/badges/gpa.svg)](https://codeclimate.com/github/subvisual/uphold-ruby)
+[![Test Coverage](https://codeclimate.com/github/subvisual/uphold-ruby/badges/coverage.svg)](https://codeclimate.com/github/subvisual/uphold-ruby)
+
+A ruby client for the [Uphold](https://uphold.com/) API.
+
+# Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'uphold'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install uphold
+
+# Contents
+
+* [Usage](#usage)
+* [Options](#options)
+* [Creating an authenticated client](#creating-an-authenticated-client)
+  * [Personal Access Token](#personal-access-token)
+    * [Via argument](#via-argument)
+    * [Via environment variable](#via-environment-variable)
+* [Endpoints](#endpoints)
+  * [Authentication](#authentication)
+    * [OAuth2](#oauth2)
+    * [Basic Authentication](#basic-authentication)
+  * [Tickers](#tickers)
+  * [Entities](#entities)
+  * [Cards](#cards)
+  * [Transactions](#transactions)
+    * [Public Transactions](#public-transactions)
+    * [Private Transactions](#private-transactions)
+  * [Contacts](#contacts)
+  * [Users](#users)
+  * [Transparency](#transparency)
+  * [Pagination](#pagination)
+* [Contributing](#contributing)
+
+# Usage
+
+To use the gem, you have to instantiate a client. All API calls are made from there. Here's a minimal working example:
+
+```ruby
+require 'uphold'
+
+client = Uphold::Client.new
+puts client.all_tickers
+```
+
+## Sandbox mode
+
+Uphold has a sandbox version for testing purposes:
+
+* Sandbox site: https://sandbox.uphold.com
+* Sandbox API: https://api-sandbox.uphold.com
+
+You can set `Uphold.sandbox = true` to enable sandboxing mode to set the global base URL to point to the sandbox API instead of the production one.
+
+# Options
+
+This is a summary of the supported options when instantiating a new client, and their default values:
+
+```ruby
+Uphold::Client.new(
+  # bearer_token for OAuth authentication
+  token: ENV['UPHOLD_AUTH_TOKEN']
+)
+```
+
+# Creating an authenticated client
+
+In order to make most of the API calls, you will need to authenticate your
+client. Here's how you can do that.
+
+## Personal Access Token
+
+If you don't have a PAT, learn how to generate one
+[here](#basic-authentication).
+
+If you already have a token, you can use it by setting an environment variable,
+or by passing it when instantiating the client.
+
+### Via argument
+
+Pass the token to the constructor:
+
+```ruby
+Uphold::Client.new(token: 'your-access-token')
+```
+
+### Via environment variable
+
+Set the environment variable using [dotenv](https://github.com/bkeepers/dotenv), or by exporting it in your shell:
+
+```bash
+$ export UPHOLD_AUTH_TOKEN="your-access-token"
+```
+
+Then instantiate the client:
+
+```ruby
+Uphold::Client.new
+```
+
+# Endpoints
+
+This is a comprehensive list of all the mappings between this wrapper and the
+Uphold's API.
+
+## Authentication
+
+[*Uphold documentation on authentication*](https://developer.uphold.com/api/v0/#authentication)
+
+### OAuth2
+
+**NOT SUPPORTED BY UPHOLD YET**
+
+### Basic Authentication
+
+[*Bireserve documentation on basic authentication*](https://developer.uphold.com/api/v0/#basic-authentication)
+
+The only thing you need, in order to use basic authentication is a Personal
+Access Token, everything else is transparent to you. If you already have a
+token, see how to use it [here](#personal-access-token).
+
+```ruby
+client.generate_access_token(username: 'your-uphold-username', password:
+'your-uphold-password', otp: 'a-valid-uphold-otp')
+```
+
+To generate a valid OTP you can install [Authy](https://www.authy.com/), follow
+it's set up process and choose uphold. You should be prompted with a set of
+numbers, which is your OTP (it only lasts 30 seconds, so you have to be quick).
+
+## Tickers
+
+[*Uphold documentation on tickers*](https://developer.uphold.com/api/v0/#tickers)
+
+**Return the current rates on Uphold for all currency pairs:**
+
+```ruby
+client.all_tickers
+```
+
+**Return the current rates on Uphold for a specific currency:**
+
+```ruby
+client.find_ticker(currency: 'EUR')
+```
+
+## Cards
+
+[*Uphold documentation on cards*](https://developer.uphold.com/api/v0/#cards)
+
+**Return all the user's cards:**
+
+```ruby
+client.all_cards
+```
+
+**Return the details for a specific card associated with the user:**
+
+```ruby
+client.find_card(id: '37e002a7-8508-4268-a18c-7335a6ddf24b')
+```
+
+**Create a card for the user:**
+
+```ruby
+client.create_card(label: 'My label', currency: 'BTC')
+```
+
+## Transactions
+
+[*Uphold documentation on transactions*](https://developer.uphold.com/api/v0/#transactions)
+
+You can interact with both the authenticated user's and public transactions.
+
+### Public Transactions
+
+**Return the public view of all transactions in the reserve (supports
+[Pagination](#pagination)):**
+
+```ruby
+client.all_public_transactions
+```
+
+**Return the public view of a specific transaction (supports
+[Pagination](#pagination)):**
+
+```ruby
+client.find_public_transactions(id: 'a97bb994-6e24-4a89-b653-e0a6d0bcf634')
+```
+
+### Private Transactions
+
+**Create a transaction:**
+
+```ruby
+client.create_transaction(card_id: 'a6d35fcd-xxxx-9c9d1dda6d57', currency:
+'BTC', amount: 0.1, destination: 'foo@bar.com')
+```
+
+**Commit a transaction:**
+
+```ruby
+client.commit_transaction(card_id: 'a6d35fcd-xxxx-9c9d1dda6d57', transaction_id:
+'d51b4e4e-9827-40fb-8763-e0ea2880085b')
+```
+
+**Cancel a transaction:**
+
+```ruby
+client.cancel_transaction(card_id: 'a6d35fcd-xxxx-9c9d1dda6d57', transaction_id:
+'d51b4e4e-9827-40fb-8763-e0ea2880085b')
+```
+
+**Resend a transaction:**
+
+```ruby
+client.resend_transaction(card_id: 'a6d35fcd-xxxx-9c9d1dda6d57', transaction_id:
+'d51b4e4e-9827-40fb-8763-e0ea2880085b')
+```
+
+**Return all transactions associated with the user (supports
+[Pagination](#pagination)):**
+
+```ruby
+client.all_user_transactions
+```
+
+**Return all transactions associated with a card:**
+
+```ruby
+client.all_card_transactions
+```
+
+## Contacts
+
+[*Uphold documentation on contacts*](https://developer.uphold.com/api/v0/#contacts)
+
+**Return all the user's contacts:**
+
+```ruby
+client.all_contacts
+```
+
+**Return the details for a specific contact associated with the user:**
+
+```ruby
+client.find_contact(id: '9fae84eb-712d-4b6a-9b2c-764bdde4c079')
+```
+
+**Create a contact for the user:**
+
+```ruby
+client.create_contact(first_name: 'Luke', last_name: 'Skywalker', company: 'Lars
+Moisture Farm Inc', emails: ['support@larsmoisturefarm.com')
+```
+
+## Users
+
+[*Uphold documentation on users*](https://developer.uphold.com/api/v0/#users)
+
+**Return the details of the user:**
+
+```ruby
+client.me
+```
+
+**Return the list of phone numbers associated with the user:**
+
+```ruby
+client.phones
+```
+
+## Transparency
+
+[*Uphold documentation on the reserve status*](https://developer.uphold.com/api/v0/#reserve-status)
+
+**Return a summary of all obligations and assets:**
+
+```ruby
+client.statistics
+```
+
+[*Uphold documentation on the reserve ledger*](https://developer.uphold.com/api/v0/#the-reserveledger)
+
+**Return a detailed record of all obligations and assets flowing into the
+network:**
+
+```ruby
+client.ledger
+```
+
+## Pagination
+
+[*Uphold documentation on pagination*](https://developer.uphold.com/api/v0/#pagination)
+
+All endpoints that support pagination take a `range` attribute, in which you can
+specify the first and last indexes for the items you wish to retrieve.
+
+The response will look exactly like an `Array`, but with a method called
+`total_items`, that returns the total number of items of that type that
+Uphold knows of.
+
+```ruby
+client = Uphold::Client.new token: 'XXX'
+client.all_public_transactions.size # 5
+client.all_public_transactions.total_size # 21110
+client.all_public_transactions(range: (5..20)).size # 16
+```
+
+# Contributing
+
+1. Fork it ( https://github.com/subvisual/uphold-ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+# Copyright
+
+Copyright (c) 2015 Group Buddies. See [LICENSE.txt](LICENSE.txt) for further details.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
+require 'rspec/core/rake_task'
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+task :console do
+  require 'pry'
+  require 'uphold'
+  ARGV.clear
+  Pry.start
+end
+
+task default: [:rubocop, :spec]

data/lib/uphold/api/auth_token.rb

@@ -0,0 +1,17 @@
+require 'base64'
+
+module Uphold
+  module API
+    module AuthToken
+      def generate_access_token(username: '', password: '', otp: '')
+        request_data = Uphold::RequestData.new(
+          Endpoints::AUTH,
+          Entities::AuthToken,
+          { 'X-Uphold-OTP' => otp, 'Authorization' => 'Basic ' + Base64.encode64("#{username}:#{password}") },
+          description: 'Uphold ruby'
+        )
+        Request.perform_with_object(:post, request_data)
+      end
+    end
+  end
+end

data/lib/uphold/api/card.rb

@@ -0,0 +1,36 @@
+module Uphold
+  module API
+    module Card
+      def all_cards
+        Request.perform_with_objects(:get, cards_request_data)
+      end
+
+      def find_card(id: nil)
+        Request.perform_with_object(:get, card_request_data(id))
+      end
+
+      def create_card(label: nil, currency: nil)
+        Request.perform_with_object(:post, cards_request_data(label: label, currency: currency))
+      end
+
+      private
+
+      def cards_request_data(payload = nil)
+        RequestData.new(
+          Endpoints::CARD,
+          Entities::Card,
+          authorization_header,
+          payload
+        )
+      end
+
+      def card_request_data(id)
+        RequestData.new(
+          Endpoints::CARD + "/#{id}",
+          Entities::Card,
+          authorization_header
+        )
+      end
+    end
+  end
+end

data/lib/uphold/api/contact.rb

@@ -0,0 +1,34 @@
+module Uphold
+  module API
+    module Contact
+      def all_contacts
+        request_data = RequestData.new(
+          Endpoints::USER_CONTACTS,
+          Entities::Contact,
+          authorization_header
+        )
+        Request.perform_with_objects(:get, request_data)
+      end
+
+      def find_contact(id: nil)
+        request_data = RequestData.new(
+          Endpoints::USER_CONTACTS + "/#{id}",
+          Entities::Contact,
+          authorization_header
+        )
+        Request.perform_with_object(:get, request_data)
+      end
+
+      def create_contact(**args)
+        request_data = RequestData.new(
+          Endpoints::USER_CONTACTS,
+          Entities::Contact,
+          authorization_header,
+          Uphold::Helpers.camelized_hash(args)
+        )
+
+        Request.perform_with_object(:post, request_data)
+      end
+    end
+  end
+end

data/lib/uphold/api/endpoints.rb

@@ -0,0 +1,26 @@
+module Uphold
+  module Endpoints
+    AUTH = '/me/tokens'
+    CARD = '/me/cards'
+    CARD_PRIVATE_TRANSACTIONS = CARD + '/:card/transactions'
+    COMMIT_TRANSACTION = CARD_PRIVATE_TRANSACTIONS + '/:id/commit'
+    CANCEL_TRANSACTION = CARD_PRIVATE_TRANSACTIONS + '/:id/cancel'
+    RESEND_TRANSACTION = CARD_PRIVATE_TRANSACTIONS + '/:id/resend'
+    USER_PRIVATE_TRANSACTIONS = '/me/transactions'
+    PUBLIC_TRANSACTIONS = '/reserve/transactions'
+    LEDGER = '/reserve/ledger'
+    STATS = '/reserve/statistics'
+    TICKER = '/ticker'
+    USER = '/me'
+    USER_CONTACTS = '/me/contacts'
+    USER_PHONES = '/me/phones'
+
+    def self.with_placeholders(endpoint, substitutions = {})
+      new_endpoint = endpoint.dup
+      substitutions.each_pair do |placeholder, substitute|
+        new_endpoint.gsub!(placeholder, substitute)
+      end
+      new_endpoint
+    end
+  end
+end

data/lib/uphold/api/private_transaction.rb

@@ -0,0 +1,58 @@
+module Uphold
+  module API
+    module PrivateTransaction
+      def create_transaction(card_id: nil, currency: nil, amount: 0, destination: nil)
+        request_data = RequestData.new(
+          Endpoints.with_placeholders(Endpoints::CARD_PRIVATE_TRANSACTIONS, ':card' => card_id),
+          Entities::Transaction,
+          authorization_header,
+          card_id: card_id, denomination: { currency: currency, amount: amount }, destination: destination
+        )
+        Request.perform_with_object(:post, request_data)
+      end
+
+      def commit_transaction(card_id: nil, transaction_id: nil)
+        request_data = transaction_request_data(Endpoints::COMMIT_TRANSACTION, card_id, transaction_id)
+        Request.perform_with_object(:post, request_data)
+      end
+
+      def cancel_transaction(card_id: nil, transaction_id: nil)
+        request_data = transaction_request_data(Endpoints::CANCEL_TRANSACTION, card_id, transaction_id)
+        Request.perform_with_object(:post, request_data)
+      end
+
+      def resend_transaction(card_id: nil, transaction_id: nil)
+        request_data = transaction_request_data(Endpoints::RESEND_TRANSACTION, card_id, transaction_id)
+        Request.perform_with_object(:post, request_data)
+      end
+
+      def all_user_transactions(range: (0..4))
+        request_data = RequestData.new(
+          Endpoints::USER_PRIVATE_TRANSACTIONS,
+          Entities::Transaction,
+          authorization_header.merge(pagination_header_for_range(range))
+        )
+        Request.perform_with_objects(:get, request_data)
+      end
+
+      def all_card_transactions(card_id: nil, range: (0..4))
+        request_data = RequestData.new(
+          Endpoints.with_placeholders(Endpoints::CARD_PRIVATE_TRANSACTIONS, ':card' => card_id),
+          Entities::Transaction,
+          authorization_header.merge(pagination_header_for_range(range))
+        )
+        Request.perform_with_objects(:get, request_data)
+      end
+
+      private
+
+      def transaction_request_data(endpoint, card_id, transaction_id)
+        RequestData.new(
+          Endpoints.with_placeholders(endpoint, ':card' => card_id, ':id' => transaction_id),
+          Entities::Transaction,
+          authorization_header
+        )
+      end
+    end
+  end
+end

data/lib/uphold/api/public_transaction.rb

@@ -0,0 +1,23 @@
+module Uphold
+  module API
+    module PublicTransaction
+      def all_public_transactions(range: (0..4))
+        request_data = RequestData.new(
+          Endpoints::PUBLIC_TRANSACTIONS,
+          Entities::Transaction,
+          authorization_header.merge(pagination_header_for_range(range))
+        )
+        Request.perform_with_objects(:get, request_data)
+      end
+
+      def find_public_transaction(id: '')
+        request_data = RequestData.new(
+          Endpoints::PUBLIC_TRANSACTIONS + "/#{id}",
+          Entities::Transaction,
+          authorization_header
+        )
+        Request.perform_with_object(:get, request_data)
+      end
+    end
+  end
+end

data/lib/uphold/api/ticker.rb

@@ -0,0 +1,23 @@
+module Uphold
+  module API
+    module Ticker
+      def all_tickers
+        request_data = RequestData.new(
+          Endpoints::TICKER,
+          Entities::Ticker,
+          authorization_header
+        )
+        Request.perform_with_objects(:get, request_data)
+      end
+
+      def find_ticker(currency: nil)
+        request_data = RequestData.new(
+          Endpoints::TICKER + "/#{currency}",
+          Entities::Ticker,
+          authorization_header
+        )
+        Request.perform_with_objects(:get, request_data)
+      end
+    end
+  end
+end

data/lib/uphold/api/transparency.rb

@@ -0,0 +1,15 @@
+module Uphold
+  module API
+    module Transparency
+      def statistics
+        request_data = RequestData.new(Endpoints::STATS, Entities::Asset, authorization_header)
+        Request.perform_with_objects(:get, request_data)
+      end
+
+      def ledger
+        request_data = RequestData.new(Endpoints::LEDGER, Entities::LedgerEntry, authorization_header)
+        Request.perform_with_objects(:get, request_data)
+      end
+    end
+  end
+end