blockchain 2.0.0 → 3.0.0

data/lib/blockchain/exchangerates.rb

@@ -1,9 +1,61 @@
 require 'json'
-require_relative 'util'
+require_relative 'client'
 
 module Blockchain
-	
-	class Currency
+
+    class ExchangeRateExplorer
+
+        attr_reader :client
+
+        def initialize(base_url = nil, api_code = nil)
+            @client = Client.new(base_url, api_code)
+        end
+
+        def proxy(method_name, *args)
+            warn "[DEPRECATED] avoid use of static methods, use an instance of ExchangeRateExplorer class instead."
+            send(method_name, *args)
+        end
+
+        def get_ticker()
+            params = {}
+            response = @client.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 to_btc(ccy, value)
+            params = { 'currency' => ccy, 'value' => value}
+            return @client.call_api('tobtc', data: params).to_f
+        end
+
+        def from_btc(ccy = nil, satoshi_value)
+            params = {'value' => satoshi_value}
+            if !ccy.nil? then params['currency'] = ccy end
+            return @client.call_api('frombtc', data: params).to_f
+        end
+
+    end
+
+	def self.get_ticker(api_code = nil)
+        Blockchain::ExchangeRateExplorer.new(nil, api_code).proxy(__method__)
+	end
+
+	def self.to_btc(ccy, value, api_code = nil)
+        Blockchain::ExchangeRateExplorer.new(nil, api_code).proxy(__method__, ccy, value)
+	end
+
+    class Currency
 		attr_reader :last
 		attr_reader :buy
 		attr_reader :sell
@@ -19,29 +71,4 @@ module Blockchain
 		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/pushtx.rb

@@ -1,16 +1,28 @@
 require 'json'
-require_relative 'util'
+require_relative 'client'
 
 module Blockchain
 
+    class PushTx
+
+        attr_reader :client
+
+        def initialize(base_url = nil, api_code = nil)
+            @client = Client.new(base_url, api_code)
+        end
+
+        def proxy(method_name, tx)
+            warn "[DEPRECATED] avoid use of static methods, use an instance of PushTx class instead."
+            send(method_name, tx)
+        end
+
+        def pushtx(tx)
+            params = { 'tx' => tx }
+            @client.call_api('pushtx', method: 'post', data: params)
+        end
+    end
+
 	def self.pushtx(tx, api_code = nil)
-		params = { 'tx' => tx }
-		
-		if !api_code.nil?
-			params['api_code'] = api_code
-		end
-		
-		Blockchain::call_api('pushtx', method: 'post', data: params)
+        Blockchain::PushTx.new(nil, api_code).proxy(__method__, tx)
 	end
-
 end

data/lib/blockchain/receive.rb

@@ -1,6 +1,6 @@
 require 'json'
 
-require_relative 'util'
+require_relative 'client'
 
 module Blockchain
 
@@ -19,7 +19,57 @@ module Blockchain
 	end
 
 	module V2
-		class ReceiveResponse
+
+        class Receive
+
+            attr_reader :client
+
+            def initialize(base_url = nil)
+                base_url = base_url.nil? ? 'https://api.blockchain.info/v2/' : base_url
+                @client = Client.new(base_url)
+            end
+
+            def proxy(method_name, *args)
+                warn "[DEPRECATED] avoid use of static methods, use an instance of Receive class instead."
+                send(method_name, *args)
+            end
+
+            def receive(xpub, callback, api_key, gap_limit = nil)
+                params = { 'xpub' => xpub, 'callback' => callback, 'key' => api_key }
+                if !gap_limit.nil? then params['gap_limit'] = gap_limit end
+                response = @client.call_api('receive', method: 'get', data: params)
+                return ReceiveResponse.new(JSON.parse(response))
+            end
+
+            def callback_log(callback, api_key = nil)
+                params = {'callback' => callback }
+                params['key'] = api_key unless api_key.nil?
+                response = @client.call_api('receive/callback_log', method: 'get', data: params)
+                json_resp = JSON.parse(response)
+                log_entries = json_resp.map do |entry|
+                    LogEntry.new(JSON.parse(entry))
+                end
+                return log_entries
+            end
+
+            def check_gap(xpub, api_key = nil)
+                params = {'xpub' => xpub}
+                params['key'] = api_key unless api_key.nil?
+                response = @client.call_api('receive/checkgap', method: 'get', data: params)
+                return JSON.parse(response)
+            end
+
+        end
+
+		def self.receive(xpub, callback, api_key)
+            Blockchain::V2::Receive.new.proxy(__method__, xpub, callback, api_key)
+		end
+
+		def self.callback_log(callback, api_key = nil)
+            Blockchain::V2::Receive.new.proxy(__method__, callback, api_key)
+		end
+
+        class ReceiveResponse
 			attr_reader :address
 			attr_reader :index
 			attr_reader :callback_url
@@ -44,30 +94,6 @@ module Blockchain
 				@response_code = response_code
 			end
 		end
-
-		def self.receive(xpub, callback, api_key)
-			params = { 'xpub' => xpub, 'callback' => callback, 'key' => api_key }
-			resp = Blockchain::call_api('v2/receive', method: 'get', data: params, base_url: 'https://api.blockchain.info/')
-			json_resp = JSON.parse(resp)
-			receive_response = ReceiveResponse.new(json_resp['address'],
-													json_resp['index'],
-													json_resp['callback'])
-			receive_response
-		end
-
-		def self.callback_log(callback, api_key = nil)
-			params = {'callback' => callback }
-			params['key'] = api_key unless api_key.nil?
-			resp = Blockchain::call_api('v2/receive/callback_log', method: 'get', data: params, base_url: 'https://api.blockchain.info/')
-			json_resp = JSON.parse(resp)
-			receive_response = json_resp.map do |entry|
-				LogEntry.new(entry['callback'],
-							entry['called_at'],
-							entry['raw_response'],
-							entry['response_code'])
-			end
-			receive_response
-		end
 	end
 
 

