block_io 0.1.3 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9263fda276a28feff2c874cbe26f0e305529a2d
-  data.tar.gz: 575708414988f13c9648fc9a9e958ef7d8929b3f
+  metadata.gz: 0a5c7f9ebfcf7f608010b2f742ebe7e2c44035ab
+  data.tar.gz: 29253bde1cdcf14f17c7000165ea00571936fef7
 SHA512:
-  metadata.gz: 635caea39d5a340b3d540e113f358e3c0dc4a5fa15221393f929b8fbeeeed0ff24a3c979d8cb57db8408f291acbaa0021edee33bdc6903084351d8c8378d48bf
-  data.tar.gz: 18d56b62b86b3d64590540f2e06e37a49a4d5c6d1cde441095e1c2783d38ff424a41d9e80583501342d35ced69301cf5943cc5ac37c28bcaefbc8f91e2db2fd9
+  metadata.gz: d999194b92fe5b45ba67ebb21a422f4e1796ffaadfe5a6bb57c0735486e9150339cc0c8638f1577e68fe1392047ba3e8773abea859d7ab26fc12574ca5dc655e
+  data.tar.gz: 0332287b974c9bab30ed52f59031d0508b1e410be694c1bcb9b5363e459b1efbf74ebcd59443146f9f35bf8a7b38816926f68753532e26801340177afe9d3565

data/README.md

@@ -17,6 +17,8 @@ Or install it yourself as:
     $ gem install block_io
 
 ## Changelog
+
+*09/27/14*: Now supporting client-side signatures. API v2 recommended.
    
 *07/01/14*: Forcing TLSv1 usage since Block.io does not support SSLv3 due to its vulnerable nature. Fixed:
 	    HTTPClient.new.ssl_config.ssl_version = :TLSv1
@@ -27,18 +29,18 @@ Or install it yourself as:
 It's super easy to get started. In your Ruby shell ($ irb), for example, do this:
 
     require 'block_io'
-    BlockIo.set_options :api_key => 'API KEY', :pin => 'SECRET PIN'
+    BlockIo.set_options :api_key => 'API KEY', :pin => 'SECRET PIN', :version => 2
      
 And you're good to go:
 
     BlockIo.get_new_address
     BlockIo.get_my_addresses
 
-For more information, see https://block.io/api
+For more information, see https://block.io/api/simple/ruby
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/block_io/fork )
+1. Fork it ( https://github.com/BlockIo/gem-block-io/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/block_io.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["a@block.io"]
   spec.summary       = %q{An easy to use Dogecoin, Bitcoin, Litecoin wallet API by Block.io. Sign up required at Block.io.}
   spec.description   = %q{This Ruby Gem is the official reference client for the Block.io payments API. To use this, you will need the Dogecoin, Bitcoin, or Litecoin API key(s) from Block.io. Go ahead, sign up :)}
-  spec.homepage      = "https://block.io/api/ruby"
+  spec.homepage      = "https://block.io/api/simple/ruby"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 0"
+  spec.add_runtime_dependency "ecdsa", "~> 1.2", '>= 1.2.0'
   spec.add_runtime_dependency "httpclient", "~> 2.4", '>= 2.4.0'
   spec.add_runtime_dependency "json", "~> 1.8", '>= 1.8.1'
   spec.add_runtime_dependency "connection_pool", "~> 2.0", '>= 2.0.0'

data/examples/basic.rb

@@ -0,0 +1,22 @@
+# creates a new destination address, withdraws from the default label to it, gets sent transactions, and the current price
+
+require 'block_io'
+
+# please use the Dogecoin Testnet API key here
+puts BlockIo.set_options :api_key => 'YOURDOGECOINTESTNETAPIKEY', :pin => 'YOURSECRETPIN', :version => 2
+
+begin
+  puts BlockIo.get_new_address(:label => 'testDest')
+rescue Exception => e
+  # if this failed, we probably created testDest label before
+  puts e.to_s
+end
+
+puts BlockIo.withdraw_from_labels(:from_labels => 'default', :to_label => 'testDest', :amount => '3.5')
+
+puts BlockIo.get_address_by_label(:label => 'default')
+
+puts BlockIo.get_transactions(:type => 'sent') # API v2 only
+
+puts BlockIo.get_current_price(:base_price => 'BTC')
+

