blockcypher-ruby 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dfbc37a64ab4a52a21b42e53205f82a3e714ec6b
-  data.tar.gz: 90369729738d15f05be790985b558d8d0684ea4a
+SHA256:
+  metadata.gz: d4d54eab1d965239db06020543ac99c61dd1e3779b83d7f74f640e06a96ab728
+  data.tar.gz: 560ff7e2e88f1dd61d494f89925c5f04e76bba825e959b4a8d3a182a094b0b0c
 SHA512:
-  metadata.gz: c8eb9097474353ca1ab9918880cb1e02f406753af16717f26b3b20b8e2b578d8b901d534e9f079bdada946115355d6d5a77723ca7be091d442504d23cc421a98
-  data.tar.gz: 5f48d97c217b03ebb401b52f3d06aba9a248625a05631d3f650e0c87731f540adee7dca47b5f466e9dd73d9ba2f51b8a50e9ab9a8d39ce3562b897c0f65e425b
+  metadata.gz: 3c64b0ca05d8c0cd0ffec4b3805c3abc8b7010439de254d39dabb3fe74595782737b35e8326bbead96aee04c49167f2c9293e699b013adacfb895d2d1f25a6d2
+  data.tar.gz: a84fc2cb516483d768076731cf4dc0e89258e3946bdb065e6783b4e8fc9f3aa9e0d630a290c83458e14f41983a90801b768c2bf15b8aa275de18bece43cff1be

data/README.md

@@ -13,7 +13,7 @@ Simply using rubygems:
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'blockcypher-ruby', '~> 0.2.4', :require => 'blockcypher'
+gem 'blockcypher-ruby', '~> 0.2.5'
 ```
 
 And then execute:
@@ -29,7 +29,7 @@ $ git clone https://github.com/blockcypher/ruby-client.git
 $ cd ruby-client
 $ bundle
 $ gem build blockcypher-ruby.gemspec
-$ gem install blockcypher-ruby-0.2.4.gem
+$ gem install blockcypher-ruby-0.2.5.gem
 ```
 
 ## Initializing a client
@@ -42,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-ruby.rb

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

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
 
@@ -58,7 +59,7 @@ module BlockCypher
     ##################
 
     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)
@@ -174,23 +172,23 @@ 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, limit: 50,
                         before: nil, after: nil, confirmations: nil,
-												omit_wallet_addresses: false, include_confidence:false)
+                        omit_wallet_addresses: false, include_confidence: false)
       query = {
         unspentOnly: unspent_only,
         limit: limit,
         omitWalletAddresses: omit_wallet_addresses,
-				includeConfidence: include_confidence
+        includeConfidence: include_confidence
       }
       query[:before] = before if before
-			query[:after] = after if after
+      query[:after] = after if after
 
-      api_http_get('/addrs/' + address, query: query )
+      api_http_get('/addrs/' + address, query: query)
     end
 
     def address_balance(address, omit_wallet_addresses: false)
@@ -204,13 +202,13 @@ module BlockCypher
       details['final_balance']
     end
 
-    def address_full_txs(address, limit: 10, before: nil, after: nil, 
-												 include_hex: false, omit_wallet_addresses: false, include_confidence:false)
+    def address_full_txs(address, limit: 10, before: nil, after: nil,
+                         include_hex: false, omit_wallet_addresses: false, include_confidence: false)
       query = {
         limit: limit,
         includeHex: include_hex,
         omitWalletAddresses: omit_wallet_addresses,
-				includeConfidence: include_confidence
+        includeConfidence: include_confidence
       }
       query[:before] = before if before
       query[:after] = after if after
@@ -223,7 +221,7 @@ module BlockCypher
     ##################
 
     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
 
@@ -243,8 +241,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)
@@ -259,15 +257,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
 
@@ -287,23 +282,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
@@ -312,7 +345,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
@@ -332,19 +365,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/spec/blockcypher/api_spec.rb

@@ -1,47 +1,48 @@
-require 'blockcypher'
+# frozen_string_literal: true
 
-module BlockCypher
+require 'spec_helper'
 
-  describe Api do
+module BlockCypher
+  describe Api, vcr: { record: :once } do
     let(:api) do
       BlockCypher::Api.new({
-        api_token: 'testtoken',
-        currency: BlockCypher::BCY,
-        network: BlockCypher::TEST_NET,
-        version: BlockCypher::V1
-      })
+                             api_token: CONFIG[:api_token],
+                             currency: BlockCypher::BCY,
+                             network: BlockCypher::TEST_NET,
+                             version: BlockCypher::V1
+                           })
     end
 
-		context '#address_generate' do
-			it 'should generate new addresses' do
-				$addr1 = api.address_generate
-				$addr2 = api.address_generate
-				expect($addr1["address"]).to be_a(String)
-				expect($addr2["address"]).to be_a(String)
-			end
-		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
 
-    let(:address_1) { $addr1["address"].to_s }
-    let(:address_1_private_key) { $addr1["private"].to_s }
+    let(:address_1) { addr1['address'].to_s }
+    let(:address_1_private_key) { addr1['private'].to_s }
 
-    let(:address_2) { $addr2["address"].to_s }
-    let(:address_2_private_key) { $addr2["private"].to_s }
+    let(:address_2) { addr2['address'].to_s }
+    let(:address_2_private_key) { addr2['private'].to_s }
 
-		context '#faucet' do
-			it 'should fund a bcy test address with the faucet' do
-				res = api.faucet(address_1, 100000)
-				expect(res["tx_ref"]).to be_a(String)
-			end
-		end
+    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
 
@@ -49,12 +50,12 @@ module BlockCypher
       it 'should call txs/send api' do
         input_addresses = [address_1]
         output_addresses = [address_2]
-        satoshi_value = 10000
+        satoshi_value = 10_000
 
         new_tx = api.transaction_new(input_addresses, output_addresses, satoshi_value)
         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)
+        expect(res['tx']['hash']).to be_a(String)
+        expect(res['tx']['hash'].length).to be(64)
       end
     end
 
@@ -67,47 +68,44 @@ module BlockCypher
     end
 
     context '#create_forwarding_address' do
-
       it 'creates a payment forward' do
         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' do
-        forward_details = api.create_forwarding_address(address_1, 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
+        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, 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)
-        expect(forward_details["input_address"]).to be_a(String)
+        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
-        expect(forwarding_addresses.first["destination"]).to eql(address_1)
+        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
+    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
       it 'should encode query into URI' do
@@ -122,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