block_io 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64a968ba0f92fcd2d78097633d45b3c5af847bb4d485d1edad901dbbfff959d6
-  data.tar.gz: 8924f4b86c12833f80bda1ef5f91be065d974f37556a4909703d46b635db0071
+  metadata.gz: eb3eee8a4c13ad41febe0e5f07271c0e9d8cab44cfc5540d898aa8802c89e334
+  data.tar.gz: 52c0524074d9ea5da705be0190b613c56e10b1f52f5bdd10bbac163a415ba2e5
 SHA512:
-  metadata.gz: 658d6559024e0bfa246fee235c61327111fd624df4d0503ec1522df6d8cd029fb8e155885f6b9555efe5fd823d2f9d7bdf8847e4b09579057ae8c2c4bcc690ae
-  data.tar.gz: ed86538d0e8811b768271b20c1dc370c9d00f9cdbce18fd75a9582e6a80e2a2562b6851c8f74e422b39aac3550ce6d8350635b9b9c7edc2915393e7226f5b3cd
+  metadata.gz: 8b85df794d052257b15add0e7a298b6b3482f04eaa67db0d4fe8b944898fd8a9e00451a2f4f6b351f867a8e33db7694421b2a419102941e41b9543a0a5ba2048
+  data.tar.gz: b58bb5628274ac2609a6103e68ba0fe5b829705231ee4264126521703907b83e46da97b6ebc9a8698c5d3ff39c11685011fcd4aa6e3d287fdb5ead9e0553054d

data/.appveyor.yml

@@ -0,0 +1,26 @@
+version: '{build}'
+
+skip_tags: true
+
+environment:
+  matrix:
+    - ruby_version: "23"
+    - ruby_version: "23-x64"
+    - ruby_version: "24"
+    - ruby_version: "24-x64"
+    - ruby_version: "25"
+    - ruby_version: "25-x64"
+    - ruby_version: "26"
+    - ruby_version: "26-x64"
+    - ruby_version: "27"
+    - ruby_version: "27-x64"
+    
+install:
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - gem install bundler --no-document -v 2.1.4
+  - bundle install --retry=3
+
+test_script:
+  - bundle exec rspec
+
+build: off

data/.gitignore

@@ -1,5 +1,5 @@
 Gemfile.lock
-pkg
 vendor/
 .bundle/
 *.gem
+*~

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+os:
+- linux
+rvm:
+- 2.3
+- 2.4
+- 2.5
+- 2.6
+- 2.7
+bundler_args: --jobs=2
+script:
+- bundle exec rspec
+cache: bundler
+

data/README.md

@@ -10,14 +10,15 @@ Add this line to your application's Gemfile:
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
-    $ gem install block_io -v=1.2.1
+    $ gem install block_io -v=2.0.0
 
 ## Changelog
 
+*07/02/20*: BREAKING CHANGES. Version 2.0.0. Remove support for Ruby < 2.3.0. Behavior and interfaces have changed. By upgrading you'll need to revise your code and tests.  
 *05/10/19*: Prevent inadvertent passing of PINs (user error).  
 *06/25/18*: Remove support for Ruby < 1.9.3 (OpenSSL::Cipher::Cipher). Remove connection_pool dependency.  
 *01/21/15*: Added ability to sweep coins from one address to another.  
@@ -31,14 +32,19 @@ 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', :version => 2
-     
+    blockio = BlockIo::Client.new(:api_key => "API KEY", :pin => "SECRET PIN")
+
+If you do not have your PIN, or just wish to use your private key backup directly, do this:
+
+    blockio = BlockIo::Client.new(:api_key => "API KEY", :keys => [BlockIo::Key.from_wif("PRIVATE KEY BACKUP")])
+
 And you're good to go:
 
-    BlockIo.get_new_address
-    BlockIo.get_my_addresses
+    blockio.get_new_address
+    blockio.get_my_addresses
 