data/examples/dtrust.rb

@@ -0,0 +1,89 @@
+# creates a new destination address, withdraws from the default label to it, gets sent transactions, and the current price
+
+require 'block_io'
+
+# please use the Dogecoin Testnet API key here
+puts "*** Initialize BlockIo library: "
+puts JSON.pretty_generate(BlockIo.set_options :api_key => 'YourDogecoinTestnetAPIKey', :pin => 'YourSecretPIN', :version => 2)
+
+
+# create 4 keys
+keys = [ BlockIo::Key.from_passphrase('alpha1alpha2alpha3alpha4'), BlockIo::Key.from_passphrase('alpha4alpha1alpha2alpha3'), BlockIo::Key.from_passphrase('alpha3alpha4alpha1alpha2'), BlockIo::Key.from_passphrase('alpha2alpha3alpha4alpha1') ]
+
+dtrust_address = nil
+
+begin
+  # let's create a new address with all 4 keys as signers, but only 3 signers required (i.e., 4 of 5 multisig, with 1 signature being Block.io)
+
+  signers = ""
+  keys.each { |key| signers += ',' if signers.length > 0; signers += key.public_key; }
+
+  response = BlockIo.get_new_dtrust_address(:label => 'dTrust1', :public_keys => signers, :required_signatures => 3)
+
+  dtrust_address = response['data']['address']
+rescue Exception => e
+  # if this failed, we probably created the same label before. let's fetch the address then.
+  puts e.to_s
+  
+  response = BlockIo.get_dtrust_address_by_label(:label => 'dTrust1')
+  
+  dtrust_address = response['data']['address']
+end
+
+puts "*** Our dTrust Address: #{dtrust_address}"
+
+# let's deposit some coins into this new address
+response = BlockIo.withdraw_from_labels(:from_labels => 'default', :to_address => dtrust_address, :amount => '3.5')
+
+puts "*** Withdrawal response:"
+puts JSON.pretty_generate(response)
+
+
+# fetch the dtrust address' balance
+puts "*** dTrust1 Balance:"
+puts JSON.pretty_generate(BlockIo.get_dtrust_address_balance(:label => 'dTrust1'))
+
+# withdraw a few coins from dtrust1 to the default label
+normal_address = BlockIo.get_address_by_label(:label => 'default')['data']['address']
+
+puts "*** Withdrawing from dTrust1 to the 'default' label in normal multisig"
+
+response = BlockIo.withdraw_from_dtrust_address(:from_labels => 'dTrust1', :to_addresses => normal_address, :amounts => '2.1')
+
+puts JSON.pretty_generate(response)
+
+# let's sign for the public keys specified
+
+response['data']['inputs'].each do |input|
+  # for each input
+
+  data_to_sign = input['data_to_sign']
+
+  input['signers'].each do |signer|
+
+    # figure out if we have the public key that matches this signer
+    
+    keys.each do |key|
+      # iterate over all keys till we've found the one that we need
+
+      signer['signed_data'] = key.sign(data_to_sign) if key.public_key == signer['signer_public_key']
+
+    end
+
+  end
+
+end
+
+puts "*** Our signed response: "
+puts JSON.pretty_generate(response['data']) #.to_json
+
+# let's final the withdrawal
+puts "*** Finalize withdrawal: "
+puts JSON.pretty_generate(BlockIo.sign_and_finalize_withdrawal(:signature_data => response['data'].to_json))
+
+# get the sent transactions for this dTrust address
+
+puts "*** Get transactions sent by our dTrust1 address: "
+
+puts JSON.pretty_generate(BlockIo.get_dtrust_transactions(:type => 'sent', :labels => 'dTrust1'))
+

