round 0.0.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd856ad0da3b256d27fc46333562be670c50619e
-  data.tar.gz: 946f4ad0661ccba1e2fe45c32625b1544b20190d
+  metadata.gz: e377e33cf32986ee469ccf7c60f396e05f436f9a
+  data.tar.gz: ffedd033550ba8633ebaf2ba67a6859006c78364
 SHA512:
-  metadata.gz: d54ea2fb15da19481702b18342e68d28c7c515fbc07e22813c46bb633895fbd5dcdf1456888932ecb01c03624107332db446a78672bd98e384ca5dbfe0796019
-  data.tar.gz: 2ad7ea5aae5d3dc675d3d2138ad5261aac2ee9af0815cd0926d6830cd0b0d5910a27cd4d2f4bb10de37a357a18b4144bd8bed25d15db1c75ae3a4e8ec7b1277f
+  metadata.gz: 26c9bed0c4c8dee92c7318b0a601a90c758db4679944f835bcf6b55fc5a54d91734c539533f763db64107a7145a3f8b6016a078954b064c88a5dce35a3e4cbaa
+  data.tar.gz: e4c83b2d6eef471e8176d4b8a710a05a539a08dfff2bdc4fa18771a6bbf8e834b76971da5abd990eebf9d6edee3bc89d64bfbe74853bd2377eaf1202842e3810

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 BitVault, Inc.
+
+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,178 @@
+# round-rb: A Ruby client for the Gem API
+The round client is designed to interact with Gem's API to make building blockchain apps drop dead simple.  All the complexity of the bitcoin protocol and crypto has been abstracted away so you can focus on building your product.  Here are a few of the many great things the API and clients provide:
+
+* Multi-signature wallets with Gem as a cosigner
+* Webhook notifications automatically subscribed for you
+* Integrated 2FA solution with arbitrary endpoints to build into your app
+* Simplified balance inqueries
+* Easy address management
+* Hardware Security Modules for co-signing key
+* Rules engine for transactions
+* SDKs for many popular languages
+
+## Support information
+* __Support email__: [support@gem.co](mailto:support@gem.co)
+* __Support IRC chat__: `#gemhq` on `irc.freenode.net`
+* __Issues__:  Use github issues
+* __Slack room__:  Send email to support requesting access to the slack room for this client
+* __Detailed API Docs__:  http://guide.gem.co
+
+## Installing round-rb:
+### Prerequisites:
+* Ruby 2.1.5
+
+#### [Linux (debian-based, tested on Ubuntu 14.04)](docs/install.md#linux-debian-based-tested-on-ubuntu-1404)
+#### [Mac OSX](docs/install.md#mac-osx)
+#### [Heroku](docs/install.md#heroku)
+
+## Getting Started Tutorial
+#### Table of Contents
+* [Introduction](README.md#Introduction)
+* [1. Run the client](README.md#1-run-the-client)
+* [2. Configure your application and API token](README.md#2-configure-your-applicaiton-and-api-token)
+* [3. Create your User and Wallet](README.md#3-create-your-user-and-wallet)
+* [4. Authenticate your User](README.md#4-authenticate-your-user)
+* [5. Access the wallet and Default Account](README.md#5-access-the-wallet-and-default-account)
+* [6. Generate an Address and Add Funds](README.md#6-generate-an-address-and-add-funds)
+* [7. Make a Payment](README.md#7-make-a-payment)
+* [Advanced Topics](docs/advanced.md)
+	* [More about Wallets and Accounts](docs/advanced.md#wallets-and-accounts)
+	* [More about Transactions](docs/advanced.md#transactions-and-payments)
+	* [Subscriptions](docs/advanced.md#subscriptions)
+	* [Integrated 2FA](docs/advanced.md#integrated-2fa)
+	* [Operational/Custodail wallet models](docs/advanced.md#operationalcustodial-wallets)
+	* [Operational/Custodial payments](docs/advanced.md#payments)
+
+### Introduction
+This tutorial will have you run through setting up your application and creating your own wallet as a user of your application.  By the end of the tutorial, you will have created your User, wallet, account, an address as well as fund it and then make a payment using the bitcoin testnet network.
+
+This tutorial assumes that you have completed the developer signup and that you have successfully [installed the client](docs/install.md)
+
+### 1. Run the Client
+In this step you will learn how to instantiate the API client for the given networks.
+
+1. start your favorite interactive shell and import the round library
+
+	```bash
+	$ irb
+	> require 'round'
+	```
+
+1. Create the client object using the sandbox stack
+
+	```ruby
+	# the default client is set to sandbox the testnet stack
+	client = Round.client
+
+	# if you want to configure the client for production mainnet
+  client = Round.client(:mainnet)
+	```
+
+[[top]](README.md#getting-started-tutorial)
+
+### 2. Configure your applicaiton and API Token
+In this step your application and you will retrieve the API Token for the application and set your applications redirect url.  The url is used to push the user back to your app after they complete an out of band challenge.
+
+1. Set the redirect url by clicking in the options gear and selecting `add redirect url`
+
+1. In the [console](https://sandbox.gem.co) copy your `api_token` by clicking on show
+
+1. Go back to your shell session and set a variable for `api_token`
+
+	```ruby
+	api_token = 'q234t09ergoasgr-9_qt4098qjergjia-asdf2490'
+
+	```
+
+[[top]](README.md#getting-started-tutorial)
+
+### 3. Create your User and Wallet
+In this step you will create your own personal Gem user and wallet authorized on your application.  This is an end-user account, which will have a 2-of-3 multisig bitcoin wallet.
+
+1. Create your user and wallet:
+
+	```ruby
+	#  Store the device token for future authentication
+	device_token = client.users.create(
+                      first_name: 'YOUR FIRST NAME',
+                      last_name: 'YOUR LAST NAME',
+                      email: 'YOUR EMAIL ADDRESS',
+                      passphrase: 'aReallyStrongPassphrase',
+                      device_name: 'SOME DEVICE NAME',
+                      redirect_uri: 'http://something/user-device-approved')
+                    )
+	```
+
+2. Your application should **store the device_token permanently** as this will be required to authenticate from your app as this user.
+3. You (acting as a user) will receive an email from Gem asking you to confirm your account and finish setup.  Please follow the instructions. At the end of the User sign up flow, you'll be redirected to the redirect_uri provided in users.create (if you provided one).
+
+[[top]](README.md#getting-started-tutorial)
+
+### 4. Authenticate your User
+In this step you will learn how to authenticate to the Gem API on a User's device to get a fully functional User object with which to perform wallet actions.
+
+1. Call the authenticate_device method from the client object
+
+	```ruby
+	full_user = client.authenticate_device(
+                api_token: api_token,
+                device_token: device_token,
+                email: email
+              )
+	```
+
+[[top]](README.md#getting-started-tutorial)
+
+### 5. Access the wallet and Default Account
+[Wallets and Accounts](docs/advanced.md#wallets-and-accounts)
+
+1. Get the wallet and then default account
+
+	```ruby
+	my_account = full_user.wallet.accounts['default']
+	```
+
+[[top]](README.md#getting-started-tutorial)
+
+### 6. Generate an Address and Add Funds
+In this section you'll learn how to create an address to fund with testnet coins aka funny money.
+
+1. Create an address
+
+	```ruby
+	address = my_account.addresses.create
+	puts address.string
+  puts address.path
+	```
+1. Copy the address string and go to a faucet to fund it:
+	1. [TP's TestNet Faucet](https://tpfaucet.appspot.com/)
+	1. [Mojocoin Testnet3 Faucet](http://faucet.xeno-genesis.com/)
+
+Payments have to be confirmed by the network and on Testnet that can be slow.  To monitor for confirmations: input the address into the following url `https://live.blockcypher.com/btc-testnet/address/<YOUR ADDRESS>`.  The current standard number of confirmations for a transaction to be considered safe is 6.
+
+You will be able to make a payment on a single confirmation.  While you wait for that to happen, feel free to read more details about:
+[Wallets and Accounts](docs/advanced.md#wallets-and-accounts)
+
+[[top]](README.md#getting-started-tutorial)
+
+### 7. Make a Payment
+In this section you’ll learn how to create a payment a multi-signature payment in an HD wallet.  Once your address gets one more more confirmations we’ll be able to send a payment out of the wallet.  To make a payment, you'll unlock a wallet, generate a list of payees and then call the pay method.
+
+1. Unlock the wallet:
+
+	```ruby
+	wallet.unlock(<YOUR PASSWORD>)
+	```
+1. Make a payment
+
+	```ruby
+	transaction = account.pay([{address: 'mxzdT4ShBudVtZbMqPMh9NVM3CS56Fp11s', amount: 25000}], 1, 'http://some-redirect-uri.com/)
+  puts transaction.mfa_uri # redirect your user to this URI to complete payment!
+	```
+
+The pay call takes a list of payee objects.  A payee is a hash of `{address: ADDRESS, amount: amount}` where address is the bitcoin address and amount is the number of satoshis.  `utxo_confirmations` default to 6 and represents the number of confirmations an unspent output needs to have in order to be selected for the transaction.  
+The last argument is the redirect uri for Gem to send the user back to your application after the user submits their MFA challenge.
+
+**CONGRATS** - now build something cool.
+
+[[top]](README.md#getting-started-tutorial)

data/lib/round/account.rb

@@ -0,0 +1,66 @@
+module Round
+  class Account < Round::Base
+    association :addresses, 'Round::AddressCollection'
+    association :subscriptions, 'Round::SubscriptionCollection'
+
+    attr_accessor :wallet
+
+    def initialize(options = {})
+      raise ArgumentError, 'Account must be associated with a wallet' unless options[:wallet]
+      super(options)
+      @wallet = options[:wallet]
+    end
+
+    def transactions(**query)
+      query[:status] = query[:status].join(',') if query[:status]
+      Round::TransactionCollection.new(
+        resource: @resource.transactions(query),
+        client: @client
+      )
+    end
+
+    def pay(payees, confirmations, redirect_uri = nil, mfa_token: nil)
+      raise ArgumentError, 'Payees must be specified' unless payees
+      raise 'You must unlock the wallet before attempting a transaction' unless @wallet.multiwallet
+
+      payment = self.transactions.create(payees, confirmations, redirect_uri: redirect_uri)
+      signed = payment.sign(@wallet.multiwallet)
+      if wallet.application
+        mfa_token = mfa_token || @wallet.application.get_mfa
+        signed.approve(mfa_token)
+        signed.refresh
+      end
+      signed
+    end
+
+    def self.hash_identifier
+      "name"
+    end
+
+  end
+
+  class AccountCollection < Round::Collection
+
+    def initialize(options = {})
+      raise ArgumentError, 'AccountCollection must be associated with a wallet' unless options[:wallet]
+      @wallet = options[:wallet]
+      super(options) { |account| account.wallet = @wallet }
+    end
+
+    def content_type
+      Round::Account
+    end
+
+    def create(name)
+      resource = @resource.create(name: name)
+      account = Round::Account.new(resource: resource, wallet: @wallet, client: @client)
+      add(account)
+      account
+    end
+
+    def refresh
+      super(wallet: @wallet)
+    end
+
+  end
+end

data/lib/round/address.rb

@@ -0,0 +1,21 @@
+module Round
+  class Address < Round::Base
+    def self.hash_identifier
+      "string"
+    end 
+  end
+
+  class AddressCollection < Round::Collection
+
+    def content_type
+      Round::Address
+    end
+
+    def create
+      resource = @resource.create
+      address = Round::Address.new(resource: resource, client: @client)
+      self.add(address)
+      address
+    end
+  end
+end

data/lib/round/application.rb

@@ -0,0 +1,68 @@
+module Round
+  API_TOKEN = 'api_token'
+  TOTP_SECRET = 'totp_secret'
+  SUBSCRIPTION_TOKEN = 'subscription_token'
+
+  class Application < Round::Base
+    association :users, 'Round::UserCollection'
+    association :wallets, 'Round::WalletCollection'
+
+    def authorize_instance(name)
+      @resource.authorize_instance(name: name)
+    end
+
+    def wallets
+      Round::WalletCollection.new(
+        resource: @resource.wallets,
+        client: @client,
+        application: self
+      )
+    end
+
+    def user_from_key(key)
+      users.detect { |u| u.key == key }
+    end
+
+    def self.hash_identifier
+      'name'
+    end
+
+    def totp=(totp_secret)
+      @totp = ROTP::TOTP.new(totp_secret)
+    end
+
+    def get_mfa
+      @totp.now
+    end
+
+    def with_mfa!(token)
+      context.mfa_token = token
+      self
+    end
+
+    def reset(*resets)
+      @resource.reset(resets)
+      self
+    end
+  end
+
+  class ApplicationCollection < Round::Collection
+
+    def content_type
+      Round::Application
+    end
+
+    def create(name, callback_url = nil)
+      params = { name: name }
+      params.merge!(callback_url: callback_url) if callback_url
+      app_resource = @resource.create(params)
+      app = Round::Application.new(
+        resource: app_resource,
+        client: @client
+      )
+      add(app)
+      app
+    end
+
+  end
+end

data/lib/round/base.rb

@@ -0,0 +1,38 @@
+module Round
+  class Base
+    attr_reader :resource
+
+    def initialize(resource:, client:, **kwargs)
+      @resource = resource
+      @client = client
+    end
+
+    def refresh
+      @resource = @resource.get
+      self
+    end
+
+    def method_missing(meth, *args, &block)
+      @resource.send(meth, *args, &block)
+    rescue => e
+      @resource.attributes.fetch(meth) do
+        raise e
+      end
+    end
+
+    def hash_identifier
+      send :[], self.class.hash_identifier
+    end
+
+    def self.hash_identifier
+      "key"
+    end
+
+    def self.association(name, klass)
+      define_method(name) do
+        Kernel.const_get(klass).new(resource: @resource.send(name), client: @client)
+      end
+    end
+
+  end
+end

data/lib/round/client.rb

@@ -0,0 +1,146 @@
+require 'patchboard'
+require 'base64'
+require 'date'
+
+module Round
+
+  MAINNET_URL = 'https://api.gem.co'
+  SANDBOX_URL = 'https://api-sandbox.gem.co'
+
+  NETWORKS = {
+    testnet: :bitcoin_testnet,
+    bitcoin_testnet: :bitcoin_testnet,
+    testnet3: :bitcoin_testnet,
+    bitcoin: :bitcoin,
+    mainnet: :bitcoin,
+  }
+
+  def self.client(network = :bitcoin_testnet, url = nil)
+    network = NETWORKS.fetch(network, :bitcoin_testnet)
+    url ||= network == :bitcoin_testnet ? SANDBOX_URL : MAINNET_URL
+
+    @patchboard ||= ::Patchboard.discover(url) { Client::Context.new }
+    Client.new(@patchboard.spawn, network)
+  end
+
+  class Client
+    include Round::Helpers
+
+    attr_reader :network
+
+    def initialize(patchboard_client, network)
+      @patchboard_client = patchboard_client
+      @network = network
+    end
+
+    def authenticate_application(api_token:, admin_token:)
+      @patchboard_client
+        .context
+        .authorize(Context::Scheme::APPLICATION, 
+          api_token: api_token, admin_token: admin_token)
+      authenticate_identify(api_token: api_token)
+
+      self.application.refresh
+    end
+
+    def context
+      @patchboard_client.context
+    end
+
+    def authenticate_identify(api_token:)
+      @patchboard_client
+        .context
+        .authorize(Context::Scheme::IDENTIFY, api_token: api_token)
+    end
+
+    def authenticate_device(email:, api_token:, device_token:)
+      @patchboard_client
+        .context
+        .authorize(Context::Scheme::DEVICE, 
+          api_token: api_token, device_token: device_token)
+      @patchboard_client
+        .context
+        .authorize(Context::Scheme::IDENTIFY, 
+          api_token: api_token)
+      self.user(email).refresh
+    end
+
+    def resources
+      @patchboard_client.resources
+    end
+
+    def users
+      UserCollection.new(resource: resources.users, client: self)
+    end
+
+    def application
+      Application.new(resource: resources.app.get, client: self)
+    end
+
+    def user(email)
+      User.new(resource: resources.user_query(email: email), client: self)
+    end
+
+    class Context
+      module Scheme
+        DEVICE = 'Gem-Device'
+        APPLICATION = 'Gem-Application'
+        IDENTIFY = 'Gem-Identify'
+      end
+
+      SCHEMES = [Scheme::DEVICE, Scheme::APPLICATION, Scheme::IDENTIFY]
+
+      attr_accessor :schemes, :mfa_token
+
+      def initialize
+        @schemes = {}
+      end
+
+      # Is there a list of accepted params somewhere?
+      def authorize(scheme, params)
+        raise ArgumentError, 'Params cannot be empty.' if params.empty?
+        raise ArgumentError, 'Unknown auth scheme' unless SCHEMES.include?(scheme)
+        @schemes[scheme] = params
+      end
+
+      def compile_params(params)
+        compiled = params.map do |key, value|
+          %Q(#{key}="#{value}")
+        end.join(', ')
+        compiled << ", mfa_token=#{@mfa_token}" if @mfa_token
+        compiled
+      end
+
+      def authorizer(schemes: [], action: 'NULL ACTION', **kwargs)
+        schemes.each do |scheme|
+          if (params = @schemes[scheme])
+            credential = compile_params(params)
+            return [scheme, credential]
+          end
+        end
+        raise "Action: #{action}.  No authorization available for '#{schemes}'"
+      end
+
+      def inspect
+        # Hide the secret token when printed
+        id = "%x" % (self.object_id << 1)
+        %Q(#<#{self.class}:0x#{id})
+      end
+    end
+
+    UnknownKeyError = Class.new(StandardError)
+    OTPConflictError = Class.new(StandardError)
+
+    class OTPAuthFailureError < StandardError
+      attr_reader :key
+
+      def initialize(key)
+        super
+        @key = key
+      end
+    end
+
+
+  end
+
+end

data/lib/round/collection.rb

@@ -0,0 +1,51 @@
+module Round
+  class Collection < Round::Base
+    include Enumerable
+    attr_reader :collection
+
+    def initialize(options = {}, &block)
+      super(options)
+      options.delete(:resource)
+      populate_data(options, &block)
+    end
+
+    def populate_data(options = {}, &block)
+      @collection = []
+      @hash = {}
+      @resource.list.each do |resource|
+        content = self.content_type.new(options.merge(resource: resource, client: @client))
+        yield content if block
+        self.add(content)
+      end if @resource.list
+    end
+
+    def refresh(options = {})
+      @collection = []
+      populate_data(options)
+    end
+
+    def add(content)
+      @collection << content
+      @hash[content.hash_identifier] = content
+    end
+
+    def content_type
+      Round::Base
+    end
+    
+    def [](key)
+      if key.is_a?(Fixnum)
+        @collection[key]
+      else
+        @hash[key]
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      @collection.send(meth, *args, &block)
+    rescue
+      super
+    end
+
+  end
+end

data/lib/round/device.rb

@@ -0,0 +1,17 @@
+module Round
+  class Device < Base
+
+  end
+
+  class DeviceCollection < Base
+
+    def create(name, redirect_uri: nil)
+      params = { name: name }
+      params[:redirect_uri] = redirect_uri if redirect_uri
+      auth_request_resource = @resource.create(params)
+      device_token = auth_request_resource.metadata.device_token
+      mfa_uri = auth_request_resource.mfa_uri
+      [device_token, mfa_uri]
+    end
+  end
+end

data/lib/round/helpers.rb

@@ -0,0 +1,10 @@
+module Round
+  module Helpers
+    def extract_params(header)
+      header.scan(/(\S*)\=\"(\S*)\"/).inject({}) {|memo, match| 
+        memo[match[0].to_sym] = match[1]
+        memo
+      }
+    end
+  end
+end

data/lib/round/transaction.rb

@@ -0,0 +1,54 @@
+module Round
+  class Transaction < Round::Base
+
+    def sign(wallet)
+      raise 'transaction is already signed' unless @resource['status'] == 'unsigned'
+      raise 'a wallet is required to sign a transaction' unless wallet
+
+      transaction = CoinOp::Bit::Transaction.data(@resource)
+      raise 'bad change address' unless wallet.valid_output?(transaction.outputs.last)
+      
+      @resource = @resource.update( 
+         signatures: {
+           transaction_hash: transaction.hex_hash,
+           inputs: wallet.signatures(transaction)
+         }
+      )
+      self
+    end
+
+    def approve(mfa_token)
+      @client.context.mfa_token = mfa_token
+      @resource.approve({})
+    end
+
+    def transaction_hash
+      @resource[:hash]
+    end
+
+    def self.hash_identifier
+      'hash'
+    end
+
+  end
+
+  class TransactionCollection < Round::Collection
+
+    def content_type
+      Round::Transaction
+    end
+
+    def create(payees, confirmations = 6, redirect_uri: nil)
+      raise 'Must have list of payees' unless payees
+
+      payment_resource = @resource.create(
+        utxo_confirmations: confirmations,
+        payees: payees,
+        redirect_uri: redirect_uri
+      )
+
+      Round::Transaction.new(resource: payment_resource, client: @client)
+    end
+
+  end
+end

data/lib/round/user.rb

@@ -0,0 +1,56 @@
+module Round
+  class User < Round::Base
+    association :wallets, 'Round::WalletCollection'
+    association :default_wallet, 'Round::Wallet'
+
+    def self.hash_identifier
+      'email'
+    end
+
+    def devices
+      resource = @client.resources.devices_query(
+        email: self.refresh.email
+      )
+      Round::DeviceCollection.new(
+        resource: resource,
+        client: @client
+      )
+    end
+    
+    def wallet
+      wallets.first
+    end
+  end
+
+  class UserCollection < Round::Collection
+
+    def content_type
+      Round::User
+    end
+
+   def create(first_name:, last_name:, email:, passphrase:,
+              device_name:, redirect_uri: nil)
+      multiwallet = CoinOp::Bit::MultiWallet.generate([:primary], @client.network)
+      primary_seed = CoinOp::Encodings.hex(multiwallet.trees[:primary].seed)
+      encrypted_seed = CoinOp::Crypto::PassphraseBox.encrypt(passphrase, primary_seed)
+      wallet = {
+        name: 'default',
+        network: @client.network,
+        primary_public_seed: multiwallet.trees[:primary].to_serialized_address,
+        primary_private_seed: encrypted_seed
+      }
+      params = {
+        email: email,
+        first_name: first_name,
+        last_name: last_name,
+        default_wallet: wallet,
+        device_name: device_name,
+      }
+      params[:redirect_uri] = redirect_uri if redirect_uri
+      user_resource = resource.create(params)
+      user = Round::User.new(resource: user_resource, client: @client)
+      user.metadata.device_token
+    end
+
+  end
+end

data/lib/round/version.rb

@@ -0,0 +1,3 @@
+module Round
+  VERSION = "0.7.0"
+end

data/lib/round/wallet.rb

@@ -0,0 +1,85 @@
+module Round
+  class Wallet < Round::Base
+
+    attr_reader :multiwallet, :application
+
+    def initialize(options = {})
+      @multiwallet = options[:multiwallet]
+      @application = options[:application]
+      super(options)
+    end
+
+    def unlock(passphrase)
+      primary_seed = CoinOp::Crypto::PassphraseBox.decrypt(passphrase, @resource.primary_private_seed)
+      primary_master = MoneyTree::Master.new(seed_hex: primary_seed)
+      @multiwallet = CoinOp::Bit::MultiWallet.new(
+        private: {
+          primary: primary_master
+        },
+        public: {
+          cosigner: @resource.cosigner_public_seed,
+          backup: @resource.backup_public_seed
+        }
+      )
+    end
+
+    def backup_key
+      @multiwallet.private_seed(:backup) 
+    end
+
+    def accounts
+      Round::AccountCollection.new(
+        resource: @resource.accounts,
+        wallet: self,
+        client: @client
+      )
+    end
+
+    def self.hash_identifier
+      'name'
+    end
+  end
+
+  class WalletCollection < Round::Collection
+
+    def initialize(options, &block)
+      super
+      @application = options[:application]
+    end
+
+    def content_type
+      Round::Wallet
+    end
+
+    def create(name, passphrase, network: 'bitcoin_testnet',
+               multiwallet: CoinOp::Bit::MultiWallet.generate([:primary, :backup]))
+      wallet_resource = create_wallet_resource(multiwallet, passphrase, name, network)
+      multiwallet.import(
+        cosigner_public_seed: wallet_resource.cosigner_public_seed
+      )
+      wallet = Round::Wallet.new(
+        resource: wallet_resource,
+        multiwallet: multiwallet,
+        application: @application,
+        client: @client
+      )
+      add(wallet)
+      wallet
+    end
+
+    def create_wallet_resource(multiwallet, passphrase, name, network)
+      primary_seed = CoinOp::Encodings.hex(multiwallet.trees[:primary].seed)
+      ## Encrypt the primary seed using a passphrase-derived key
+      encrypted_seed = CoinOp::Crypto::PassphraseBox.encrypt(passphrase, primary_seed)
+
+      @resource.create(
+        name: name,
+        network: network,
+        backup_public_seed: multiwallet.trees[:backup].to_serialized_address,
+        primary_public_seed: multiwallet.trees[:primary].to_serialized_address,
+        primary_private_seed: encrypted_seed
+      )
+    end
+
+  end
+end

data/lib/round.rb

@@ -1,8 +1,21 @@
-class Round
-  def self.shape
-    puts "Round!"
-  end
-  def self.cut
-  	puts "flawless"
-  end
-end
+require 'rbnacl/libsodium'
+require 'coin-op'
+require 'rotp'
+
+# Establish the namespace.
+module Round
+
+end
+
+require_relative 'round/version'
+require_relative 'round/helpers'
+require_relative 'round/client'
+require_relative 'round/base'
+require_relative 'round/collection'
+require_relative 'round/user'
+require_relative 'round/application'
+require_relative 'round/wallet'
+require_relative 'round/device'
+require_relative 'round/account'
+require_relative 'round/address'
+require_relative 'round/transaction'

data.tar.gz.sig

@@ -0,0 +1,3 @@
+���D�"D<{(̇�D�����B��?��T~��{����Io�f����-@>��M�	děyfރ�1��'�kާ�F��[Ǜ��X67����Ӎ_��C�X�A��&��m�۲8.��;6�Cj�(��RBe� ��7��f`���Se)��
+Dܵ�������x���w�U�9�@=���Q��z�f_8J��K���S���
+;��#e�_�j�~+/�ӆ��7�M��BYh���Y�dgt���^�1���

metadata

@@ -1,23 +1,218 @@
 --- !ruby/object:Gem::Specification
 name: round
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.7.0
 platform: ruby
 authors:
-- JMAN
+- Matthew King
+- Julian Vergel de Dios
+- James Larisch
 autorequire: 
 bindir: bin
-cert_chain: []
-date: 2014-08-29 00:00:00.000000000 Z
-dependencies: []
-description: A simple gem for the type of cut
-email: ''
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDXDCCAkSgAwIBAgIBATANBgkqhkiG9w0BAQUFADA6MQ8wDQYDVQQDDAZqdWxp
+  YW4xEzARBgoJkiaJk/IsZAEZFgNnZW0xEjAQBgoJkiaJk/IsZAEZFgJjbzAeFw0x
+  NTA0MDMwODAwMTdaFw0xNjA0MDIwODAwMTdaMDoxDzANBgNVBAMMBmp1bGlhbjET
+  MBEGCgmSJomT8ixkARkWA2dlbTESMBAGCgmSJomT8ixkARkWAmNvMIIBIjANBgkq
+  hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp0qCsOUQyTRA4f7WxoU2ctpUO5+eLZw8
+  ILvHJy/0dC2nnIgib+FaFA8TRIGw6fjX2hQ43QJyO36zkjUhAwNu/+TBCfG+Grut
+  2dI9XmqU5Z6PvvXRj6Gu5IkDeIVDKILZv3bDugHJalre4BUKnwPYv5WpZ/e/c6+z
+  E4fwe4ZQzqslSXZo0o/wFvs5dGuIoP93bazSeqddre0JKFFiEP/SNGP9e/lXEd2V
+  rLFYAY409no9J+VQOHP0Nu9ShlCZp8M45abKd2ykuSDaT6jH9YcUHBr3/IEsA4+f
+  DypeS1ySVvad+o8iTnfz1Hyohz4ORm3spf0BOtGI/Swbv3LObZJqkwIDAQABo20w
+  azAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUERhBDW/kkq7tz2hN
+  hPNHtounnkowGAYDVR0RBBEwD4ENanVsaWFuQGdlbS5jbzAYBgNVHRIEETAPgQ1q
+  dWxpYW5AZ2VtLmNvMA0GCSqGSIb3DQEBBQUAA4IBAQAgnumhg8ST8JohYWcoDoQt
+  3BUG5rbfJ/qE0utOt6esi9d6Vz6YHpiT08woaj68OWl9U9N4vjox+ckkTRs93KBd
+  y3thnK9cIEAzoEZs3BBguXYOoFLughGD7hEuLlRYbwZzyIdzx/XdLgsy5Di8Gqaa
+  RKurfXP+dERQww34CUhmhOLO4/rYGqaD88so0MzCImgS+OX+G4ppqd38iQpaxCHL
+  tdc4VS7IlSRxlZ3dBOgiigy9GXpJ+7F831AqjxL39EPwdr7RguTNz+pi//RKaT/U
+  IlpVB+Xfk0vQdP7iYfjGxDzUf0FACMjsR95waJmadKW1Iy6STw2hwPhYIQz1Hu1A
+  -----END CERTIFICATE-----
+date: 2015-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: patchboard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rotp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rbnacl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rbnacl-libsodium
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: coin-op
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Gem is a full-stack Bitcoin API that makes it easy to build powerful
+  blockchain apps with beautiful, elegant code.
+email:
+- matthew@pandastrike.com
+- julian@gem.co
+- james@gem.co
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
 - lib/round.rb
-homepage: http://rubygems.org/gems/round
+- lib/round/account.rb
+- lib/round/address.rb
+- lib/round/application.rb
+- lib/round/base.rb
+- lib/round/client.rb
+- lib/round/collection.rb
+- lib/round/device.rb
+- lib/round/helpers.rb
+- lib/round/transaction.rb
+- lib/round/user.rb
+- lib/round/version.rb
+- lib/round/wallet.rb
+homepage: https://github.com/GemHQ/round-rb
 licenses:
 - MIT
 metadata: {}
@@ -40,5 +235,5 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: The cut!
+summary: Ruby client for the Gem API
 test_files: []

metadata.gz.sig

@@ -0,0 +1 @@
+(�P���qG#pz���uɠǒ
�܌�Y�ܫ����|{3\E��"OsX���E ��	@�}