-For more information, see https://block.io/api/simple/ruby
+For other initialization options/parameters, see `lib/block_io/client.rb`.  
+For more information, see https://block.io/api/simple/ruby.
 
 ## Contributing
 

data/block_io.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'block_io/version'
@@ -16,12 +15,15 @@ Gem::Specification.new do |spec|
   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.required_ruby_version = '>= 2.3.0'
   spec.require_paths = ["lib"]
 
-  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.8", '>= 2.8.0'
-  spec.add_runtime_dependency "oj", "~> 3.3", '>= 3.3.5'
-  spec.add_runtime_dependency "pbkdf2-ruby", '~> 0.2', '>= 0.2.1'
+  spec.add_development_dependency "bundler", ">= 1.16", "< 3.0"
+  spec.add_development_dependency "rake", "~> 12.3", ">= 12.3.3"
+  spec.add_development_dependency "rspec", "~> 3.6", ">= 3.6"
+  spec.add_development_dependency "webmock", "~> 3.8", "< 4.0"
+  spec.add_runtime_dependency "ecdsa", "~> 1.2.0", ">= 1.2.0"
+  spec.add_runtime_dependency "http", "~> 4.4.1", ">= 4.4.1"
+  spec.add_runtime_dependency "oj", "~> 3.10.6", ">= 3.10"
+  spec.add_runtime_dependency "connection_pool", "~> 2.2.3", ">= 2.2"
 end

data/examples/basic.rb

@@ -7,22 +7,20 @@
 
 require 'block_io'
 
-puts BlockIo.set_options :api_key => ENV['API_KEY'], :pin => ENV['PIN'], :version => 2
+blockio = BlockIo::Client.new(:api_key => ENV['API_KEY'], :pin => ENV['PIN'], :version => 2)
+puts blockio.get_balance
+puts blockio.network
 
-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
+# create the address if it doesn't exist
+puts blockio.get_new_address(:label => 'testDest')
 
-puts BlockIo.withdraw_from_labels(:from_labels => 'default', :to_label => 'testDest', :amount => '2.5')
+puts blockio.withdraw_from_labels(:from_labels => 'default', :to_label => 'testDest', :amount => '2.5')
 
-puts BlockIo.get_address_balance(:labels => 'default,testDest')
+puts blockio.get_address_balance(:labels => 'default,testDest')
 
-puts BlockIo.get_transactions(:type => 'sent') # API v2 only
+puts blockio.get_transactions(:type => 'sent')
 
-puts BlockIo.get_transactions(:type => 'received') # API v2 only
+puts blockio.get_transactions(:type => 'received')
 
-puts BlockIo.get_current_price(:base_price => 'BTC')
+puts blockio.get_current_price(:base_price => 'BTC')
 

data/examples/dtrust.rb

@@ -3,30 +3,45 @@
 require 'block_io'
 require 'json'
 
-# please use the Dogecoin Testnet API key here
+# please use the Litecoin Testnet API key here
 puts "*** Initialize BlockIo library: "
-puts JSON.pretty_generate(BlockIo.set_options :api_key => 'YourDogecoinTestnetAPIKey', :pin => 'YourSecretPIN', :version => 2)
+blockio = BlockIo::Client.new(:api_key => ENV['API_KEY'], :pin => ENV['PIN'], :version => 2)
+puts blockio.get_dtrust_balance
+puts blockio.network
 
+raise "Please use the LTCTEST network API Key here or modify this script for another network." unless blockio.network == "LTCTEST"
 
 # create 4 keys