data/lib/block_io.rb

@@ -1,204 +1,245 @@
-require "block_io/version"
+require 'block_io/version'
 require 'httpclient'
 require 'json'
 require 'connection_pool'
+require 'ecdsa'
+require 'openssl'
+require 'digest'
+require 'securerandom'
+require 'base64'
 
 module BlockIo
 
   @api_key = nil
-  @base_url = "https://block.io/api/v1/API_CALL/?api_key="
+  @base_url = "https://block.io/api/VERSION/API_CALL/?api_key="
   @pin = nil
+  @encryptionKey = nil
   @conn_pool = nil
+  @version = nil
 
   def self.set_options(args = {})
     # initialize BlockIo
     @api_key = args[:api_key]
     @pin = args[:pin]
-    @conn_pool = ConnectionPool.new(size: 5, timeout: 300) { HTTPClient.new }
+    @encryptionKey = Helper.pinToAesKey(@pin) if !@pin.nil?
 
+    @conn_pool = ConnectionPool.new(size: 5, timeout: 300) { HTTPClient.new }
+    
+    @version = args[:version] || 2 # default version is 2
+    
     self.api_call(['get_balance',""])
   end
 
-  def self.get_offline_vault_balance
-    # returns the offline vault's balance
-    endpoint = ["get_offline_vault_balance",""]
-    self.api_call(endpoint)
-  end
-
-  def self.get_offline_vault_address
-    # returns the offline vault's address and balance info
-    self.get_offline_vault_balance
-  end
-
-  def self.get_balance
-    # returns the balances for your account tied to the API key
-    endpoint = ["get_balance", ""] 
-    self.api_call(endpoint)
-  end
-
-  def self.get_user_balance(args)
-    # returns the specified user's balance
-    
-    user_id = args[:user_id]
+  def self.method_missing(m, *args, &block)      
 
-    raise Exception.new("Must provide user_id") if user_id.nil?
+    method_name = m.to_s
 
-    endpoint = ['get_user_balance',"&user_id=#{user_id}"]
+    if ['withdraw', 'withdraw_from_address', 'withdraw_from_addresses', 'withdraw_from_user', 'withdraw_from_users', 'withdraw_from_label', 'withdraw_from_labels'].include?(m.to_s) then
 
-    self.api_call(endpoint)
-  end
+      self.withdraw(args.first, m.to_s)
 
-  def self.get_address_balance(args)
-    # returns the specified address or address_label's balance
+    else
+      params = get_params(args.first)
+      self.api_call([method_name, params])
+    end
     
-    address = args[:address]
-    address_label = args[:address_label]
-
-    raise Exception.new("Must provide ONE of address or address_label") if (!address.nil? and !address_label.nil?) or (address.nil? and address_label.nil?)
-
-    endpoint = ['get_address_balance',"&address=#{address}"] unless address.nil?
-    endpoint = ['get_address_balance',"&address_label=#{address_label}"] unless address_label.nil?
+  end 
 
-    self.api_call(endpoint)
-  end
-
-  def self.get_current_price(args = {})
-    # returns prices from different exchanges as an array of hashes
-    price_base = args[:price_base]
-
-    endpoint = ['get_current_price', '']
-    endpoint = ['get_current_price',"&price_base=#{price_base}"] unless price_base.nil? or price_base.to_s.length == 0
+  def self.withdraw(args = {}, method_name = 'withdraw')
+    # validate arguments for withdrawal of funds TODO
 
-    self.api_call(endpoint)
-  end
+    raise Exception.new("PIN not set. Use BlockIo.set_options(:api_key=>'API KEY',:pin=>'SECRET PIN',:version=>'API VERSION')") if @pin.nil?
 
-  def self.withdraw_from_user(args = {})
-    # withdraws coins from the given user(s)
-    self.withdraw(args)
-  end
+    params = get_params(args)
 
-  def self.withdraw(args = {})
-    # validate arguments for withdrawal of funds TODO
+    params += "&pin=#{@pin}" if @version == 1 # Block.io handles the Secret PIN in the legacy API (v1)
 
