blockcypher-ruby 0.2.0 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7745506061c201b5a82f943b2dadec2759f82a88
-  data.tar.gz: fb35dcbc2e31dbf1c3433f41d442413b9cb79a62
+SHA256:
+  metadata.gz: d57bd644ca20b09669708df8ad9ee6bfde407b3ad96ea35a1b92d1fe3e6bb4a7
+  data.tar.gz: 74ea376dd072dddb1f795f625df8d7be4dcbe3163ef933adab48db7a99724d37
 SHA512:
-  metadata.gz: 1ce6d7b7f4d59c3080e77d952e0bf5ff59c1674d9d3f833c749f6d20058f0dbe0e2080fbee7864e8a75a77f17d0fd1a8e1ea5747576a47fc4127216e6edc1da2
-  data.tar.gz: a3a07c71551edd6f81a4f94ad3017fb540b7cb14eefd2e182a33330ce530a92b2cec39b1346dce0b9fc2b53bc5b79ab6fdc1f9480a9d71cb83c7c5b4de12c714
+  metadata.gz: f58122d38a6b058b77e27a71ff6f31e2b36eba7207d2f53aa5ca843c82968f3bae2c7ff85bdf63ce28a3dbbdfe5443db8ebfb7926fe6c5774f149185db2391c5
+  data.tar.gz: 8b4c1951d6a66682a45c870c1961296fb4cabdea7e92b9633e4cc764fd152534b3e3019e4942ad53812e2097a37ff06adda382e20a47d72890298229fdac2d08

data/README.md