-keys = [ BlockIo::Key.from_passphrase('alpha1alpha2alpha3alpha4'), BlockIo::Key.from_passphrase('alpha4alpha1alpha2alpha3'), BlockIo::Key.from_passphrase('alpha3alpha4alpha1alpha2'), BlockIo::Key.from_passphrase('alpha2alpha3alpha4alpha1') ]
+# you will generate your own private keys, for instance: key = BlockIo::Key.new. Just note down key.public_key and key.private_key somewhere safe before you use your keys to generate dTrust addresses.
+# if you already have hex private keys, load the keys with BlockIo::Key.new(private_key_hex). Ensure the key's .public_key matches what you expect.
+# WARNING: The keys below are just for demonstration, DO NOT use them on mainnets, DO NOT use insecurely generated keys
+keys = [
+  BlockIo::Key.new("b515fd806a662e061b488e78e5d0c2ff46df80083a79818e166300666385c0a2"), # alpha1alpha2alpha3alpha4
+  BlockIo::Key.new("1584b821c62ecdc554e185222591720d6fe651ed1b820d83f92cdc45c5e21f"), # alpha2alpha3alpha4alpha1
+  BlockIo::Key.new("2f9090b8aa4ddb32c3b0b8371db1b50e19084c720c30db1d6bb9fcd3a0f78e61"), # alpha3alpha4alpha1alpha2
+  BlockIo::Key.new("6c1cefdfd9187b36b36c3698c1362642083dcc1941dc76d751481d3aa29ca65") # alpha4alpha1alpha2alpha3
+].freeze
 
 dtrust_address = nil
+dtrust_address_label = "dTrust1_witness_v0"
 
 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)
+  # you will need all 4 of your keys to use your address without interacting with Block.io
 
-  signers = ""
-  keys.each { |key| signers += ',' if signers.length > 0; signers += key.public_key; }
+  signers = keys.map{|k| k.public_key}.join(',')
 
-  response = BlockIo.get_new_dtrust_address(:label => 'dTrust1', :public_keys => signers, :required_signatures => 3)
+  response = blockio.get_new_dtrust_address(:label => dtrust_address_label, :public_keys => signers, :required_signatures => 3, :address_type => "witness_v0")
 
   dtrust_address = response['data']['address']
+
+  raise response["data"]["error_message"] unless response["status"].eql?("success")
+  
 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')
+  response = blockio.get_dtrust_address_by_label(:label => dtrust_address_label)
   
   dtrust_address = response['data']['address']
 end
@@ -34,57 +49,40 @@ 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')
+response = blockio.withdraw_from_labels(:from_labels => 'default', :to_address => dtrust_address, :amount => '0.001')
 
 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'))
+puts "*** dtrust_address_label Balance:"
+puts JSON.pretty_generate(blockio.get_dtrust_address_balance(:label => dtrust_address_label))
 
-# withdraw a few coins from dtrust1 to the default label
-normal_address = BlockIo.get_address_by_label(:label => 'default')['data']['address']
+# withdraw a few coins from dtrust_address_label 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"
+puts "*** Withdrawing from dtrust_address_label to the 'default' label in normal multisig"
 
-response = BlockIo.withdraw_from_dtrust_address(:from_labels => 'dTrust1', :to_addresses => normal_address, :amounts => '2.1')
+response = blockio.withdraw_from_dtrust_address(:from_labels => dtrust_address_label, :to_addresses => normal_address, :amounts => '0.0009')
 
 puts JSON.pretty_generate(response)
 
 # let's sign for the public keys specified
+signatures_added = BlockIo::Helper.signData(response["data"]["inputs"], keys)
 
-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 "*** Signatures added? #{signatures_added}"
 
-puts "*** Our signed response: "
-puts JSON.pretty_generate(response['data']) #.to_json
+puts "*** Our (signed) request:"
+puts JSON.pretty_generate(response['data'])
 
 # let's final the withdrawal
 puts "*** Finalize withdrawal: "
-puts JSON.pretty_generate(BlockIo.sign_and_finalize_withdrawal(:signature_data => response['data'].to_json))
+puts JSON.pretty_generate(blockio.sign_and_finalize_withdrawal({:signature_data => response["data"]}))
 
 # get the sent transactions for this dTrust address
 
-puts "*** Get transactions sent by our dTrust1 address: "
+puts "*** Get transactions sent by our dtrust_address_label address: "
 