-    raise Exception.new("PIN not set. Use BlockIo.set_options(:api_key=>'API KEY',:pin=>'SECRET PIN')") if @pin.nil?
+    response = self.api_call([method_name, params])
+    
+    if response['data'].has_key?('reference_id') then
+      # Block.io's asking us to provide some client-side signatures, let's get to it
 
-    # validate argument sets
-    amount = args[:amount]
-    to_user_id = args[:to_user_id]
-    payment_address = args[:payment_address]
-    from_user_ids = args[:from_user_ids] || args[:from_user_id]
+      # extract the passphrase
+      encrypted_passphrase = response['data']['encrypted_passphrase']['passphrase']
 
-    raise Exception.new("Must provide ONE of payment_address, or to_user_id") if (!to_user_id.nil? and !payment_address.nil?) or (to_user_id.nil? and payment_address.nil?)
-    raise Exception.new("Must provide amount to withdraw") if amount.nil?
+      # let's get our private key
+      key = Helper.extractKey(encrypted_passphrase, @encryptionKey)
 
-    endpoint = ['withdraw',"&amount=#{amount}&payment_address=#{payment_address}&pin=#{@pin}"] unless payment_address.nil?
-    endpoint = ['withdraw',"&amount=#{amount}&to_user_id=#{to_user_id}&pin=#{@pin}"] unless to_user_id.nil?
-    endpoint = ['withdraw',"&amount=#{amount}&from_user_ids=#{from_user_ids}&pin=#{@pin}&payment_address=#{payment_address}"] unless from_user_ids.nil? or payment_address.nil?
-    endpoint = ['withdraw',"&amount=#{amount}&from_user_ids=#{from_user_ids}&to_user_id=#{to_user_id}&pin=#{@pin}"] unless to_user_id.nil? or from_user_ids.nil?
+      raise Exception.new('Public key mismatch for requested signer and ourselves. Invalid Secret PIN detected.') if key.public_key != response['data']['encrypted_passphrase']['signer_public_key']
 
-    self.api_call(endpoint)
-  end
+      # let's sign all the inputs we can
+      inputs = response['data']['inputs']
 
-  def self.get_new_address(args = {})
-    # validate arguments for getting a new address
-    address_label = args[:address_label]
+      inputs.each do |input|
+        # iterate over all signers
+        
+        input['signers'].each do |signer|
+          # if our public key matches this signer's public key, sign the data
 
-    endpoint = ['get_new_address','']
-    endpoint = ["get_new_address","&address_label=#{address_label}"] unless address_label.nil?
+          signer['signed_data'] = key.sign(input['data_to_sign']) if signer['signer_public_key'] == key.public_key
 
-    self.api_call(endpoint)
-  end
+        end
+        
+      end
 
-  def self.create_user(args = {})
-    # validate arguments for getting a new address
-    address_label = args[:address_label]
+      # the response object is now signed, let's stringify it and finalize this withdrawal
 
-    endpoint = ['create_user','']
-    endpoint = ['create_user',"&address_label=#{address_label}"] unless address_label.nil?
+      response = self.api_call(['sign_and_finalize_withdrawal',{:signature_data => response['data'].to_json}])
 
-    self.api_call(endpoint)
-  end  
+      # if we provided all the required signatures, this transaction went through
+      # otherwise Block.io responded with data asking for more signatures
+      # the latter will be the case for dTrust addresses
+    end
 
-  def self.get_my_addresses(args = {})
-    # returns all the addresses in your account tied to the API key
-    endpoint = ["get_my_addresses",""]
+    return response
 
-    self.api_call(endpoint)
   end
 
-  def self.get_users(args = {})
-    # returns all the addresses in your account tied to the API key
-    endpoint = ['get_users',""]
-
-    self.api_call(endpoint)
-  end
 