data/lib/blockchain/statistics.rb

@@ -1,38 +1,74 @@
 require 'json'
-require_relative 'util'
+require_relative 'client'
 
 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)
+    class StatisticsExplorer
+
+        attr_reader :client
+
+        def initialize(base_url = nil, api_code = nil)
+            @client = Client.new(base_url, api_code)
+        end
+
+        def proxy(method_name, *args)
+            warn "[DEPRECATED] avoid use of static methods, use an instance of StatisticsExplorer class instead."
+            send(method_name, *args)
+        end
+
+        def get_statistics()
+            params = { 'format' => 'json' }
+            resource = 'stats'
+            response = @client.call_api(resource, method: 'get', data: params)
+            return StatisticsResponse.new(JSON.parse(response))
+        end
+
+        def get_chart(chart_type, timespan = nil, rolling_average = nil)
+            params = { 'format' => 'json' }
+            if !timespan.nil? then params['timespan'] = timespan end
+            if !rolling_average.nil? then params['rollingAverage'] = rolling_average end
+            resource = 'charts/' + chart_type
+            response = @client.call_api(resource, method: 'get', data: params)
+            return ChartResponse.new(JSON.parse(response))
+        end
+
+        def get_pools(timespan = 4)
+            if timespan < 1 || timespan > 10
+                raise ArgumentError, 'timespan must be between 1 and 10'
+            end
+            params = { 'format' => 'json', 'timespan' => timespan.to_s + 'days' }
+            resource = 'pools'
+            response = @client.call_api(resource, method: 'get', data: params)
+            return JSON.parse(response)
+        end
+    end
+
+	def self.get(api_code = nil)
+        Blockchain::StatisticsExplorer.new(nil, api_code).proxy('get_statistics')
 	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 :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
-		
+        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 :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']
@@ -56,5 +92,30 @@ module Blockchain
 			@market_price_usd = s['market_price_usd']
 		end
 	end
-	
+
+    class ChartResponse
+        attr_reader :chart_name
+        attr_reader :unit
+        attr_reader :timespan
+        attr_reader :description
+        attr_reader :values
+
+        def initialize(cr)
+            @chart_name = cr['name']
+            @unit = cr['unit']
+            @timespan = cr['period']
+            @description = cr['description']
+            @values = cr['values'].map{ |value| ChartValue.new(value) }
+        end
+    end
+
+    class ChartValue
+        attr_reader :x
+        attr_reader :y
+
+        def initialize(cv)
+            @x = cv['x']
+            @y = cv['y']
+        end
+    end
 end

data/lib/blockchain/version.rb

@@ -1,3 +1,3 @@
 module Blockchain
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

data/lib/blockchain/wallet.rb

@@ -1,27 +1,32 @@
 require 'json'
-require_relative 'util'
+require_relative 'client'
 
 module Blockchain
 
 	class Wallet
 
-		def initialize(identifier, password, url, second_password = nil, api_code = nil)
-			@identifier = identifier
+        attr_reader :client
+
+		def initialize(identifier, password, url = 'http://localhost:3000/', second_password = nil, api_code = nil)
+            @client = Client.new(url, api_code)
+            @identifier = identifier
 			@password = password
 			@second_password = second_password
-			@api_code = api_code
-			@url = url
 		end
-		
-		def send(to, amount, from_address: nil, fee: nil, note: nil)
+
+		def send(to, amount, from_address: nil, fee: nil)
 			recipient = { to => amount }
-			return send_many(recipient, from_address: from_address, fee: fee, note: note)
+			return send_many(recipient, from_address: from_address, fee: fee)
 		end
-		
-		def send_many(recipients, from_address: nil, fee: nil, note: nil)
+
+		def send_many(recipients, from_address: nil, fee: nil)
 			params = build_basic_request()
 			method = ''
-			
+
+            if recipients.nil? || recipients.size == 0
+                raise ArgumentError, 'Sending bitcoin from your wallet requires at least one receipient'
+            end
+
 			if recipients.size == 1
 				params['to'] = recipients.keys[0]
 				params['amount'] = recipients.values[0]
@@ -30,37 +35,33 @@ module Blockchain
 				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, base_url: @url)
+
+			response = @client.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())
+			response = @client.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)
+
+		def list_addresses()
 			params = build_basic_request()
-			params['confirmations'] = confirmations
-			response = Blockchain::call_api("merchant/#{@identifier}/list", method: 'get', data: params)
+			response = @client.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'],
@@ -71,57 +72,53 @@ module Blockchain
 			end
 			return addresses
 		end
-		
-		def get_address(address, confirmations = 0)
+
+		def get_address(address)
 			params = build_basic_request()
 			params['address'] = address
-			params['confirmations'] = confirmations
-			response = Blockchain::call_api("merchant/#{@identifier}/address_balance", method: 'get', data: params)
+			response = @client.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)
+			response = @client.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)
+			response = @client.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)
+			response = @client.call_api("merchant/#{@identifier}/unarchive_address", method: 'post', data: params)
 			json_response = parse_json(response)
 			return json_response['active']
 		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)
@@ -136,7 +133,7 @@ module Blockchain
 		attr_reader :address
 		attr_reader :label
 		attr_reader :total_received
-		
+
 		def initialize(balance, address, label, total_received)
 			@balance = balance
 			@address = address
@@ -149,12 +146,12 @@ module Blockchain
 		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