-puts JSON.pretty_generate(BlockIo.get_dtrust_transactions(:type => 'sent', :labels => 'dTrust1'))
+puts JSON.pretty_generate(blockio.get_dtrust_transactions(:type => 'sent', :labels => dtrust_address_label))
 

data/examples/max_withdrawal.rb

@@ -0,0 +1,29 @@
+# withdraws maximum balance to a given destination in a single transaction
+# you will need to repeat this if a single transaction does not suffice for withdrawing the entire balance
+# for error handling, please check response['data']['status'] != 'success'
+
+require 'block_io'
+
+blockio = BlockIo::Client.new(:api_key => ENV['API_KEY'], :pin => ENV['PIN'], :version => 2)
+puts blockio.get_balance
+puts blockio.network
+
+TO_ADDRESS = ENV['TO_ADDRESS']
+
+raise "must specify a TO_ADDRESS" unless TO_ADDRESS.to_s.size > 0
+
+total_balance = blockio.get_balance['data']['available_balance']
+
+puts " -- total balance: #{total_balance} #{blockio.network}"
+
+while true do
+  response = blockio.withdraw(:to_address => TO_ADDRESS, :amount => total_balance)
+  maximum_withdrawable_balance = response['data']['max_withdrawal_available']
+  break if BigDecimal(maximum_withdrawable_balance).zero?
+  puts blockio.withdraw(:to_address => TO_ADDRESS, :amount => maximum_withdrawable_balance)
+end
+
+final_balance = blockio.get_balance['data']['available_balance']
+
+puts " -- final balance: #{final_balance} #{blockio.network}"
+

data/examples/proxy.rb

@@ -0,0 +1,36 @@
+# creates a new destination address, withdraws from the default label to it,
+# gets updated address balances, gets sent/received transactions, and the
+# current price
+# ... through an https proxy (like Squid)
+#
+# Unauthenticated:
+# $ PROXY_HOST=localhost PROXY_PORT=3128 API_KEY=TESTNET_API_KEY PIN=YOUR_SECRET_PIN ruby proxy.rb
+#
+# Authenticated:
+# $ PROXY_HOST=localhost PROXY_PORT=3128 PROXY_USER=user PROXY_PASS=pass API_KEY=TESTNET_API_KEY PIN=YOUR_SECRET_PIN ruby proxy.rb
+#
+# adjust amount below if not using the Dogecoin Testnet
+
+require '../lib/block_io'
+
+blockio = BlockIo::Client.new(:api_key => ENV['API_KEY'], :pin => ENV['PIN'], :version => 2, :proxy => {
+  :hostname => ENV['PROXY_HOST'],
+  :port => ENV['PROXY_PORT'],
+  :username => ENV['PROXY_USER'],
+  :password => ENV['PROXY_PASS']
+  })
+puts blockio.get_balance
+puts blockio.network
+
+# create the address if it doesn't exist
+puts blockio.get_new_address(:label => 'testDest')
+
+puts blockio.withdraw_from_labels(:from_labels => 'default', :to_label => 'testDest', :amount => '2.5')
+
+puts blockio.get_address_balance(:labels => 'default,testDest')
+
+puts blockio.get_transactions(:type => 'sent')
+
+puts blockio.get_transactions(:type => 'received')
+
+puts blockio.get_current_price(:base_price => 'BTC')

data/examples/sweeper.rb

@@ -6,19 +6,24 @@
 
 require "block_io"
 
-BlockIo.set_options :api_key => 'YOUR API KEY', :pin => 'PIN NOT NEEDED', :version => 2
+blockio = BlockIo::Client.new(:api_key => ENV['API_KEY'], :version => 2)
+puts blockio.get_balance
+puts blockio.network
 
-to_address = 'SWEEP COINS TO THIS ADDRESS'
+to_address = ENV['TO_ADDRESS'] # sweep coins into this address
 
