crypto_address_validator 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a5acb742dfaf129cf78b31bd02f819a1f004e8e6b6243f3f4b440a4902175987
+  data.tar.gz: 566d0f3c14dbcbdb22474bdfe1964e53d073a241ad5c9d843934cd8104c6dab7
+SHA512:
+  metadata.gz: 32e065985182686f76333525bba80e2277978a2577c074ad0904c5a36bdbf58a515993e521a4b89a124e70e9ed657d152ccb39f5421c0389910a02b2346d44f9
+  data.tar.gz: ca0739bc1a05275bbe620dd704116b9ec85cf273795e0f6796df37fdc1136bd6e4ab5be9f0caa5a1a02ab06532c206c2430441bf545bff28486d034928bbe84e

data/.coveralls.yml

@@ -0,0 +1,2 @@
+repo_token: ATgUXu3s0jZaYdzAdUr8P8ytuMMbR9ueh
+

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status
+
+# Spec artifacts
+/coverage

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,36 @@
+require: rubocop-rspec
+
+AllCops:
+  DisplayCopNames: true
+
+Naming/AccessorMethodName:
+  Description: Check the naming of accessor methods for get_/set_.
+  Enabled: false
+
+Style/DocumentationMethod:
+  RequireForNonPublicMethods: false
+
+Documentation:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/NegatedIf:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 30
+
+Style/SymbolArray:
+  Enabled: true
+  EnforcedStyle: brackets
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+  SupportedStyles:
+    - single_quotes
+

data/.travis.yml

@@ -0,0 +1,13 @@
+---
+language: ruby
+sudo: false
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.3
+script: bundle exec rspec spec
+notifications:
+  email:
+    - justin@sequoir.com
+after_success:
+- CI=true TRAVIS=true coveralls --verbose

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gem 'coveralls', '>= 0.8.17', require: false
+gem 'pry', require: false
+
+gem 'rubocop-rspec'
+# Specify your gem's dependencies in crypto_address_validator.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 vtm
+
+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.

data/Makefile

@@ -0,0 +1,6 @@
+
+build:
+	gem build crypto_address_validator.gemspec
+
+push:
+	gem push crypto_address_validator-0.1.5.gem

data/README.md

