blockchain 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 018e78fa4e59f75c5e786819ca080b696ef6dd33
+  data.tar.gz: 02d086845dd8c96c335e4cbb358c7ba9648b3149
+SHA512:
+  metadata.gz: 51da40ee452dd3107775d4fad95c76983bf29976e25e0abd420ae3dbf0740f3e9d7e958e57681e178903cd950812dff5b2efc311f593f1c2c28fb94894726ebf
+  data.tar.gz: 7a6ff5c6980ece9c49d1b1165ec830e02b37b56f559f7e70ea15bdc69d4da15dec3a303e3f6873cb391cec3314497203f70ade6679b105c74669eb0deaf3f968

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blockchain
+
+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,46 @@
+#Blockchain API library (Ruby, v1)
+
+An official Ruby gem for interacting with the Blockchain.info API.
+
+###Getting started
+
+Installation via RubyGems:
+
+```
+$ gem install blockchain
+```
+
+Manual installation:
+```
+$ git clone https://github.com/blockchain/api-v1-client-ruby
+$ cd api-v1-client-ruby
+$ rake install
+```
+
+The gem consists of the following functionality:
+
+* `blockexplorer` ([docs](docs/blockexplorer.md)) ([api/blockchain_api][api1])
+* `createwallet` ([docs](docs/createwallet.md)) ([api/create_wallet][api2])
+* `exchangerates` ([docs](docs/exchangerates.md)) ([api/exchange\_rates\_api][api3])
+* `receive` ([docs](docs/receive.md)) ([api/api_receive][api4])
+* `statistics` ([docs](docs/statistics.md)) ([api/charts_api][api5])
+* `wallet` ([docs](docs/wallet.md)) ([api/blockchain\_wallet\_api][api6])
+
+The main module is called `Blockchain`
+
+###Error handling
+
+All functions may raise exceptions caused by incorrectly passed parameters or other problems. If a call is rejected server-side, the `APIException` exception will be raised.
+
+###Request limits and API keys
+
+In order to prevent abuse some API methods require an API key approved with some basic contact information and a description of its intended use. Please request an API key [here](https://blockchain.info/api/api_create_code).
+
+The same API key can be used to bypass the request limiter.
+
+[api1]: https://blockchain.info/api/blockchain_api
+[api2]: https://blockchain.info/api/create_wallet
+[api3]: https://blockchain.info/api/exchange_rates_api
+[api4]: https://blockchain.info/api/api_receive
+[api5]: https://blockchain.info/api/charts_api
+[api6]: https://blockchain.info/api/blockchain_wallet_api

data/Rakefile

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

data/blockchain.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'blockchain/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "blockchain"
+  spec.version       = Blockchain::VERSION
+  spec.authors       = ["Blockchain"]
+  spec.email         = ["support@blockchain.zendesk.com"]
+  spec.summary       = %q{Blockchain API library (Ruby, v1)}
+  spec.description   = %q{Blockchain API library (Ruby, v1)}
+  spec.homepage      = "https://github.com/blockchain/api-v1-client-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/docs/blockexplorer.md

@@ -0,0 +1,117 @@
+##Block explorer functionality
+
+All functions support an optional parameter called `api_code`. It won't be listed with every function description.
+
+####`get_block`
+Get a single block based on a block index or hash. Returns a `Block` object.
+
+Params: 
+```
+block_id : str - block index or hash
+```
+
+Usage:
+```ruby
+require 'blockchain'
+
+block = Blockchain::get_block('000000000000000016f9a2c3e0f4c1245ff24856a79c34806969f5084f410680')
+```
+
+####`get_tx`
+Get a single transaction based on a transaction index or hash. Returns a `Transaction` object.
+
+Params:
+```
+tx_id : str - transaction index or hash
+```
+
+Usage:
+```ruby
+tx = Blockchain::get_tx('d4af240386cdacab4ca666d178afc88280b620ae308ae8d2585e9ab8fc664a94')
+```
+
+####`get_block_height`
+Get an array of blocks at the specified height. Returns an array of `Block` objects.
+
+Params:
+```
+height : int - block height
+```
+
+Usage:
+```ruby
+blocks = Blockchain::get_block_height(2570)
+```
+
+####`get_address`
+Get a single address and its transactions. Returns an `Address` object.
+
+Params:
+```
+address : str - address in the base58 or hash160 format
+```
+
+Usage:
+```ruby
+address = Blockchain::get_address('1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd')
+```
+
+####`get_unspent_outputs`
+Get an array of unspent outputs for an address. Returns an array of `UnspentOutput` objects.
+
+Params:
+```
+address : str - address in the base58 or hash160 format
+```
+
+Usage:
+```ruby
+outs = Blockchain::get_unspent_outputs('1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd')
+```
+
+####`get_latest_block`
+Get the latest block on the main chain. Returns a `LatestBlock` object.
+
+Usage:
+```ruby
+latest_block = Blockchain::get_latest_block()
+```
+
+####`get_unconfirmed_tx`
+Get a list of currently unconfirmed transactions. Returns an array of `Transaction` objects.
+
+Usage:
+```ruby
+txs = Blockchain::get_unconfirmed_tx()
+```
+
+####`get_blocks`
+Get a list of blocks for a specific day or mining pool. Returns an array of `SimpleBlock` objects.
+
+Params:
+```
+time : int - unix time in ms (optional)
+pool_name : str - pool name (optional)
+```
+At least one parameter is required.
+
+Usage:
+```ruby
+blocks = Blockchain::get_blocks(pool_name = 'Discus Fish')
+```
+
+####`get_inventory_data`
+Get inventory data for recent blocks and addresses (up to 1 hour old). Returns an `InventoryData` object.
+
+Params:
+```
+hash : str - tx or block hash
+```
+
+Usage:
+```ruby
+inv = Blockchain::get_inventory_data('d4af240386cdacab4ca666d178afc88280b620ae308ae8d2585e9ab8fc664a94')
+```
+
+Note regarding `Input` objects: if coinbase transaction, only `script` and `script_siq` will be populated.
+

data/docs/createwallet.md

@@ -0,0 +1,20 @@
+##Create Wallet functionality
+
+####`create_wallet`
+Create a new Blockchain.info wallet. It can be created containing a pre-generated private key or will otherwise generate a new private key. Returns a `CreateWalletResponse` instance.
+
+Params: 
+```
+password : str - password for the new wallet. At least 10 characters.
+api_code : str - API code with the create wallets permission
+priv : str - private key to add to the wallet (optional, keyword)
+label : str - label for the first address in the wallet (optional, keyword)
+email : str - email to associate with the new wallet (optional, keyword)
+```
+
+Usage:
+```ruby
+require 'blockchain'
+
+wallet = Blockchain::create_wallet('1234password', '58ck39ajuiw', label: 'Test wallet')
+```

data/docs/exchangerates.md

@@ -0,0 +1,32 @@
+##Exchange rates functionality
+
+All functions support an optional parameter called `api_code`. It won't be listed with every function description.
+
+####`get_ticker`
+Call the 'ticker' method and return a dictionary of `Currency` objects. Keys are currency symbols (str) and values are `Currency` objects.
+
+
+Usage:
+```ruby
+require 'blockchain'
+
+ticker = Blockchain::get_ticker()
+#print the 15 min price for every currency
+ticker.keys.each do |key|
+	puts ticker[key].p15min
+end
+```
+
+####`to_btc`
+Call the 'tobtc' method and convert x value in the provided currency to BTC. Returns a `float`.
+
+Params:
+```
+ccy : str - currency code
+value : float
+```
+
+Usage:
+```ruby
+btc_amount = Blockchain::to_btc('USD', 4342.11)
+```

data/docs/receive.md

@@ -0,0 +1,19 @@
+##Receive functionality
+
+####`receive`
+Call the 'api/receive' endpoint and create a forwarding address. Returns a `ReceiveResponse` object.
+
+Params:
+```
+dest_addr : str
+callback : str
+api_code : str (optional)
+```
+
+Usage:
+```ruby
+require 'blockchain'
+
+resp = Blockchain::receive('1hNapz1CuH4DhnV1DFHH7hafwDE8FJRheA', 'http://your.url.com')
+
+```

data/docs/statistics.md

@@ -0,0 +1,16 @@
+## Statistics functionality
+
+####`get`
+Get network statistics. Returns a `StatisticsResponse` object.
+
+Params:
+```
+api_code : str (optional)
+```
+
+Usage:
+```ruby
+require 'blockchain'
+
+stats = Blockchain::get_statistics()
+```

data/docs/wallet.md

@@ -0,0 +1,148 @@
+##`wallet` module
+
+An instance of the `Wallet` class needs to be initialized before it can be used.
+
+Constructor params:
+```
+identifier : str
+password : str
+second_password : str (optional)
+api_code : str (optional)
+```
+
+Usage:
+```ruby
+require 'blockchain'
+
+wallet = Blockchain::Wallet.new('ada4e4b6-3c9f-11e4-baad-164230d1df67', 'password123')
+```
+
+####`send`
+Send bitcoin from your wallet to a single address. Returns a `PaymentResponse` object.
+
+Params:
+```
+to : str - receiving address
+amount : int - amount to send (in satoshi)
+from_address : str - specific address to send from (optional, keyword)
+fee : int - transaction fee in satoshi. Must be greater than default (optional, keyword)
+note : str - public note to include with the transaction (optional, keyword)
+```
+
+Usage:
+```ruby
+payment = wallet.send('1NAF7GbdyRg3miHNrw2bGxrd63tfMEmJob', 1000000, from_address: '1A8JiWcwvpY7tAopUkSnGuEYHmzGYfZPiq')
+
+puts payment.tx_hash
+```
+
+####`send_many`
+Send bitcoin from your wallet to multiple addresses. Returns a `PaymentResponse` object.
+
+Params:
+```
+recipients : dictionary - dictionary with the structure of 'address':amount
+from_address : str - specific address to send from (optional, keyword)
+fee : int - transaction fee in satoshi. Must be greater than default (optional, keyword)
+note : str - public note to include with the transaction (optional, keyword)
+```
+
+Usage:
+```ruby
+recipients = { '1NAF7GbdyRg3miHNrw2bGxrd63tfMEmJob' => 1428300,
+				'1A8JiWcwvpY7tAopUkSnGuEYHmzGYfZPiq' => 234522117 }
+payment = wallet.send_many(recipients)
+
+puts payment.tx_hash
+```
+
+####`get_balance`
+Fetch the wallet balance. Includes unconfirmed transactions and possibly double spends. Returns the wallet balance in satoshi.
+
+Usage:
+```ruby
+puts wallet.get_balance() 
+```
+
+####`list_addresses`
+List all active addresses in the wallet. Returns an array of `Address` objects.
+
+Params:
+```
+confirmations : int - minimum number of confirmations transactions must have before being included in balance of addresses (optional)
+```
+
+Usage:
+```ruby
+addresses = wallet.list_addresses()
+addresses.each do |a|
+	puts a.balance
+end
+
+```
+
+####`get_address`
+Retrieve an address from the wallet. Returns an `Address` object.
+
+Params:
+```
+confirmations : int - minimum number of confirmations transactions must have before being included in the balance (optional)
+```
+
+Usage:
+```ruby
+addr = wallet.get_address('1NAF7GbdyRg3miHNrw2bGxrd63tfMEmJob', confirmations = 2)
+puts addr.balance
+```
+
+####`new_address`
+Generate a new address and add it to the wallet. Returns an `Address` object.
+
+Params:
+```
+label : str - label to attach to the address (optional, keyword)
+```
+
+Usage:
+```ruby
+newaddr = wallet.new_address('test_label')
+```
+
+####`archive_address`
+Archive an address. Returns a string representation of the archived address.
+
+Params:
+```
+address : str - address to archive
+```
+
+Usage:
+```ruby
+wallet.archive_address('1NAF7GbdyRg3miHNrw2bGxrd63tfMEmJob')
+```
+
+####`unarchive_address`
+Unarchive an address. Returns a string representation of the unarchived address.
+
+Params:
+```
+address : str - address to unarchive
+```
+
+Usage:
+```ruby
+wallet.unarchive_address('1NAF7GbdyRg3miHNrw2bGxrd63tfMEmJob')
+```
+
+####`consolidate`
+Consolidate the wallet addresses. Returns a string array of consolidated addresses.
+
+Params:
+```
+days : int - addresses which have not received any transactions in at least this many days will be consolidated.
+```
+
+Usage:
+```ruby
+wallet.consolidate(50)
+```

data/lib/blockchain.rb

@@ -0,0 +1,11 @@
+require "blockchain/version"
+require "blockchain/blockexplorer"
+require "blockchain/createwallet"
+require "blockchain/exchangerates"
+require "blockchain/receive"
+require "blockchain/statistics"
+require "blockchain/wallet"
+
+module Blockchain
+
+end

data/lib/blockchain/blockexplorer.rb

@@ -0,0 +1,298 @@
+require 'json'
+require_relative 'util'
+
+module Blockchain
+
+	def self.get_block(block_id, api_code = nil)
+		params = api_code.nil? ? { } : { 'api_code' => api_code }
+		resource = 'rawblock/' + block_id
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return Block.new(JSON.parse(response))
+	end
+
+	def self.get_tx(tx_id, api_code = nil)
+		params = api_code.nil? ? { } : { 'api_code' => api_code }
+		resource = 'rawtx/' + tx_id
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return Transaction.new(JSON.parse(response))
+	end
+
+	def self.get_block_height(height, api_code = nil)
+		params = { 'format' => 'json' }
+		if !api_code.nil? then params['api_code'] = api_code end
+		resource = "block-height/#{height}"
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return JSON.parse(response)['blocks'].map{ |b| Block.new(b) }
+	end
+
+	def self.get_address(address, api_code = nil)
+		params = api_code.nil? ? { } : { 'api_code' => api_code }
+		resource = 'rawaddr/' + address
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return Address.new(JSON.parse(response))
+	end
+
+	def self.get_unspent_outputs(address, api_code = nil)
+		params = { 'active' => address }
+		if !api_code.nil? then params['api_code'] = api_code end
+		resource = 'unspent'
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return JSON.parse(response)['unspent_outputs'].map{ |o| UnspentOutput.new(o) }
+	end
+
+	def self.get_unconfirmed_tx(api_code = nil)
+		params = { 'format' => 'json' }
+		if !api_code.nil? then params['api_code'] = api_code end
+		resource = 'unconfirmed-transactions'
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return JSON.parse(response)['txs'].map{ |t| Transaction.new(t) }
+	end
+
+	def self.get_blocks(api_code = nil, time: nil, pool_name: nil)
+		params = { 'format' => 'json' }
+		if !api_code.nil? then params['api_code'] = api_code end
+		resource = "blocks/"
+		if !time.nil?
+			resource += time.to_s
+		elsif !pool_name.nil?
+			resource += pool_name
+		end
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return JSON.parse(response)['blocks'].map{ |b| SimpleBlock.new(b) }
+	end
+	
+	def self.get_latest_block(api_code = nil)
+		params = {}
+		if !api_code.nil? then params['api_code'] = api_code end
+		resource = 'latestblock'
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return LatestBlock.new(JSON.parse(response))
+	end
+	
+	def self.get_inventory_data(hash, api_code = nil)
+		params = { 'format' => 'json' }
+		if !api_code.nil? then params['api_code'] = api_code end
+		resource = "inv/#{hash}"
+		response = Blockchain::call_api(resource, method: 'get', data: params)
+		return InventoryData.new(JSON.parse(response))
+	end
+
+	class SimpleBlock
+		attr_reader :height
+		attr_reader :hash
+		attr_reader :time
+		attr_reader :main_chain
+		
+		def initialize(b)
+			@height = b['height']
+			@hash = b['hash']
+			@time = b['time']
+			@main_chain = b['main_chain']
+		end
+	end
+
+	class LatestBlock
+		attr_reader :hash
+		attr_reader :time
+		attr_reader :block_index
+		attr_reader :height
+		attr_reader :tx_indexes
+		
+		def initialize(b)
+			@hash = b['hash']
+			@time = b['time']
+			@block_index = b['block_index']
+			@height = b['height']
+			@tx_indexes = b['txIndexes']
+		end
+	end
+
+	class UnspentOutput
+		attr_reader :tx_hash
+		attr_reader :tx_index
+		attr_reader :tx_output_n
+		attr_reader :script
+		attr_reader :value
+		attr_reader :value_hex
+		attr_reader :confirmations
+		
+		def initialize(o)
+			@tx_hash = o['tx_hash']
+			@tx_index = o['tx_index']
+			@tx_output_n = o['tx_output_n']
+			@script = o['script']
+			@value = o['value']
+			@value_hex = o['value_hex']
+			@confirmations = o['confirmations']
+		end
+	end
+
+	class Address
+		attr_reader :hash160
+		attr_reader :address
+		attr_reader :n_tx
+		attr_reader :total_received
+		attr_reader :total_sent
+		attr_reader :final_balance
+		attr_reader :transactions
+		
+		def initialize(a)
+			@hash160 = a['hash160']
+			@address = a['address']
+			@n_tx = a['n_tx']
+			@total_received = a['total_received']
+			@total_sent = a['total_sent']
+			@final_balance = a['final_balance']
+			@transactions = a['txs'].map{ |tx| Transaction.new(tx) }
+		end
+	end
+
+	class Input
+		attr_reader :n
+		attr_reader :value
+		attr_reader :address
+		attr_reader :tx_index
+		attr_reader :type
+		attr_reader :script
+		attr_reader :script_sig
+		attr_reader :sequence
+
+		def initialize(i)
+			obj = i['prev_out']
+			if !obj.nil?
+			# regular TX
+				@n = obj['n']
+				@value = obj['value']
+				@address = obj['addr']
+				@tx_index = obj['tx_index']
+				@type = obj['type']
+				@script = obj['script']
+				@script_sig = i['script']
+				@sequence = i['sequence']
+			else
+			# coinbase TX
+				@script_sig = i['script']
+				@sequence = i['sequence']
+			end
+		end
+	end
+
+	class Output
+		attr_reader :n
+		attr_reader :value
+		attr_reader :address
+		attr_reader :tx_index
+		attr_reader :script
+		attr_reader :spent
+
+		def initialize(o)
+			@n = o['n']
+			@value = o['value']
+			@address = o['addr']
+			@tx_index = o['tx_index']
+			@script = o['script']
+			@spent = o['spent']
+		end
+	end
+
+	class Transaction
+		attr_reader :double_spend
+		attr_reader :block_height
+		attr_reader :time
+		attr_reader :relayed_by
+		attr_reader :hash
+		attr_reader :tx_index
+		attr_reader :version
+		attr_reader :size
+		attr_reader :inputs
+		attr_reader :outputs
+		
+		def initialize(t)
+			@double_spend = t.fetch('double_spend', false)
+			@block_height = t.fetch('block_height', false)
+			@time = t['time']
+			@relayed_by = t['relayed_by']
+			@hash = t['hash']
+			@tx_index = t['tx_index']
+			@version = t['ver']
+			@size = t['size']
+			@inputs = t['inputs'].map{ |i| Input.new(i) }
+			@outputs = t['out'].map{ |o| Output.new(o) }
+			
+			if @block_height.nil?
+				@block_height = -1
+			end
+		end
+		
+		def adjust_block_height(h)
+			@block_height = h
+		end
+	end
+
+		
+	class Block
+		attr_reader :hash
+		attr_reader :version
+		attr_reader :previous_block
+		attr_reader :merkle_root
+		attr_reader :time
+		attr_reader :bits
+		attr_reader :fee
+		attr_reader :nonce
+		attr_reader :n_tx
+		attr_reader :size
+		attr_reader :block_index
+		attr_reader :main_chain
+		attr_reader :height
+		attr_reader :received_time
+		attr_reader :relayed_by
+		attr_reader :transactions
+		
+		def initialize(b)
+			@hash = b['hash']
+			@version = b['ver']
+			@previous_block = b['prev_block']
+			@merkle_root = b['mrkl_root']
+			@time = b['time']
+			@bits = b['bits']
+			@fee = b['fee']
+			@nonce = b['nonce']
+			@n_tx = b['n_tx']
+			@size = b['size']
+			@block_index = b['block_index']
+			@main_chain = b['main_chain']
+			@height = b['height']
+			@received_time = b['received_time']
+			@relayed_by = b['relayed_by']
+			@transactions = b['tx'].map{ |tx| Transaction.new(tx) }
+			@transactions.each do |tx|
+				tx.adjust_block_height(@height)
+			end
+			
+			if @received_time.nil?
+				@received_time = @time
+			end
+		end
+	end
+
+	class InventoryData
+		attr_reader :hash
+		attr_reader :type
+		attr_reader :initial_time
+		attr_reader :initial_ip
+		attr_reader :nconnected
+		attr_reader :relayed_count
+		attr_reader :relayed_percent
+			
+		def initialize(i)
+			@hash = i['hash']
+			@type = i['type']
+			@initial_time = i['initial_time'].to_i
+			@initial_ip = i['initial_ip']
+			@nconnected = i['nconnected'].to_i
+			@relayed_count = i['relayed_count'].to_i
+			@relayed_percent = i['relayed_percent'].to_i
+		end
+	end
+		
+end

data/lib/blockchain/createwallet.rb

@@ -0,0 +1,39 @@
+require 'json'
+require_relative 'util'
+
+module Blockchain
+
+	def self.create_wallet(password, api_code, priv: nil, label: nil, email: nil)
+
+		params = { 'password' => password, 'api_code' => api_code }
+		
+		if !priv.nil?
+			params['priv'] = priv
+		end
+		if !label.nil?
+			params['label'] = label
+		end
+		if !email.nil?
+			params['email'] = email
+		end
+		
+		response = Blockchain::call_api('api/v2/create_wallet', method: 'post', data: params)
+		json_response = JSON.parse(response)
+		return CreateWalletResponse.new(json_response['guid'],
+										json_response['address'],
+										json_response['link'])
+	end
+
+	class CreateWalletResponse
+		attr_reader :identifier
+		attr_reader :address
+		attr_reader :link
+
+		def initialize(identifier, address, link)
+			@identifier = identifier
+			@address = address
+			@link = link
+		end
+	end
+
+end

data/lib/blockchain/exchangerates.rb

@@ -0,0 +1,47 @@
+require 'json'
+require_relative 'util'
+
+module Blockchain
+	
+	class Currency
+		attr_reader :last
+		attr_reader :buy
+		attr_reader :sell
+		attr_reader :symbol
+		attr_reader :p15min
+
+		def initialize(last, buy, sell, symbol, p15min)
+			@last = last
+			@buy = buy
+			@sell = sell
+			@symbol = symbol
+			@p15min = p15min
+		end
+	end
+
+	def self.get_ticker(api_code = nil)
+		params = {}
+		if !api_code.nil? then params['api_code'] = api_code end
+		response = Blockchain::call_api('ticker', data: params)
+		json_response = JSON.parse(response)
+		
+		ticker = {}
+		json_response.each do |key,value|
+			json_ccy = json_response[key]
+			ccy = Currency.new(json_ccy['last'],
+								json_ccy['buy'],
+								json_ccy['sell'],
+								json_ccy['symbol'],
+								json_ccy['15m'])
+			ticker[key] = ccy
+		end
+		return ticker
+	end
+
+	def self.to_btc(ccy, value, api_code = nil)
+		params = { 'currency' => ccy, 'value' => value}
+		if !api_code.nil? then params['api_code'] = api_code end
+		return Blockchain::call_api('tobtc', data: params).to_f
+	end
+
+end

data/lib/blockchain/receive.rb

@@ -0,0 +1,32 @@
+require 'json'
+require_relative 'util'
+
+module Blockchain
+
+	class ReceiveResponse
+		attr_reader :fee_percent
+		attr_reader :destination
+		attr_reader :input_address
+		attr_reader :callback_url
+		
+		def initialize(fee_percent, dest, input, callback)
+			@fee_percent = fee_percent
+			@destination = dest
+			@input_address = input
+			@callback_url = callback
+		end
+	end	
+
+	def self.receive(dest_addr, callback, api_code = nil)
+		params = { 'method' => 'create', 'address' => dest_addr, 'callback' => callback }
+		if !api_code.nil? then params['api_code'] = api_code end
+		resp = Blockchain::call_api('api/receive', method: 'post', data: params)
+		json_resp = JSON.parse(resp)
+		receive_response = ReceiveResponse.new(json_resp['fee_percent'],
+												json_resp['destination'],
+												json_resp['input_address'],
+												json_resp['callback_url'])
+		return receive_response
+	end
+
+end

data/lib/blockchain/statistics.rb

@@ -0,0 +1,62 @@
+require 'json'
+require_relative 'util'
+
+module Blockchain
+
+	def self.get_statistics(api_code = nil)
+		params = { 'format' => 'json' }
+		if !api_code.nil? then params['api_code'] = api_code end
+		response = Blockchain::call_api('stats', method: 'get', data: params)
+		json_response = JSON.parse(response)
+		return StatisticsResponse.new(json_response)
+	end
+
+	class StatisticsResponse
+			attr_reader :trade_volume_btc
+			attr_reader :miners_revenue_usd
+			attr_reader :btc_mined
+			attr_reader :trade_volume_usd
+			attr_reader :difficulty
+			attr_reader :minutes_between_blocks
+			attr_reader :days_destroyed
+			attr_reader :number_of_transactions
+			attr_reader :hash_rate
+			attr_reader :timestamp
+			attr_reader :mined_blocks
+			attr_reader :blocks_size
+			attr_reader :total_fees_btc
+			attr_reader :total_btc_sent
+			attr_reader :estimated_btc_sent
+			attr_reader :total_btc
+			attr_reader :total_blocks
+			attr_reader :next_retarget
+			attr_reader :estimated_transaction_volume_usd
+			attr_reader :miners_revenue_btc
+			attr_reader :market_price_usd
+		
+		def initialize(s)
+			@trade_volume_btc = s['trade_volume_btc']
+			@miners_revenue_usd = s['miners_revenue_usd']
+			@btc_mined = s['n_btc_mined']
+			@trade_volume_usd = s['trade_volume_usd']
+			@difficulty = s['difficulty']
+			@minutes_between_blocks = s['minutes_between_blocks']
+			@days_destroyed = s['days_destroyed']
+			@number_of_transactions = s['n_tx']
+			@hash_rate = s['hash_rate']
+			@timestamp = s['timestamp']
+			@mined_blocks = s['n_blocks_mined']
+			@blocks_size = s['blocks_size']
+			@total_fees_btc = s['total_fees_btc']
+			@total_btc_sent = s['total_btc_sent']
+			@estimated_btc_sent = s['estimated_btc_sent']
+			@total_btc = s['totalbc']
+			@total_blocks = s['n_blocks_total']
+			@next_retarget = s['nextretarget']
+			@estimated_transaction_volume_usd = s['estimated_transaction_volume_usd']
+			@miners_revenue_btc = s['miners_revenue_btc']
+			@market_price_usd = s['market_price_usd']
+		end
+	end
+	
+end

data/lib/blockchain/util.rb

@@ -0,0 +1,32 @@
+require 'net/http'
+
+module Blockchain
+
+	class APIException < StandardError
+	end
+
+	BASE_URL = "https://blockchain.info/"
+
+	def self.call_api(resource, method: 'get', data: nil)
+		url = URI.parse(BASE_URL + resource)
+		http = Net::HTTP.new(url.host, url.port)
+		http.use_ssl = true
+		
+		request = nil
+		if method == 'get'
+			url.query = data.nil? ? nil : URI.encode_www_form(data)
+			request = Net::HTTP::Get.new(url.request_uri)
+		elsif method == 'post'
+			request = Net::HTTP::Post.new(url.request_uri)
+			request.content_type = 'application/x-www-form-urlencoded'
+			if data != nil then request.set_form_data(data) else {} end
+		end
+		
+		response = http.request(request)
+		if response.code != '200'
+			raise APIException, response.body
+		end
+		return response.body
+	end
+
+end

data/lib/blockchain/version.rb

@@ -0,0 +1,3 @@
+module Blockchain
+  VERSION = "1.0.0"
+end

data/lib/blockchain/wallet.rb

@@ -0,0 +1,167 @@
+require 'json'
+require_relative 'util'
+
+module Blockchain
+
+	class Wallet
+
+		def initialize(identifier, password, second_password = nil, api_code = nil)
+			@identifier = identifier
+			@password = password
+			@second_password = second_password
+			@api_code = api_code
+		end
+		
+		def send(to, amount, from_address: nil, fee: nil, note: nil)
+			recipient = { to => amount }
+			return send_many(recipient, from_address: from_address, fee: fee, note: note)
+		end
+		
+		def send_many(recipients, from_address: nil, fee: nil, note: nil)
+			params = build_basic_request()
+			method = ''
+			
+			if recipients.size == 1
+				params['to'] = recipients.keys[0]
+				params['amount'] = recipients.values[0]
+				method = 'payment'
+			else
+				params['recipients'] = JSON.dump(recipients)
+				method = 'sendmany'
+			end
+			
+			if !from_address.nil?
+				params['from'] = from_address
+			end
+			if !fee.nil?
+				params['fee'] = fee
+			end
+			if !note.nil?
+				params['note'] = note
+			end
+			
+			response = Blockchain::call_api("merchant/#{@identifier}/#{method}", method: 'post', data: params)
+			json_response = parse_json(response)
+			return PaymentResponse.new(
+										json_response['message'],
+										json_response['tx_hash'],
+										json_response['notice'])
+		end
+		
+		def get_balance()
+			response = resp = Blockchain::call_api("merchant/#{@identifier}/balance", method: 'get', data: build_basic_request())
+			json_response = parse_json(response)
+			return json_response['balance']
+		end
+		
+		def list_addresses(confirmations = 0)
+			params = build_basic_request()
+			params['confirmations'] = confirmations
+			response = Blockchain::call_api("merchant/#{@identifier}/list", method: 'get', data: params)
+			json_response = parse_json(response)
+			
+			addresses = []
+			json_response['addresses'].each do |a|
+				addr = WalletAddress.new(a['balance'],
+											a['address'],
+											a['label'],
+											a['total_received'])
+				addresses.push(addr)
+			end
+			return addresses
+		end
+		
+		def get_address(address, confirmations = 0)
+			params = build_basic_request()
+			params['address'] = address
+			params['confirmations'] = confirmations
+			response = Blockchain::call_api("merchant/#{@identifier}/address_balance", method: 'get', data: params)
+			json_response = parse_json(response)
+			return WalletAddress.new(json_response['balance'],
+									json_response['address'],
+									nil,
+									json_response['total_received'])
+		end
+		
+		def new_address(label = nil)
+			params = build_basic_request()
+			if !label.nil? then params['label'] = label end
+			response = Blockchain::call_api("merchant/#{@identifier}/new_address", method: 'post', data: params)
+			json_response = parse_json(response)
+			return WalletAddress.new(0,
+									json_response['address'],
+									json_response['label'],
+									0)
+		end
+		
+		def archive_address(address)
+			params = build_basic_request()
+			params['address'] = address
+			response = Blockchain::call_api("merchant/#{@identifier}/archive_address", method: 'post', data: params)
+			json_response = parse_json(response)
+			return json_response['archived']
+		end
+		
+		def unarchive_address(address)
+			params = build_basic_request()
+			params['address'] = address
+			response = Blockchain::call_api("merchant/#{@identifier}/unarchive_address", method: 'post', data: params)
+			json_response = parse_json(response)
+			return json_response['active']
+		end
+		
+		def consolidate(days)
+			params = build_basic_request()
+			params['days'] = days
+			response = Blockchain::call_api("merchant/#{@identifier}/auto_consolidate", method: 'post', data: params)
+			json_response = parse_json(response)
+			return json_response['consolidated']
+		end
+		
+		def build_basic_request()
+			params = { 'password' => @password }
+			if !@second_password.nil?
+				params['second_password'] = @second_password
+			end
+			if !@api_code.nil?
+				params['api_code'] = @api_code
+			end
+			return params
+		end
+		
+		# convenience method that parses a response into json AND makes sure there are no errors
+		def parse_json(response)
+			json_response = JSON.parse(response)
+			error = json_response['error']
+			if !error.nil? then raise APIException.new(error) end
+			return json_response
+		end
+	end
+
+	class WalletAddress
+		attr_reader :balance
+		attr_reader :address
+		attr_reader :label
+		attr_reader :total_received
+		
+		def initialize(balance, address, label, total_received)
+			@balance = balance
+			@address = address
+			@label = label
+			@total_received = total_received
+		end
+	end
+
+	class PaymentResponse
+		attr_reader :message
+		attr_reader :tx_hash
+		attr_reader :notice
+		
+		def initialize(message, tx_hash, notice)
+			@message = message
+			@tx_hash = tx_hash
+			@notice = notice
+		end
+	end
+	
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: blockchain
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Blockchain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Blockchain API library (Ruby, v1)
+email:
+- support@blockchain.zendesk.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- blockchain.gemspec
+- docs/blockexplorer.md
+- docs/createwallet.md
+- docs/exchangerates.md
+- docs/receive.md
+- docs/statistics.md
+- docs/wallet.md
+- lib/blockchain.rb
+- lib/blockchain/blockexplorer.rb
+- lib/blockchain/createwallet.rb
+- lib/blockchain/exchangerates.rb
+- lib/blockchain/receive.rb
+- lib/blockchain/statistics.rb
+- lib/blockchain/util.rb
+- lib/blockchain/version.rb
+- lib/blockchain/wallet.rb
+homepage: https://github.com/blockchain/api-v1-client-ruby
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Blockchain API library (Ruby, v1)
+test_files: []