-from_address = 'SWEEP COINS FROM THIS ADDRESS'
-private_key = 'PRIVATE KEY FOR FROM_ADDRESS'
+from_address = ENV['FROM_ADDRESS'] # sweep coins from this address
+private_key = ENV['PRIVATE_KEY'] # private key for from_address
 
 begin
-  response = BlockIo.sweep_from_address(:to_address => to_address, :private_key => private_key, :from_address => from_address)
-  
+  response = blockio.sweep_from_address(:to_address => to_address, :private_key => private_key, :from_address => from_address)
+
+  raise response["data"]["error_message"] unless response["status"].eql?("success")
+
   puts "Sweep Complete: #{response['data']['amount_sent']} #{response['data']['network']} swept from #{from_address} to #{to_address}."
   puts "Transaction ID: #{response['data']['txid']}"
   puts "Network Fee Incurred: #{response['data']['network_fee']} #{response['data']['network']}"
+  
 rescue Exception => e
   puts "Sweep failed: #{e}"
 end

data/lib/block_io.rb

@@ -1,418 +1,22 @@
-require 'block_io/version'
-require 'httpclient'
-require 'oj'
-require 'ecdsa'
-require 'openssl'
-require 'digest'
-require 'pbkdf2'
-require 'securerandom'
-require 'base64'
+require "http"
+require "oj"
+require "ecdsa"
+require "openssl"
+require "securerandom"
+require "connection_pool"
+
+require_relative "block_io/version"
+require_relative "block_io/constants"
+require_relative "block_io/helper"
+require_relative "block_io/key"
+require_relative "block_io/client"
 
 module BlockIo
 
-  @api_key = nil
-  @base_url = nil
-  @pin = nil
-  @encryptionKey = nil
-  @client = nil
-  @conn_pool = nil
-  @version = nil
-
-  def self.set_options(args = {})
-    # initialize BlockIo
-    @api_key = args[:api_key]
-    @pin = args[:pin]
-    
-    @encryptionKey = Helper.pinToAesKey(@pin) if !@pin.nil?
-
-    hostname = args[:hostname] || "block.io"
-    @base_url = "https://" << hostname << "/api/VERSION/API_CALL/?api_key="
-    
-    @client = HTTPClient.new
-    @client.tcp_keepalive = true
-    @client.ssl_config.ssl_version = :auto
-    
-    @version = args[:version] || 2 # default version is 2
-    
-    self.api_call(['get_balance',""])
-  end
-
-  def self.method_missing(m, *args, &block)      
-
-    method_name = m.to_s
-
-    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
-      # need to withdraw from an address
-      self.withdraw(args.first, m.to_s)
-    elsif ['sweep_from_address'].include?(m.to_s) then
-      # need to sweep from an address
-      self.sweep(args.first, m.to_s)
-    else
-      params = get_params(args.first)
-      self.api_call([method_name, params])
-    end
-    
-  end 
-
-  def self.withdraw(args = {}, method_name = 'withdraw')
-    # validate arguments for withdrawal of funds TODO
-
-    raise Exception.new("PIN not set. Use BlockIo.set_options(:api_key=>'API KEY',:pin=>'SECRET PIN',:version=>'API VERSION')") if @pin.nil?
-
-    # make sure pins don't get passed inadvertently
-    args.delete(:pin)
-    args.delete('pin')
-
-    params = get_params(args)
-
-    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
-
-      # extract the passphrase
-      encrypted_passphrase = response['data']['encrypted_passphrase']['passphrase']
-
-      # let's get our private key
-      key = Helper.extractKey(encrypted_passphrase, @encryptionKey)
-
-      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']
-
-      # let's sign all the inputs we can
-      inputs = response['data']['inputs']
-
-      Helper.signData(inputs, [key])
-
-      # the response object is now signed, let's stringify it and finalize this withdrawal
-      response = self.api_call(['sign_and_finalize_withdrawal',{:signature_data => Oj.dump(response['data'])}])
-
-      # 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
-
-    return response
-
+  def self.version
+    BlockIo::VERSION
   end