@@ -0,0 +1,150 @@
+
+CryptoAddressValidator
+===============
+
+[![Gem Version][gem-version-svg]][gem-version-link]
+[![Build Status][build-status-svg]][build-status-link]
+[![Code Climate][codeclimate-status-svg]][codeclimate-status-link]
+[![Coverage Status][coverage-status-svg]][coverage-status-link]
+[![Downloads][downloads-svg]][downloads-link]
+[![Docs][docs-rubydoc-svg]][docs-rubydoc-link]
+[![License][license-svg]][license-link]
+
+Simple wallet address validator and normalizer for cryptocurrencies addresses in Ruby.
+
+Inspired by [vtm9/adequate_crypto_address](https://github.com/vtm9/adequate_crypto_address).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'crypto_address_validator'
+```
+
+Or install it yourself as:
+
+```bash
+gem install crypto_address_validator
+```
+
+## Main API
+
+##### .valid? (address, currency [, type = :prod, type = [])
+
+###### Parameters
+* address - Wallet address to validate.
+* currency - Currency name string or symbol in any case, `:bitcoin` or `'BTC'` or `:btc` or `'BitCoin'`
+* type - Optional. You can enforce validation with specific type or an array of types. Not all currencies support types. 
+
+> Returns true if the address (string) is a valid wallet address for the crypto currency specified, see below for supported currencies.
+
+### Supported crypto currencies
+
+* Bitcoin/BTC, `'bitcoin'` or `'BTC'` types: `:segwit_v0_keyhash :segwit_v0_scripthash :hash160 :p2sh`
+* BitcoinCash/BCH, `'bitcoincash'` or `'BCH'` types: `:p2sh :p2pkh :p2pkhtest :p2shtest`
+* Dash, `'dash'` or `'DASH'` types: `:prod :test`
+* Zcash/ZEC, `'zcash'` or `'ZEC'` types: `:prod :test`
+* Ethereum/ETH, `'ethereum'` or `'ETH'`
+* Ripple/XRP, `'ripple'` or `'XRP'`
+
+## Usage
+
+### Validation
+``` ruby
+require 'crypto_address_validator'
+# BTC
+CryptoAddressValidator.valid?('12QeMLzSrB8XH8FvEzPMVoRxVAzTr5XM2y', 'BTC') #=> true
+CryptoAddressValidator.valid?('3NJZLcZEEYBpxYEUGewU4knsQRn1WM5Fkt', :bitcoin, :p2sh) #=> true
+
+# BTC(non SegWit address validation)
+CryptoAddressValidator.valid?('3NJZLcZEEYBpxYEUGewU4knsQRn1WM5Fkt', :bitcoin, [:p2sh, :hash160]) #=> true
+
+# BCH
+CryptoAddressValidator.valid?('bitcoincash:qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk', :bch) #=> true
+CryptoAddressValidator.valid?('mmRH4e9WW4ekZUP5HvBScfUyaSUjfQRyvD', :BCH, :p2pkhtest) #=> true
+
+# ETH
+CryptoAddressValidator.valid?('0xde709f2102306220921060314715629080e2fb77', :ETH) #=> true
+CryptoAddressValidator.valid?('de709f2102306220921060314715629080e2fb77', :ethereum) #=> true
+```
+
+### Normalization
+###### *Not all currencies support this feature.
+``` ruby
+require 'crypto_address_validator'
+
+# BCH
+CryptoAddressValidator.address('mmRH4e9WW4ekZUP5HvBScfUyaSUjfQRyvD', 'bch').cash_address #=> "bchtest:qpqtmmfpw79thzq5z7s0spcd87uhn6d34uqqem83hf"
+CryptoAddressValidator.address('bitcoincash:qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk', 'bch').legacy_address #=> "1LcerwTc1oPsMtByDCNUXFxReZpN1EXHoe"
+
+address_string = 'qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk'
+addr = CryptoAddressValidator.address(address_string, 'bch')
+addr.prefix #=> "bitcoincash"
+addr.type #=> :p2pkh
+addr.address #=> "bitcoincash:qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk"
+
+# ETH
+CryptoAddressValidator.address('D1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb', 'eth').address #=> "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb"
+```
+
+
+### ActiveRecord validation example
+``` ruby
+class Model < ActiveRecord::Base
+  attribute :address, :string
+  attribute :dest_tag, :string
+  attribute :currency, :string
+
+  validate  :validate_address_type
+  validate  :validate_destination_tag
+
+  def validate_address_type
+    errors.add(:address, 'invalid address') unless CryptoAddressValidator.valid?(address, currency)
+  end
+
+  # for Ripple
+  def validate_destination_tag
+    errors.add(:dest_tag, 'invalid destination tag') if dest_tag.present? && !(dest_tag =~ /\A\d{1,10}\z/)
+  end
+end
+
+```
+### Add your currnecy
+``` ruby
+# frozen_string_literal: true
+# for Rails /config/initializers/crypto_address_validator.rb
+module CryptoAddressValidator
+  class Coin
+    attr_reader :address
+
+    def initialize(address_sring)
+      @address = address_sring
+    end
+
+    def valid?(_type)
+      address.present?
+    end
+  end
+end
+
+CryptoAddressValidator.valid?('addr', :coin) #=> true
+```
+
+## Development
+
+Run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+1. Fork [the repo](https://github.com/sequoir/crypto_address_validator)
+2. Grab dependencies: `bundle install`
+3. Make sure everything is working: `bundle exec rake spec`
+4. Make your changes
+5. Test your changes
+5. Create a Pull Request
+
+## Notes
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sequoir/crypto_address_validator/issues

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'crypto_address_validator'
+
+ACA = CryptoAddressValidator
+include CryptoAddressValidator
+
+require 'pry'
+Pry.start

data/crypto_address_validator.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'crypto_address_validator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'crypto_address_validator'
+  spec.version       = CryptoAddressValidator::VERSION
+  spec.authors       = ['sequoir']
+  spec.email         = ['engineering@sequoir.com']
+
+  spec.summary     = 'A Ruby Library for dealing with validation cryptocurrency adresses.'
+  spec.description = 'A Ruby Library for dealing with validation cryptocurrency adresses.'
+  spec.homepage = 'https://github.com/sequoir/crypto_address_validator'
+
+  spec.license = 'MIT'
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'base58', '~> 0.2'
+  spec.add_dependency 'keccak', '1.2'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.10'
+end

data/lib/crypto_address_validator/altcoin.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module CryptoAddressValidator
+  # simple class for common altcoin addresses like legacy btc, ripple, dash, zec, etc.
+  class Altcoin
+    EXPECTED_LENGTH = 50
+    ADDRESS_TYPES = {}.freeze
+    ALPHABET_TYPE = :bitcoin
+
+    attr_reader :address, :type
+    alias raw_address address
+
+    def initialize(address)
+      @address = address
+      @type = address_type
+    end
+
+    def valid?(validated_type = nil)
+      if validated_type
+        type == validated_type.to_sym
+      else
+        !type.nil?
+      end
+    end
+
+    private
+
+    attr_reader :decoded
+
+    def address_type
+      @decoded = begin
+              decode_base58
+                 rescue StandardError
+                   nil
+            end
+      if decoded && decoded.bytesize == self.class::EXPECTED_LENGTH && valid_address_checksum?
+        self.class::ADDRESS_TYPES.each do |net_type, net_prefixes|
+          net_prefixes.each do |net_prefix|
+            return net_type if decoded.start_with?(net_prefix)
+          end
+        end
+      end
+      nil
+    end
+
+    def decode_base58
+      Base58.base58_to_binary(address, self.class::ALPHABET_TYPE).each_byte.map { |b| b.to_s(16).rjust(2, '0') }.join
+    end
+
+    def valid_address_checksum?
+      return false unless decoded
+
+      checksum(decoded[0...-8]) == decoded[-8..-1]
+    end
+
+    def checksum(bytes)
+      Digest::SHA256.hexdigest(Digest::SHA256.digest([bytes].pack('H*')))[0...8]
+    end
+  end
+end

data/lib/crypto_address_validator/bch.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'base58'
+require 'digest'
+
+module CryptoAddressValidator
+  class InvalidAddress < StandardError; end
+  class Bch
+    class InvalidLegacyAddress < ::CryptoAddressValidator::InvalidAddress; end
+    class InvalidCashAddress < ::CryptoAddressValidator::InvalidAddress; end
+    include ::CryptoAddressValidator::Utils::Bch
+
+    TYPE_MAP = {
+      legacy: [
+        [:p2sh, 5],
+        [:p2pkh, 0],
+        [:p2shtest, 196],
+        [:p2pkhtest, 111]
+      ],
+      cash: [
+        [:p2sh, 8],
+        [:p2pkh, 0],
+        [:p2shtest, 8],
+        [:p2pkhtest, 0]
+      ]
+    }.freeze
+    DEFAULT_PREFIX = :bitcoincash
+
+    attr_reader :raw_address, :type, :payload, :prefix, :digest
+
+    def initialize(address)
+      @raw_address = address
+      normalize
+    end
+
+    def valid?(validated_type = nil)
+      if validated_type
+        type == validated_type.to_sym
+      else
+        !type.nil?
+      end
+    end
+
+    def address_type(address_code, address_type)
+      TYPE_MAP[address_code].each do |mapping|
+        return mapping if mapping.include?(address_type)
+      end
+
+      raise(CryptoAddressValidator::InvalidAddress, 'Could not determine address type')
+    end
+
+    def legacy_address
+      type_int = address_type(:legacy, type)[1]
+      input = code_list_to_string([type_int] + payload + Array(digest))
+      input += Digest::SHA256.digest(Digest::SHA256.digest(input))[0..3] unless digest
+      Base58.binary_to_base58(input, :bitcoin)
+    end
+
+    def cash_address
+      type_int = address_type(:cash, type)[1]
+      p = [type_int] + payload
+      p = convertbits(p, 8, 5)
+      checksum = calculate_cash_checksum(p)
+      "#{prefix}:#{b32encode(p + checksum)}"
+    end
+
+    alias address cash_address
+
+    private
+
+    def normalize
+      begin
+        from_cash_string
+      rescue InvalidCashAddress
+        from_legacy_string
+      end
+    rescue CryptoAddressValidator::InvalidAddress
+      nil
+    end
+
+    def from_cash_string
+      if (raw_address.upcase != raw_address) && (raw_address.downcase != raw_address)
+        raise(InvalidCashAddress, 'Cash address contains uppercase and lowercase characters')
+      end
+
+      @raw_address = raw_address.downcase
+      @raw_address = "#{DEFAULT_PREFIX}:#{raw_address}" if !raw_address.include?(':')
+
+      @prefix, base32string = raw_address.split(':')
+      decoded = b32decode(base32string)
+
+      raise(InvalidCashAddress, 'Bad cash address checksum') if !verify_cash_checksum(decoded)
+
+      converted = convertbits(decoded, 5, 8)
+      @type = address_type(:cash, converted[0].to_i)[0]
+      @payload = converted[1..-7]
+
+      @type = :p2shtest if prefix == 'bchtest' && type == :p2sh
+      @type = :p2pkhtest if prefix == 'bchtest' && type == :p2pkh
+    end
+
+    def from_legacy_string
+      decoded = nil
+      begin
+        decoded = Base58.base58_to_binary(raw_address, :bitcoin).bytes
+      rescue StandardError
+        raise(InvalidLegacyAddress, 'Could not decode legacy address')
+      end
+
+      @type = address_type(:legacy, decoded[0].to_i)[0]
+      @payload = decoded[1..-5]
+      @digest = decoded[-4..-1]
+      @prefix = DEFAULT_PREFIX
+
+      @type = :p2shtest if prefix == 'bchtest' && type == :p2sh
+      @type = :p2pkhtest if prefix == 'bchtest' && type == :p2pkh
+      @prefix = 'bchtest' if [:p2shtest, :p2pkhtest].include?(type)
+    end
+  end
+
+  Bitcoincash = Bch
+end

data/lib/crypto_address_validator/btc.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module CryptoAddressValidator
+  class Btc
+    attr_reader :address, :type
+    alias raw_address address
+
+    def initialize(address)
+      @address = address
+      @type = address_type
+    end
+
+    def valid?(types = nil)
+      if types
+        types = [types].flatten.map(&:to_sym)
+        types.include?(address_type)
+      else
+        !address_type.nil?
+      end
+    end
+
+    private
+
+    def address_type
+      segwit_decoded = begin
+                         decode_segwit_address
+                       rescue StandardError
+                         nil
+                       end
+      if segwit_decoded
+        witness_version, witness_program_hex = segwit_decoded
+        witness_program = [witness_program_hex].pack('H*')
+
+        return :segwit_v0_keyhash if witness_version == 0 && witness_program.bytesize == 20
+
+        return :segwit_v0_scripthash if witness_version == 0 && witness_program.bytesize == 32
+      end
+
+      base58_decoded = begin
+              decode_base58(address)
+                       rescue StandardError
+                         nil
+            end
+      if base58_decoded && base58_decoded.bytesize == 50 && valid_base58_address_checksum?(base58_decoded)
+        case base58_decoded[0...2]
+        when '00'
+          return :hash160
+        when '05'
+          return :p2sh
+        when '6f'
+          return :hash160test
+        when 'c4'
+          return :p2shtest
+        end
+      end
+
+      nil
+    end
+
+    def decode_segwit_address
+      actual_hrp, data = Utils::Bech32.decode(address)
+
+      return nil if actual_hrp.nil?
+
+      length = data.size
+      return nil if length == 0 || length > 65
+      return nil if actual_hrp != 'bc'
+      return nil if data[0] > 16
+
+      program = Utils::Bech32.convert_bits(data[1..-1], from_bits: 5, to_bits: 8, pad: false)
+      return nil if program.nil?
+
+      length = program.size
+      return nil if length < 2 || length > 40
+      return nil if data[0] == 0 && length != 20 && length != 32
+
+      program_hex = program.pack('C*').unpack('H*').first
+      [data[0], program_hex]
+    end
+
+    def decode_base58(_base58_val)
+      Base58.base58_to_binary(address, :bitcoin).each_byte.map { |b| b.to_s(16).rjust(2, '0') }.join
+    end
+
+    def valid_base58_address_checksum?(base58_decoded)
+      return false unless base58_decoded
+
+      checksum(base58_decoded[0...-8]) == base58_decoded[-8..-1]
+    end
+
+    def checksum(hex)
+      Digest::SHA256.hexdigest(Digest::SHA256.digest([hex].pack('H*')))[0...8]
+    end
+  end
+  Bitcoin = Btc
+end

data/lib/crypto_address_validator/dash.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module CryptoAddressValidator
+  class Dash < Altcoin
+    ADDRESS_TYPES = { prod: %w[4c 10], test: %w[8c 13] }.freeze
+  end
+end

data/lib/crypto_address_validator/eth.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module CryptoAddressValidator
+  class Eth
+    attr_reader :address, :raw_address
+
+    def initialize(address_sring)
+      @address = normalize(address_sring)
+      @raw_address = address_sring
+    end
+
+    def normalize(address_sring)
+      /\A0x/.match?(address_sring) ? address_sring : "0x#{address_sring}"
+    end
+
+    def valid?(_type = nil)
+      if !valid_format?
+        false
+      elsif not_checksummed?
+        true
+      else
+        checksum_matches?
+      end
+    end
+
+    def address_type; end
+
+    private
+
+    def checksummed
+      raise "Invalid address: #{address}" unless valid_format?
+
+      cased = unprefixed.chars.zip(checksum.chars).map do |char, check|
+        /[0-7]/.match?(check) ? char.downcase : char.upcase
+      end
+
+      normalize(cased.join)
+    end
+
+    private
+
+    def checksum_matches?
+      address == checksummed
+    end
+
+    def not_checksummed?
+      all_uppercase? || all_lowercase?
+    end
+
+    def all_uppercase?
+      address.match(/(?:0[xX])[A-F0-9]{40}/)
+    end
+
+    def all_lowercase?
+      address.match(/(?:0[xX])[a-f0-9]{40}/)
+    end
+
+    def valid_format?
+      address.match(/\A(?:0[xX])[a-fA-F0-9]{40}\z/)
+    end
+
+    def checksum
+      bin_to_hex(keccak256(unprefixed.downcase))
+    end
+
+    def unprefixed
+      remove_hex_prefix address
+    end
+
+    def remove_hex_prefix(s)
+      s[0, 2] == '0x' ? s[2..-1] : s
+    end
+
+    def bin_to_hex(string)
+      string.unpack1('H*')
+    end
+
+    def keccak256(x)
+      Digest::Keccak.new(256).digest(x)
+    end
+  end
+  Ethereum = Eth
+end