-  def self.get_address_received(args = {})
-    # get coins received, confirmed and unconfirmed, by the given address, address_label, or user_id
-    address_label = args[:address_label]
-    user_id = args[:user_id]
-    address = args[:address]
+  private
+  
+  def self.api_call(endpoint)
 
-    raise Exception.new("Must provide ONE of address_label, user_id, or address") unless args.keys.length == 1 and (!address_label.nil? or !user_id.nil? or !address.nil?)
+    body = nil
 
-    endpoint = ['get_address_received','']
-    endpoint = ["get_address_received","&user_id=#{user_id}"] unless user_id.nil?
-    endpoint = ['get_address_received',"&address_label=#{address_label}"] unless address_label.nil?
-    endpoint = ['get_address_received',"&address=#{address}"] unless address.nil?
+    @conn_pool.with do |hc|
+      # prevent initiation of HTTPClients every time we make this call, use a connection_pool
 
-    self.api_call(endpoint)
+      hc.ssl_config.ssl_version = :TLSv1
+      response = hc.post("#{@base_url.gsub('API_CALL',endpoint[0]).gsub('VERSION', 'v'+@version.to_s) + @api_key}", endpoint[1])
+      
+      begin
+        body = JSON.parse(response.body)
+        raise Exception.new(body['data']['error_message']) if !body['status'].eql?('success')
+      rescue
+        raise Exception.new('Unknown error occurred. Please report this.')
+      end
+    end
+    
+    body
   end
 
-  def self.get_user_received(args = {})
-    # returns the user's received coins, confirmed and unconfirmed
-
-    user_id = args[:user_id]
+  private
 
-    raise Exception.new("Must provide user_id") if user_id.nil?
+  def self.get_params(args)
+    # construct the parameter string
+    params = ""
+    
+    args.each do |k,v|
+      params += '&' if params.length > 0
+      params += "#{k.to_s}=#{v.to_s}"
+    end
 
-    self.get_address_received(:user_id => user_id)
+    return params
   end
 
-  def self.get_address_by_label(args = {})
-    # get address by label
-
-    address_label = args[:address_label]
-
-    raise Exception.new("Must provide address_label") if address_label.nil?
-
-    endpoint = ["get_address_by_label","&address_label=#{address_label}"]
+  public
 
-    self.api_call(endpoint)
-  end
-
-  def self.get_user_address(args = {})
-    # gets the user's address
+  class Key
 
-    user_id = args[:user_id]
+    def initialize(privkey = nil)
+      # the privkey must be in hex if at all provided
 
-    raise Exception.new("Must provide user_id") if user_id.nil?
+      @group = ECDSA::Group::Secp256k1
+      @private_key = privkey.to_i(16) || 1 + SecureRandom.random_number(group.order - 1)
+      @public_key = @group.generator.multiply_by_scalar(@private_key)
 
-    endpoint = ['get_user_address',"&user_id=#{user_id}"]
+    end 
+    
+    def private_key
+      # returns private key in hex form
+      return @private_key.to_s(16)
+    end
+    
+    def public_key
+      # returns the compressed form of the public key to save network fees (shorter scripts)
 
-    self.api_call(endpoint)
-  end
+      return ECDSA::Format::PointOctetString.encode(@public_key, compression: true).unpack("H*")[0]
+    end
+    
+    def sign(data)
+      # signed the given hexadecimal string
 
-  private
+      nonce = 1 + SecureRandom.random_number(@group.order - 1) # nonce, can be made deterministic TODO
+      
+      signature = ECDSA.sign(@group, @private_key, [data].pack("H*"), nonce)
 
-  def self.api_call(endpoint)
+      # DER encode this, and return it in hex form
 
-    body = nil
+      return ECDSA::Format::SignatureDerString.encode(signature).unpack("H*")[0]
 
-    @conn_pool.with do |hc|
-      # prevent initiation of HTTPClients every time we make this call, use a connection_pool
+    end
+    
+    def self.from_passphrase(passphrase)
+      # create a private+public key pair from a given passphrase
+      # think of this as your brain wallet. be very sure to use a sufficiently long passphrase
+      # if you don't want a passphrase, just use Key.new and it will generate a random key for you
+      
+      raise Exception.new('Must provide passphrase at least 8 characters long.') if passphrase.nil? or passphrase.length < 8
+      
+      hashed_key = Helper.sha256([passphrase].pack("H*")) # must pass bytes to sha256
 