-
-  def self.sweep(args = {}, method_name = 'sweep_from_address')
-    # sweep coins from a given address + key
-
-    raise Exception.new("No private_key provided.") unless args.has_key?(:private_key)
-
-    key = Key.from_wif(args[:private_key])
-
-    args[:public_key] = key.public_key # so Block.io can match things up
-    args.delete(:private_key) # the key must never leave this machine
-
-    params = get_params(args)
-
-    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
-
-      # let's sign all the inputs we can
-      inputs = response['data']['inputs']
-      Helper.signData(inputs, [key])
-
-      # the response object is now signed, let's stringify it and finalize this withdrawal
-      response = self.api_call(['sign_and_finalize_sweep',{:signature_data => Oj.dump(response['data'])}])
-
-      # 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
-
-    return response
-
-  end
-
-
-  private
   
-  def self.api_call(endpoint)
-
-    body = nil
-
-    response = @client.post("#{@base_url.gsub('API_CALL',endpoint[0]).gsub('VERSION', 'v'+@version.to_s) + @api_key}", endpoint[1])
-      
-    begin
-      body = Oj.load(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
-    
-    body
-  end
-
-  private
-
-  def self.get_params(args = {})
-    # construct the parameter string
-    params = ""
-    args = {} if args.nil?
-    
-    args.each do |k,v|
-      params += '&' if params.length > 0
-      params += "#{k.to_s}=#{v.to_s}"
-    end
-
-    return params
-  end
-
-  public
-
-  class Key
-
-    def initialize(privkey = nil, compressed = true)
-      # the privkey must be in hex if at all provided
-
-      @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)
-      @compressed = compressed
-
-    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)
-
-      return ECDSA::Format::PointOctetString.encode(@public_key, compression: @compressed).unpack("H*")[0]
-    end
-    
-    def sign(data)
-      # signed the given hexadecimal string
-
-      nonce = deterministicGenerateK([data].pack("H*"), @private_key) # RFC6979
-      
-      signature = ECDSA.sign(@group, @private_key, data.to_i(16), nonce)
-
-      # BIP0062 -- use lower S values only
-      r, s = signature.components
-
-      over_two = @group.order >> 1 # half of what it was                     
-      s = @group.order - s if (s > over_two)
-
-      signature = ECDSA::Signature.new(r, s)
-
-      # DER encode this, and return it in hex form
-      return ECDSA::Format::SignatureDerString.encode(signature).unpack("H*")[0]
-    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
-
-      return Key.new(hashed_key)
-    end
-
-    def self.from_wif(wif)
-      # returns a new key extracted from the Wallet Import Format provided
-      # TODO check against checksum
-
-      hexkey = Helper.decode_base58(wif)
-      actual_key = hexkey[2...66]
-
-      compressed = hexkey[2..hexkey.length].length-8 > 64 and hexkey[2..hexkey.length][64...66] == '01'
-
-      return Key.new(actual_key, compressed)
-
-    end
-    
-    def isPositive(i)
-      sig = "!+-"[i <=> 0]
-      
-      return sig.eql?("+")
-    end
-    
-    def deterministicGenerateK(data, privkey, group = ECDSA::Group::Secp256k1)
-      # returns a deterministic K  -- RFC6979
-
-      hash = data.bytes.to_a
-
-      x = [privkey.to_s(16)].pack("H*").bytes.to_a
-      
-      k = []
-      32.times { k.insert(0, 0) }
-      
-      v = []
-      32.times { v.insert(0, 1) }
-      
-      # step D
-      k = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), k.pack("C*"), [].concat(v).concat([0]).concat(x).concat(hash).pack("C*")).bytes.to_a
-      
-      # step E
-      v = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), k.pack("C*"), v.pack("C*")).bytes.to_a
-      
-      #  puts "E: " + v.pack("C*").unpack("H*")[0]
-      
-      # step F
-      k = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), k.pack("C*"), [].concat(v).concat([1]).concat(x).concat(hash).pack("C*")).bytes.to_a
-      
-      # step G
-      v = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), k.pack("C*"), v.pack("C*")).bytes.to_a
-      
-      # step H2b (Step H1/H2a ignored)
-      v = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), k.pack("C*"), v.pack("C*")).bytes.to_a
-      
-      h2b = v.pack("C*").unpack("H*")[0]
-      tNum = h2b.to_i(16)
-      
-      # step H3
-      while (!isPositive(tNum) or tNum >= group.order) do
-        # k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0])]), k)
-        k = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), k.pack("C*"), [].concat(v).concat([0]).pack("C*")).bytes.to_a
-        
-        # v = crypto.HmacSHA256(v, k)
-        v = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), k.pack("C*"), v.pack("C*")).bytes.to_a
-        
-        # T = BigInteger.fromBuffer(v)
-        tNum = v.pack("C*").unpack("H*")[0].to_i(16)
-      end
-      
-      return tNum
-    end
-
-  end
-  
-  module Helper
-    
-    def self.signData(inputs, keys)
-      # sign the given data with the given keys
-      # TODO loop is O(n^3), make it better
-
-      raise Exception.new('Keys object must be an array of keys, without at least one key inside it.') unless keys.is_a?(Array) and keys.size >= 1
-
-      i = 0
-      while i < inputs.size do
-        # iterate over all signers
-        input = inputs[i]
-
-        j = 0
-        while j < input['signers'].size do
-          # if our public key matches this signer's public key, sign the data
-          signer = inputs[i]['signers'][j]
-          
-          k = 0
-          while k < keys.size do
-            # sign for each key provided, if we can
-            key = keys[k]
-            signer['signed_data'] = key.sign(input['data_to_sign']) if signer['signer_public_key'] == key.public_key
-            k = k + 1
-          end
-
-          j = j + 1
-        end
-
-        i = i + 1
-      end
-
-      inputs
-    end
-
-    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
-    
-    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 = ""
-
-      # pbkdf2-ruby gem uses SHA256 as the default hash function
-      aes_key_bin = PBKDF2.new(:password => secret_pin, :salt => salt, :iterations => iterations/2, :key_length => 128/8).value
-      aes_key_bin = PBKDF2.new(:password => aes_key_bin.unpack("H*")[0], :salt => salt, :iterations => iterations/2, :key_length => 256/8).value
-
-      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.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.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
 