@@ -6,7 +6,31 @@ Simple Ruby client for the [BlockCypher](http://www.blockcypher.com) API.
 
 Simply using rubygems:
 
-  gem install blockcypher-ruby
+    gem install blockcypher-ruby
+
+### For Rails apps
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'blockcypher-ruby', '~> 0.2.7'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ git clone https://github.com/blockcypher/ruby-client.git
+$ cd ruby-client
+$ bundle
+$ gem build blockcypher-ruby.gemspec
+$ gem install blockcypher-ruby-0.2.7.gem
+```
 
 ## Initializing a client
 
@@ -18,7 +42,12 @@ If you want to use BTC on the main net, which is normally what you want to do, i
 
 For more information check the API docs at:
 
-http://dev.blockcypher.com
+https://www.blockcypher.com/dev/bitcoin
+
+## Development
+
+- Copy `spec/config.yml.sample` to `spec/config.yml` and put your test API token
+- `rspec spec`
 
 ## Contributors
 

data/lib/blockcypher/api.rb

@@ -1,19 +1,20 @@
-module BlockCypher
+# frozen_string_literal: true
 
+module BlockCypher
   V1 = 'v1'
 
   BTC = 'btc'
   LTC = 'ltc'
   DOGE = 'doge'
-  BCY= 'bcy'
+  BCY = 'bcy'
+  ETH = 'eth'
 
   MAIN_NET = 'main'
   TEST_NET = 'test'
   TEST_NET_3 = 'test3'
 
   class Api
-
-    class Error < RuntimeError ; end
+    class Error < RuntimeError; end
 
     attr_reader :api_token
 
@@ -32,8 +33,8 @@ module BlockCypher
       api_http_get('/txs')
     end
 
-    def blockchain_transaction(transaction_hash)
-      api_http_get('/txs/' + transaction_hash)
+    def blockchain_transaction(transaction_hash, **params)
+      api_http_get('/txs/' + transaction_hash, query: params)
     end
 
     def blockchain_block(block_index, params)
@@ -56,9 +57,9 @@ module BlockCypher
     ##################
     # Transaction API
     ##################
-    
+
     def decode_hex(hex)
-      payload = { 'tx' => hex}
+      payload = { 'tx' => hex }
       api_http_post('/txs/decode', json_payload: payload)
     end
 
@@ -68,10 +69,7 @@ module BlockCypher
     end
 
     def send_money(from_address, to_address, satoshi_amount, private_key)
-
-      unless to_address.kind_of? Array
-        to_address = [to_address]
-      end
+      to_address = [to_address] unless to_address.is_a? Array
 
       tx_new = transaction_new([from_address], to_address, satoshi_amount)
 
@@ -114,13 +112,13 @@ module BlockCypher
       signatures = []
 
       tosign.each do |to_sign_hex|
-        to_sign_binary = [to_sign_hex].pack("H*")
+        to_sign_binary = [to_sign_hex].pack('H*')
         sig_binary = key.sign(to_sign_binary)
-        sig_hex = sig_binary.unpack("H*").first
+        sig_hex = sig_binary.unpack1('H*')
         signatures << sig_hex
       end
 
-      return signatures
+      signatures
     end
 
     def transaction_new_custom(payload)
@@ -140,8 +138,8 @@ module BlockCypher
 
     ##################
     # Microtx API
-    ##################  
-    
+    ##################
+
     # This method sends private key to server
     def microtx_from_priv(private_key, to_address, value_satoshis)
       payload = {
@@ -174,33 +172,58 @@ module BlockCypher
     end
 
     def address_generate_multi(pubkeys, script_type)
-      payload = { 'pubkeys' => pubkeys, 'script_type' => script_type}
+      payload = { 'pubkeys' => pubkeys, 'script_type' => script_type }
       api_http_post('/addrs', json_payload: payload)
     end
 
-    def address_details(address, unspent_only: false)
-      api_http_get('/addrs/' + address, query: { unspentOnly: unspent_only } )
+    def address_details(address, unspent_only: false, limit: 50,
+                        before: nil, after: nil, confirmations: nil,
+                        omit_wallet_addresses: false, include_confidence: false)
+      query = {
+        unspentOnly: unspent_only,
+        limit: limit,
+        omitWalletAddresses: omit_wallet_addresses,
+        includeConfidence: include_confidence
+      }
+      query[:before] = before if before
+      query[:after] = after if after
+
+      api_http_get('/addrs/' + address, query: query)
     end
 
-    def address_balance(address)
-      api_http_get('/addrs/' + address + '/balance')
+    def address_balance(address, omit_wallet_addresses: false)
+      query = { omitWalletAddresses: omit_wallet_addresses }
+      api_http_get('/addrs/' + address + '/balance', query: query)
     end
 
-    def address_final_balance(address)
-      details = address_balance(address)
+    def address_final_balance(address, omit_wallet_addresses: false)
+      details = address_balance(address,
+                                omit_wallet_addresses: omit_wallet_addresses)
       details['final_balance']
     end
 
-    def address_full_txs(address, limit: 10)
-      api_http_get("/addrs/#{address}/full", query: { limit: limit })
+    def address_full_txs(address, limit: 10, before: nil, after: nil,
+                         include_hex: false, omit_wallet_addresses: false,
+                         include_confidence: false, txlimit: 20)
+      query = {
+        limit: limit,
+        includeHex: include_hex,
+        omitWalletAddresses: omit_wallet_addresses,
+        includeConfidence: include_confidence,
+        txlimit: txlimit
+      }
+      query[:before] = before if before
+      query[:after] = after if after
+
+      api_http_get("/addrs/#{address}/full", query: query)
     end
 
     ##################
     # Wallet API
     ##################
-    
+
     def wallet_create(name, addresses)
-      payload = { 'name' => name, 'addresses' => Array(addresses)}
+      payload = { 'name' => name, 'addresses' => Array(addresses) }
       api_http_post('/wallets', json_payload: payload)
     end
 
@@ -208,9 +231,11 @@ module BlockCypher
       api_http_get('/wallets/' + name)
     end
 
-    def wallet_add_addr(name, addresses)
-      payload = { 'addresses' => Array(addresses)}
-      api_http_post('/wallets/' + name + '/addresses', json_payload: payload)
+    def wallet_add_addr(name, addresses, omit_wallet_addresses: false)
+      payload = { 'addresses' => Array(addresses) }
+      query = { omitWalletAddresses: omit_wallet_addresses }
+      api_http_post('/wallets/' + name + '/addresses',
+                    json_payload: payload, query: query)
     end
 
     def wallet_get_addr(name)
@@ -218,8 +243,8 @@ module BlockCypher
     end
 
     def wallet_delete_addr(name, addresses)
-      addrjoin = addresses.join(";")
-      api_http_delete('/wallets/' + name + '/addresses', query: { address: addrjoin})
+      addrjoin = addresses.join(';')
+      api_http_delete('/wallets/' + name + '/addresses', query: { address: addrjoin })
     end
 
     def wallet_gen_addr(name)
@@ -234,15 +259,12 @@ module BlockCypher
     # Events API
     ##################
 
-    def event_webhook_subscribe(url, event, confirmations: nil, hash:nil, address:nil, script:nil)
+    def event_webhook_subscribe(url, event, options = {})
       payload = {
         url: url,
-        event: event,
-      }
-      payload[:address] = address if address
-      payload[:hash] = hash if hash
-      payload[:script] = script if script
-      payload[:confirmations] = confirmations if confirmations
+        event: event
+      }.merge(options)
+
       api_http_post('/hooks', json_payload: payload)
     end
 
@@ -262,23 +284,61 @@ module BlockCypher
     # Payments and Forwarding API
     ##################
 
-    def create_forwarding_address(destination, callback_url: nil, enable_confirmations: false)
+    def create_forwarding_address(
+      destination,
+      callback_url: nil,
+      enable_confirmations: false,
+      mining_fees_satoshis: nil
+    )
       payload = {
         destination: destination,
         callback_url: callback_url,
-        enable_confirmations: enable_confirmations
+        enable_confirmations: enable_confirmations,
+        mining_fees_satoshis: mining_fees_satoshis
       }
       api_http_post('/payments', json_payload: payload)
     end
 
-    alias :create_payments_forwarding :create_forwarding_address
+    alias create_payments_forwarding create_forwarding_address
 
     def list_forwarding_addresses
-      api_http_get("/payments")
+      api_http_get('/payments')
     end
 
     def delete_forwarding_address(id)
-      api_http_delete("/payments/" + id)
+      api_http_delete('/payments/' + id)
+    end
+
+    #############
+    # Asset API #
+    #############
+
+    def generate_asset_address
+      api_http_post('/oap/addrs')
+    end
+
+    def issue_asset(from_private, to_address, amount)
+      api_http_post('/oap/issue', json_payload: {
+                      from_private: from_private,
+                      to_address: to_address,
+                      amount: amount
+                    })
+    end
+
+    def transfer_asset(asset_id, from_private, to_address, amount)
+      api_http_post("/oap/#{asset_id}/transfer", json_payload: {
+                      from_private: from_private,
+                      to_address: to_address,
+                      amount: amount
+                    })
+    end
+
+    def asset_txs(asset_id)
+      api_http_get("/oap/#{asset_id}/txs")
+    end
+
+    def asset_address(asset_id, oap_address)
+      api_http_get("/oap/#{asset_id}/addrs/#{oap_address}")
     end
 
     private
@@ -287,7 +347,7 @@ module BlockCypher
       uri = endpoint_uri(api_path, query)
 
       # Build the connection
-      http    = Net::HTTP.new(uri.host, uri.port)
+      http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
 
       # Build the Request
@@ -307,19 +367,20 @@ module BlockCypher
       end
 
       response = http.request(request)
+      response_code = response.code.to_i
 
       # Detect errors/return 204 empty body
-      if response.code == '400'
-        raise Error.new(uri.to_s + ' Response:' + response.body)
-      elsif response.code == '204'
+      if response_code >= 400
+        raise Error, uri.to_s + ' Response:' + response.body
+      elsif response_code == 204
         return nil
       end
 
       # Process the response
       begin
         json_response = JSON.parse(response.body)
-        return json_response
-      rescue => e
+        json_response
+      rescue StandardError => e
         raise "Unable to parse JSON response #{e.inspect}, #{response.body}"
       end
     end

data/lib/blockcypher-ruby.rb

@@ -0,0 +1 @@
+require 'blockcypher'

data/spec/blockcypher/api_spec.rb

@@ -1,88 +1,110 @@
-require 'blockcypher'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 module BlockCypher
+  describe Api, vcr: { record: :once } do
+    let(:api) do
+      BlockCypher::Api.new({
+                             api_token: CONFIG[:api_token],
+                             currency: BlockCypher::BCY,
+                             network: BlockCypher::TEST_NET,
+                             version: BlockCypher::V1
+                           })
+    end
+
+    let(:addr1) { api.address_generate }
+    let(:addr2) { api.address_generate }
+    context '#address_generate' do
+      it 'should generate new addresses' do
+        expect(addr1['address']).to be_a(String)
+        expect(addr2['address']).to be_a(String)
+      end
+    end
 
-  describe Api do
-    let(:api) { BlockCypher::Api.new(currency: BlockCypher::BTC, network: BlockCypher::TEST_NET_3, version: BlockCypher::V1) }
+    let(:address_1) { addr1['address'].to_s }
+    let(:address_1_private_key) { addr1['private'].to_s }
 
-    let(:address_1) { 'miB9s4fcYCEBxPQm8vw6UrsYc2iSiEW3Yn' }
-    let(:address_1_private_key) { 'f2a73451a726e81aec76a2bfd5a4393a89822b30cc4cddb2b4317efb2266ad47' }
+    let(:address_2) { addr2['address'].to_s }
+    let(:address_2_private_key) { addr2['private'].to_s }
 
-    let(:address_2) { 'mnTBb2Fd13pKwNjFQz9LVoy2bqmDugLM5m' }
-    let(:address_2_private_key) { '76a32c1e5b6f9e174719e7c1b555d6a55674fdc2fd99cfeee96a5de632775645' }
+    context '#faucet' do
+      it 'should fund a bcy test address with the faucet' do
+        res = api.faucet(address_1, 100_000)
+        expect(res['tx_ref']).to be_a(String)
+      end
+    end
 
     context '#transaction_new' do
-
       it 'should call the txs/new api' do
         input_addresses = [address_1]
         output_addresses = [address_2]
-        satoshi_value = 20000
+        satoshi_value = 20_000
         res = api.transaction_new(input_addresses, output_addresses, satoshi_value)
-        expect(res["tx"]["hash"]).to be_a(String)
-        expect(res["tx"]["hash"].length).to be(64)
+        expect(res['tx']['hash']).to be_a(String)
+        expect(res['tx']['hash'].length).to be(64)
       end
     end
 
     context '#transaction_sign_and_send' do
-
       it 'should call txs/send api' do
-
-        input_addresses = [address_2]
-        output_addresses = [address_1]
-        satoshi_value = 10000
+        input_addresses = [address_1]
+        output_addresses = [address_2]
+        satoshi_value = 10_000
 
         new_tx = api.transaction_new(input_addresses, output_addresses, satoshi_value)
-        res = api.transaction_sign_and_send(new_tx, address_2_private_key)
-        expect(res["tx"]["hash"]).to be_a(String)
-        expect(res["tx"]["hash"].length).to be(64)
+        res = api.transaction_sign_and_send(new_tx, address_1_private_key)
+        expect(res['tx']['hash']).to be_a(String)
+        expect(res['tx']['hash'].length).to be(64)
       end
-
     end
 
     context '#address_final_balance' do
-
       it 'should get the balance of an address' do
         balance = api.address_final_balance(address_1)
         expect(balance).to be_kind_of Integer
         expect(balance).to be > 0
       end
-
     end
 
     context '#create_forwarding_address' do
-
       it 'creates a payment forward' do
-        forward_details = api.create_forwarding_address(address_1, "foo")
-        expect(forward_details["input_address"]).to be_a(String)
-        expect(forward_details["input_address"].length).to be(34) # Ok this isn't strictly true but..
-      end
-
-      it 'allows creating a payment forward with a callback' do
-        forward_details = api.create_forwarding_address(address_1, "foo", callback_url: "http://test.com/foo")
-        expect(forward_details["callback_url"]).to eql("http://test.com/foo")
-        expect(forward_details["enable_confirmations"]).to be nil
+        forward_details = api.create_forwarding_address(address_1)
+        expect(forward_details['input_address']).to be_a(String)
+        expect(forward_details['input_address'].length).to be(34) # Ok this isn't strictly true but..
       end
 
-      it 'allows creating a payment forward with a callback and confirmation notifications enabled' do
-        forward_details = api.create_forwarding_address(address_1, "foo", callback_url: "http://test.com/foo", enable_confirmations: true)
-        expect(forward_details["callback_url"]).to eql("http://test.com/foo")
-        expect(forward_details["enable_confirmations"]).to be true
+      it 'allows creating a payment forward with options' do
+        forward_details = api.create_forwarding_address(address_1, {
+                                                          callback_url: 'http://test.com/foo',
+                                                          enable_confirmations: true,
+                                                          mining_fees_satoshis: 20_000
+                                                        })
+        expect(forward_details['callback_url']).to eql('http://test.com/foo')
+        expect(forward_details['enable_confirmations']).to be true
+        expect(forward_details['mining_fees_satoshis']).to be 20_000
       end
 
       it 'is possible to use the alias create_payments_forwarding' do
-        forward_details = api.create_payments_forwarding(address_1, "foo")
-        expect(forward_details["input_address"]).to be_a(String)
+        forward_details = api.create_payments_forwarding(address_1)
+        expect(forward_details['input_address']).to be_a(String)
       end
-
     end
 
     context '#list_forwarding_addresses' do
-
       it 'lists all forwading addresses created for a given token' do
-        forwarding_addresses = api.list_forwarding_addresses("foo")
-        expect(forwarding_addresses.first["destination"]).to eql(address_1)
+        forwarding_addresses = api.list_forwarding_addresses
+        expect(forwarding_addresses.first['destination']).to eql(address_1)
       end
+    end
 
+    context '#delete_forwarding_address' do
+      it 'deletes all previously created forwarding addresses' do
+        forwarding_addresses = api.list_forwarding_addresses
+        forwarding_addresses.each { |x| api.delete_forwarding_address(x['id']) }
+        forwarding_addresses = api.list_forwarding_addresses
+        expect(forwarding_addresses.any? == false)
+      end
     end
 
     describe '#endpoint_uri' do
@@ -98,6 +120,51 @@ module BlockCypher
       end
     end
 
-  end
+    describe 'Asset API' do
+      describe 'Generate Asset Address' do
+        it 'should include private, public, oap_address, original_address hashes' do
+          res = api.generate_asset_address
+          expect(res).to include('private', 'public', 'oap_address', 'original_address')
+        end
+      end
+
+      describe 'Issue Asset' do
+        it 'should issue asset' do
+          asset_address = api.generate_asset_address
+          api.faucet(asset_address['original_address'], 1_000_000)
+          res = api.issue_asset(asset_address['private'], asset_address['oap_address'], 1000)
+
+          expect(res).to include(
+            'ver',
+            'assetid',
+            'oap_meta',
+            'hash',
+            'received',
+            'double_spend',
+            'inputs',
+            'outputs'
+          )
+        end
+      end
 
+      describe 'Asset Transfer' do
+        it 'should transfer asset' do
+          asset_address = api.generate_asset_address
+          asset_address_to = api.generate_asset_address
+          api.faucet(asset_address['original_address'], 100_000_000)
+          asset = api.issue_asset(asset_address['private'], asset_address['oap_address'], 1000)
+
+          puts 'waiting asset to been issued'
+          begin
+            printf('|')
+            check_address = api.asset_address(asset['assetid'], asset_address['oap_address'])
+            sleep(1)
+          end while check_address['n_tx'] == 0
+
+          res = api.transfer_asset(asset['assetid'], asset_address['private'], asset_address_to['oap_address'], 100)
+          expect(res).to include('assetid')
+        end
+      end
+    end
+  end
 end

data/spec/config.yml

@@ -0,0 +1,2 @@
+---
+api_token: aa5ced01083e7f6f0b3dc11e618379a9

data/spec/config.yml.sample

@@ -0,0 +1,2 @@
+---
+api_token: testtoken-changeme