-      hc.ssl_config.ssl_version = :TLSv1
-      response = hc.get("#{@base_url.gsub('API_CALL',endpoint[0]) + @api_key + endpoint[1]}")
-      body = JSON.parse(response.body)
+      return Key.new(hashed_key)
+    end
+    
+  end
+  
+  module Helper
+    
+    def self.extractKey(encrypted_data, b64_enc_key)
+      # passphrase is in plain text
+      # encrypted_data is in base64, as it was stored on Block.io
+      # returns the private key extracted from the given encrypted data
       
+      decrypted = self.decrypt(encrypted_data, b64_enc_key)
+      
+      return Key.from_passphrase(decrypted)
     end
     
-    body
+    def self.sha256(value)
+      # returns the hex of the hash of the given value
+      hash = Digest::SHA2.new(256)
+      hash << value
+      hash.hexdigest # return hex
+    end
+    
+    def self.pinToAesKey(secret_pin, iterations = 2048)
+      # converts the pincode string to PBKDF2
+      # returns a base64 version of PBKDF2 pincode
+      salt = ""
+      aes_key_bin = OpenSSL::PKCS5.pbkdf2_hmac(secret_pin, salt, iterations/2, 16, OpenSSL::Digest::SHA256.new)
+      aes_key_bin = OpenSSL::PKCS5.pbkdf2_hmac(aes_key_bin.unpack("H*")[0], salt, iterations/2, 32, OpenSSL::Digest::SHA256.new)
+      
+      return Base64.strict_encode64(aes_key_bin) # the base64 encryption key
+    end
+    
+    # Decrypts a block of data (encrypted_data) given an encryption key
+    def self.decrypt(encrypted_data, b64_enc_key, iv = nil, cipher_type = 'AES-256-ECB')
+      
+      response = nil
+
+      begin
+        aes = OpenSSL::Cipher::Cipher.new(cipher_type)
+        aes.decrypt
+        aes.key = Base64.strict_decode64(b64_enc_key)
+        aes.iv = iv if iv != nil
+        response = aes.update(Base64.strict_decode64(encrypted_data)) + aes.final
+      rescue Exception => e
+        # decryption failed, must be an invalid Secret PIN
+        raise Exception.new('Invalid Secret PIN provided.')
+      end
+
+      return response
+    end
+    
+    # Encrypts a block of data given an encryption key
+    def self.encrypt(data, b64_enc_key, iv = nil, cipher_type = 'AES-256-ECB')
+      aes = OpenSSL::Cipher::Cipher.new(cipher_type)
+      aes.encrypt
+      aes.key = Base64.strict_decode64(b64_enc_key)
+      aes.iv = iv if iv != nil
+      Base64.strict_encode64(aes.update(data) + aes.final)
+    end
   end
 
 end

data/lib/block_io/version.rb

@@ -1,3 +1,3 @@
 module BlockIo
-  VERSION = "0.1.3"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: block_io
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.0.1
 platform: ruby
 authors:
 - Atif Nazir
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-01 00:00:00.000000000 Z
+date: 2014-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ecdsa
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: httpclient
   requirement: !ruby/object:Gem::Requirement
@@ -109,13 +129,14 @@ extra_rdoc_files: []
 files:
 - Gemfile
 - LICENSE
-- LICENSE.txt
 - README.md
 - Rakefile
 - block_io.gemspec
+- examples/basic.rb
+- examples/dtrust.rb
 - lib/block_io.rb
 - lib/block_io/version.rb
-homepage: https://block.io/api/ruby
+homepage: https://block.io/api/simple/ruby
 licenses:
 - MIT
 metadata: {}

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2014 Atif Nazir
-
-MIT License
-
-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.