-    # courtesy bitcoin-ruby
-    
-    def self.int_to_base58(int_val, leading_zero_bytes=0)
-      alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-      base58_val, base = '', alpha.size
-      while int_val > 0
-        int_val, remainder = int_val.divmod(base)
-        base58_val = alpha[remainder] + base58_val
-      end
-      base58_val
-    end
-    
-    def self.base58_to_int(base58_val)
-      alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-      int_val, base = 0, alpha.size
-      base58_val.reverse.each_char.with_index do |char,index|
-        raise ArgumentError, 'Value not a valid Base58 String.' unless char_index = alpha.index(char)
-        int_val += char_index*(base**index)
-      end
-      int_val
-    end
-    
-    def self.encode_base58(hex)
-      leading_zero_bytes  = (hex.match(/^([0]+)/) ? $1 : '').size / 2
-      ("1"*leading_zero_bytes) + Helper.int_to_base58( hex.to_i(16) )
-    end
-    
-    def self.decode_base58(base58_val)
-      s = Helper.base58_to_int(base58_val).to_s(16); s = (s.bytesize.odd? ? '0'+s : s)
-      s = '' if s == '00'
-      leading_zero_bytes = (base58_val.match(/^([1]+)/) ? $1 : '').size
-      s = ("00"*leading_zero_bytes) + s  if leading_zero_bytes > 0
-      s
-    end
-  end
 
-end