adequate_crypto_address 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f7abf6ba909332001fc5fab5db12fd1177aa7d456f4a339fa3e9bda27911cb9
-  data.tar.gz: e02c961746fa7768da235cf315a9c381b1b76a82c82343cf39c6fcd290b445f7
+  metadata.gz: 396151caf8361e74bf9686d4ec10c913c6ba5f3c16a695fdf1c2a33dc3886abb
+  data.tar.gz: 51131dea9686bab8c4ea4996b53735c7db13b5d6c94869d39935b5517710b11b
 SHA512:
-  metadata.gz: c517de74d9547b1adb25fed8ac499912b2d7d0a289d2404db0b4415b8d17aff6e739149dd035d98a0e65cd72a1c5b13855d9ebd5d7185736d9640cc539eb8561
-  data.tar.gz: e68fb7d7efb67f867d01e90a5ffec8d766df845643bb3a938952b229251f55fd9fec0baa84253073d79ae832f304fa7f04fa94ddcad39a24ff2625df6a166fd2
+  metadata.gz: d0bb08404d180ee04be259d804aa298009136b57bfe023c3296bc09c792dca7e292a50f87a481e472210dacde055c58aff88b8c4f69800eacd566dac25b5451b
+  data.tar.gz: 4c18a2e6cdd22d5ac0e66eeb5bfcf2583f0114e945ea20a84aab8ab40d968f01848229e8e2d731d4f8b9b7499ba5af52a7c08d270eca6d64cd9700506050211f

data/README.md

@@ -1,4 +1,7 @@
 # AdequateCryptoAddress
+Simple wallet address validator and normalizer for cryptocurrencies addresses in Ruby.
+
+Inspired by [ognus/wallet-address-validator](https://github.com/ognus/wallet-address-validator).
 
 [![Gem Version](https://badge.fury.io/rb/adequate_crypto_address.svg)](https://rubygems.org/gems/adequate_crypto_address)
 [![Build Status](https://travis-ci.org/vtm9/adequate_crypto_address.svg?branch=master)](https://travis-ci.org/vtm9/adequate_crypto_address)
@@ -6,9 +9,6 @@
 [![Coverage Status](https://coveralls.io/repos/vtm9/adequate_crypto_address/badge.svg?branch=master)](https://coveralls.io/r/vtm9/adequate_crypto_address?branch=master)
 [![License](https://img.shields.io/github/license/RubyMoney/money.svg)](https://opensource.org/licenses/MIT)
 
-
-
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -17,13 +17,31 @@ Add this line to your application's Gemfile:
 gem 'adequate_crypto_address'
 ```
 
-And then execute:
+Or install it yourself as:
+
+```bash
+gem install adequate_crypto_address
+```
+
+## Main API
 
-    $ bundle
+##### .valid? (address [, currency = 'BTC'[, type = :prod]])
 
-Or install it yourself as:
+###### 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. Not all currencies support types.
 
-    $ gem install adequate_crypto_address
+> 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
 
@@ -36,8 +54,7 @@ AdequateCryptoAddress.valid?('3NJZLcZEEYBpxYEUGewU4knsQRn1WM5Fkt', :bitcoin, :p2
 
 # BCH
 AdequateCryptoAddress.valid?('bitcoincash:qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk', :bch) #=> true
-AdequateCryptoAddress.valid?('mmRH4e9WW4ekZUP5HvBScfUyaSUjfQRyvD', :BCH, :P2PKHTestnet) #=> true
-AdequateCryptoAddress.valid?('qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk', :BCH, :bitcoincash) #=> true
+AdequateCryptoAddress.valid?('mmRH4e9WW4ekZUP5HvBScfUyaSUjfQRyvD', :BCH, :p2pkhtest) #=> true
 
 # ETH
 AdequateCryptoAddress.valid?('0xde709f2102306220921060314715629080e2fb77', :ETH) #=> true
@@ -49,13 +66,19 @@ AdequateCryptoAddress.valid?('de709f2102306220921060314715629080e2fb77', :ethere
 require 'adequate_crypto_address'
 
 # BCH
-AdequateCryptoAddress.address('qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk', 'bch').address #=> "bitcoincash:qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk"
 AdequateCryptoAddress.address('mmRH4e9WW4ekZUP5HvBScfUyaSUjfQRyvD', 'bch').cash_address #=> "bchtest:qpqtmmfpw79thzq5z7s0spcd87uhn6d34uqqem83hf"
 AdequateCryptoAddress.address('bitcoincash:qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk', 'bch').legacy_address #=> "1LcerwTc1oPsMtByDCNUXFxReZpN1EXHoe"
 
+address_string = 'qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk'
+addr = AdequateCryptoAddress.address(address_string, 'bch')
+addr.prefix #=> "bitcoincash"
+addr.type #=> :p2pkh
+addr.address #=> "bitcoincash:qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk"
+
 # ETH
 AdequateCryptoAddress.address('D1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb', 'eth').address #=> "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb"
 ```
+*Not all currencies support this feature.
 
 ## Development
 

data/lib/adequate_crypto_address.rb

@@ -1,10 +1,13 @@
 require 'adequate_crypto_address/utils/bech32'
 require 'adequate_crypto_address/utils/bch'
 
+require 'adequate_crypto_address/altcoin'
+require 'adequate_crypto_address/bch'
 require 'adequate_crypto_address/eth'
 require 'adequate_crypto_address/btc'
-require 'adequate_crypto_address/bch'
-
+require 'adequate_crypto_address/xrp'
+require 'adequate_crypto_address/dash'
+require 'adequate_crypto_address/zec'
 
 module AdequateCryptoAddress
   class UnknownCurrency < StandardError; end

data/lib/adequate_crypto_address/altcoin.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module AdequateCryptoAddress
+  # 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/adequate_crypto_address/bch.rb

@@ -12,16 +12,16 @@ module AdequateCryptoAddress
 
     TYPE_MAP = {
       legacy: [
-        [:P2SH, 5],
-        [:P2PKH, 0],
-        [:P2SHTestnet, 196],
-        [:P2PKHTestnet, 111]
+        [:p2sh, 5],
+        [:p2pkh, 0],
+        [:p2shtest, 196],
+        [:p2pkhtest, 111]
       ],
       cash: [
-        [:P2SH, 8],
-        [:P2PKH, 0],
-        [:P2SHTestnet, 8],
-        [:P2PKHTestnet, 0]
+        [:p2sh, 8],
+        [:p2pkh, 0],
+        [:p2shtest, 8],
+        [:p2pkhtest, 0]
       ]
     }.freeze
     DEFAULT_PREFIX = :bitcoincash
@@ -35,8 +35,6 @@ module AdequateCryptoAddress
 
     def valid?(validated_type = nil)
       if validated_type
-        puts type
-        puts validated_type
         type == validated_type.to_sym
       else
         !type.nil?
@@ -97,8 +95,8 @@ module AdequateCryptoAddress
       @type = address_type(:cash, converted[0].to_i)[0]
       @payload = converted[1..-7]
 
-      @type = :P2SHTestnet if prefix == 'bchtest' && type == :P2SH
-      @type = :P2PKHTestnet if prefix == 'bchtest' && type == :P2PKH
+      @type = :p2shtest if prefix == 'bchtest' && type == :p2sh
+      @type = :p2pkhtest if prefix == 'bchtest' && type == :p2pkh
     end
 
     def from_legacy_string
@@ -114,9 +112,9 @@ module AdequateCryptoAddress
       @digest = decoded[-4..-1]
       @prefix = DEFAULT_PREFIX
 
-      @type = :P2SHTestnet if prefix == 'bchtest' && type == :P2SH
-      @type = :P2PKHTestnet if prefix == 'bchtest' && type == :P2PKH
-      @prefix = 'bchtest' if [:P2SHTestnet, :P2PKHTestnet].include?(type)
+      @type = :p2shtest if prefix == 'bchtest' && type == :p2sh
+      @type = :p2pkhtest if prefix == 'bchtest' && type == :p2pkh
+      @prefix = 'bchtest' if [:p2shtest, :p2pkhtest].include?(type)
     end
   end
 

data/lib/adequate_crypto_address/btc.rb

@@ -2,11 +2,12 @@
 
 module AdequateCryptoAddress
   class Btc
-    attr_reader :address
+    attr_reader :address, :type
     alias raw_address address
 
     def initialize(address)
       @address = address
+      @type = address_type
     end
 
     def valid?(type = nil)
@@ -17,6 +18,8 @@ module AdequateCryptoAddress
       end
     end
 
+    private
+
     def address_type
       segwit_decoded = begin
                          decode_segwit_address
@@ -32,13 +35,13 @@ module AdequateCryptoAddress
         return :segwit_v0_scripthash if witness_version == 0 && witness_program.bytesize == 32
       end
 
-      hex = begin
+      base58_decoded = begin
               decode_base58(address)
             rescue StandardError
               nil
             end
-      if hex && hex.bytesize == 50 && address_checksum?
-        case hex[0...2]
+      if base58_decoded && base58_decoded.bytesize == 50 && valid_base58_address_checksum?(base58_decoded)
+        case base58_decoded[0...2]
         when '00'
           return :hash160
         when '05'
@@ -49,8 +52,6 @@ module AdequateCryptoAddress
       nil
     end
 
-    private
-
     def decode_segwit_address
       actual_hrp, data = Utils::Bech32.decode(address)
 
@@ -72,29 +73,18 @@ module AdequateCryptoAddress
       [data[0], program_hex]
     end
 
-    def decode_base58(base58_val)
-      s = Base58.base58_to_int(address, :bitcoin).to_s(16); s = (s.bytesize.odd? ? '0' + s : s)
-      s = '' if s == '00'
-      leading_zero_bytes = (base58_val =~ /^([1]+)/ ? Regexp.last_match(1) : '').size
-      s = ('00' * leading_zero_bytes) + s if leading_zero_bytes > 0
-      s
+    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 address_checksum?
-      hex = begin
-              decode_base58(address)
-            rescue StandardError
-              nil
-            end
-      return false unless hex
+    def valid_base58_address_checksum?(base58_decoded)
+      return false unless base58_decoded
 
-      checksum(hex[0...42]) == hex[-8..-1]
+      checksum(base58_decoded[0...-8]) == base58_decoded[-8..-1]
     end
 
-    # checksum is a 4 bytes sha256-sha256 hexdigest.
     def checksum(hex)
-      b = [hex].pack('H*') # unpack hex
-      Digest::SHA256.hexdigest(Digest::SHA256.digest(b))[0...8]
+      Digest::SHA256.hexdigest(Digest::SHA256.digest([hex].pack('H*')))[0...8]
     end
   end
   Bitcoin = Btc

data/lib/adequate_crypto_address/dash.rb

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

data/lib/adequate_crypto_address/version.rb

@@ -1,3 +1,3 @@
 module AdequateCryptoAddress
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.1.3'.freeze
 end

data/lib/adequate_crypto_address/xrp.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module AdequateCryptoAddress
+  class Xrp < Altcoin
+    ADDRESS_TYPES = { common: %w[00] }.freeze
+    ALPHABET_TYPE = :ripple
+  end
+  Ripple = Xrp
+end

data/lib/adequate_crypto_address/zec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module AdequateCryptoAddress
+  class Zec < Altcoin
+    EXPECTED_LENGTH = 52
+    ADDRESS_TYPES = { prod: %w[1cb8 1cbd], test: %w[1d25 1cba] }.freeze
+  end
+  Zcash = Zec
+end

data/spec/adequate_crypto_address_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe(AdequateCryptoAddress) do
       it 'validates segwit addresses' do
         expect(described_class).to be_valid('BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4', 'BTC')
         expect(described_class).to be_valid('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'bitcoin')
-        expect(described_class).to be_valid('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'bitcoin', 'segwit_v0_keyhash')
+        expect(described_class).to be_valid('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'bitcoin', :segwit_v0_keyhash)
         expect(described_class).to be_valid('bc1qc7slrfxkknqcq2jevvvkdgvrt8080852dfjewde450xdlk4ugp7szw5tk9', 'BTC')
         expect(described_class).to be_valid('bc1qc7slrfxkknqcq2jevvvkdgvrt8080852dfjewde450xdlk4ugp7szw5tk9', 'bitcoin', 'segwit_v0_scripthash')
       end
@@ -41,23 +41,23 @@ RSpec.describe(AdequateCryptoAddress) do
 
     context 'Bitcoincash' do
       it 'validates legacy addresses' do
-        expect(described_class).to be_valid('3CWFddi6m4ndiGyKqzYvsFYagqDLPVMTzC', :bch, :P2SH)
-        expect(described_class).to be_valid('155fzsEBHy9Ri2bMQ8uuuR3tv1YzcDywd4', 'bitcoincash', :P2PKH)
-        expect(described_class).to be_valid('2MzQwSSnBHWHqSAqtTVQ6v47XtaisrJa1Vc', 'BCH', :P2SHTestnet)
-        expect(described_class).to be_valid('mmRH4e9WW4ekZUP5HvBScfUyaSUjfQRyvD', :BCH, :P2PKHTestnet)
+        expect(described_class).to be_valid('3CWFddi6m4ndiGyKqzYvsFYagqDLPVMTzC', :bch, :p2sh)
+        expect(described_class).to be_valid('155fzsEBHy9Ri2bMQ8uuuR3tv1YzcDywd4', 'bitcoincash', :p2pkh)
+        expect(described_class).to be_valid('2MzQwSSnBHWHqSAqtTVQ6v47XtaisrJa1Vc', 'BCH', :p2shtest)
+        expect(described_class).to be_valid('mmRH4e9WW4ekZUP5HvBScfUyaSUjfQRyvD', :BCH, :p2pkhtest)
       end
 
       it 'validates cash addresses' do
-        expect(described_class).to be_valid('bitcoincash:qqkv9wr69ry2p9l53lxp635va4h86wv435995w8p2h', :bch, :P2PKH)
-        expect(described_class).to be_valid('bitcoincash:pqdg9uq52wzhf228hweext9j2jdjgdpj9qt7xxfngd', :bitcoincash, :P2SH)
-        expect(described_class).to be_valid('bchtest:qpqtmmfpw79thzq5z7s0spcd87uhn6d34uqqem83hf', :Bitcoincash, :P2PKHTestnet)
-        expect(described_class).to be_valid('bchtest:pp8f7ww2g6y07ypp9r4yendrgyznysc9kqxh6acwu3', :BCH, :P2SHTestnet)
+        expect(described_class).to be_valid('bitcoincash:qqkv9wr69ry2p9l53lxp635va4h86wv435995w8p2h', :bch, :p2pkh)
+        expect(described_class).to be_valid('bitcoincash:pqdg9uq52wzhf228hweext9j2jdjgdpj9qt7xxfngd', :bitcoincash, :p2sh)
+        expect(described_class).to be_valid('bchtest:qpqtmmfpw79thzq5z7s0spcd87uhn6d34uqqem83hf', :Bitcoincash, :p2pkhtest)
+        expect(described_class).to be_valid('bchtest:pp8f7ww2g6y07ypp9r4yendrgyznysc9kqxh6acwu3', :BCH, :p2shtest)
         expect(described_class).to be_valid('bitcoincash:qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk', :bitcoincash)
       end
 
       it 'validates cash addresses without prefix addresses' do
         expect(described_class).to be_valid('qrtj3rd8524cndt2eew3s6wljqggmne00sgh4kfypk', :bitcoincash)
-        expect(described_class).to be_valid('pqdg9uq52wzhf228hweext9j2jdjgdpj9qt7xxfngd', :bitcoincash, :P2SH)
+        expect(described_class).to be_valid('pqdg9uq52wzhf228hweext9j2jdjgdpj9qt7xxfngd', :bitcoincash, :p2sh)
       end
 
       it 'validates wrong addresses' do
@@ -66,10 +66,10 @@ RSpec.describe(AdequateCryptoAddress) do
         expect(described_class).not_to be_valid('bitcoincash:wrong', :bch)
         expect(described_class).not_to be_valid('bitcoincash:123', :bch)
 
-        expect(described_class).not_to be_valid('bitcoincash:qqkv9wr69ry2p9l53lxp635va4h86wv435995w8p2h', :bch, :P2PKHTestnet)
-        expect(described_class).not_to be_valid('bitcoincash:pqdg9uq52wzhf228hweext9j2jdjgdpj9qt7xxfngd', :bitcoincash, :P2PKHTestnet)
-        expect(described_class).not_to be_valid('bchtest:qpqtmmfpw79thzq5z7s0spcd87uhn6d34uqqem83hf', :Bitcoincash, :P2SH)
-        expect(described_class).not_to be_valid('bchtest:pp8f7ww2g6y07ypp9r4yendrgyznysc9kqxh6acwu3', :BCH, :P2SH)
+        expect(described_class).not_to be_valid('bitcoincash:qqkv9wr69ry2p9l53lxp635va4h86wv435995w8p2h', :bch, :p2pkhtest)
+        expect(described_class).not_to be_valid('bitcoincash:pqdg9uq52wzhf228hweext9j2jdjgdpj9qt7xxfngd', :bitcoincash, :p2pkhtest)
+        expect(described_class).not_to be_valid('bchtest:qpqtmmfpw79thzq5z7s0spcd87uhn6d34uqqem83hf', :Bitcoincash, :p2sh)
+        expect(described_class).not_to be_valid('bchtest:pp8f7ww2g6y07ypp9r4yendrgyznysc9kqxh6acwu3', :BCH, :p2sh)
       end
     end
 
@@ -83,6 +83,7 @@ RSpec.describe(AdequateCryptoAddress) do
         expect(described_class).to be_valid('0x8617E340B3D01FA5F11F306F4090FD50E238070D', 'ETH')
         expect(described_class).to be_valid('0xde709f2102306220921060314715629080e2fb77', 'ETH')
       end
+
       it 'validates without prefixes addresses' do
         expect(described_class).to be_valid('27b1fdb04752bbc536007a920d24acb045561c26', 'ETH')
         expect(described_class).to be_valid('5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed', 'ETH')
@@ -96,6 +97,51 @@ RSpec.describe(AdequateCryptoAddress) do
         expect(described_class).not_to be_valid('a10354276d2fC74ee91e37D085d35748613f4748', :ethereum)
       end
     end
+
+    context 'Ripple' do
+      it 'validates addresses' do
+        expect(described_class).to be_valid('rPMLwSwyyULN2acf5JKB1nj8F8Eu8pVMV8', :ripple)
+        expect(described_class).to be_valid('rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn', :ripple)
+        expect(described_class).to be_valid('rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn', 'RIPPLE')
+        expect(described_class).to be_valid('r3kmLJN5D28dHuH8vZNUZpMC43pEHpaocV', 'XRP')
+        expect(described_class).to be_valid('rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', :XRP)
+        expect(described_class).to be_valid('rDTXLQ7ZKZVKz33zJbHjgVShjsBnqMBhmN', 'XRP')
+      end
+
+      it 'validates wrong addresses' do
+        expect(described_class).not_to be_valid('r3kmLJN5D28dHuH8vZNUZpMC43pEHpaoc1', :xrp)
+        expect(described_class).not_to be_valid('r1kmLJN5D28dHuH8vZNUZpMC43pEHpaocV', 'ripple')
+      end
+    end
+
+    context 'Dash' do
+      it 'validates addresses' do
+        expect(described_class).to be_valid('Xx4dYKgz3Zcv6kheaqog3fynaKWjbahb6b', :dash)
+        expect(described_class).to be_valid('XcY4WJ6Z2Q8w7vcYER1JypC8s2oa3SQ1b1', 'DASH')
+        expect(described_class).to be_valid('XqMkVUZnqe3w4xvgdZRtZoe7gMitDudGs4', 'DASH', :prod)
+        expect(described_class).to be_valid('yPv7h2i8v3dJjfSH4L3x91JSJszjdbsJJA', :DASH, 'test')
+      end
+
+      it 'validates wrong addresses' do
+        expect(described_class).not_to be_valid('yPv7h2i8v3dJ1fSH4L3x91JSJszjdbsJJA', :dash)
+        expect(described_class).not_to be_valid('XqMkVUZnqe3w4xvgdZRtZoe7gMitDudGs4', 'dash', :test)
+        expect(described_class).not_to be_valid('yPv7h2i8v3dJjfSH4L3x91JSJszjdbsJJA', :DASH, :prod)
+      end
+    end
+
+    context 'Zcash' do
+      it 'validates addresses' do
+        expect(described_class).to be_valid('t1U9yhDa5XEjgfnTgZoKddeSiEN1aoLkQxq', :zec)
+        expect(described_class).to be_valid('t3Vz22vK5z2LcKEdg16Yv4FFneEL1zg9ojd', 'zcash', :prod)
+        expect(described_class).to be_valid('t2UNzUUx8mWBCRYPRezvA363EYXyEpHokyi', 'ZEC', :test)
+      end
+
+      it 'validates wrong addresses' do
+        expect(described_class).not_to be_valid('t1Y9yhDa5XEjgfnTgZoKddeSiEN1aoLkQxq', :zcash)
+        expect(described_class).not_to be_valid('t3Yz22vK5z2LcKEdg16Yv4FFneEL1zg9ojd', :ZEC)
+        expect(described_class).not_to be_valid('t2YNzUUx8mWBCRYPRezvA363EYXyEpHokyi', :zcash, :test)
+      end
+    end
   end
 
   describe '.address' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adequate_crypto_address
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - vtm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-20 00:00:00.000000000 Z
+date: 2018-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base58
@@ -98,12 +98,16 @@ files:
 - adequate_crypto_address.gemspec
 - bin/console
 - lib/adequate_crypto_address.rb
+- lib/adequate_crypto_address/altcoin.rb
 - lib/adequate_crypto_address/bch.rb
 - lib/adequate_crypto_address/btc.rb
+- lib/adequate_crypto_address/dash.rb
 - lib/adequate_crypto_address/eth.rb
 - lib/adequate_crypto_address/utils/bch.rb
 - lib/adequate_crypto_address/utils/bech32.rb
 - lib/adequate_crypto_address/version.rb
+- lib/adequate_crypto_address/xrp.rb
+- lib/adequate_crypto_address/zec.rb
 - spec/adequate_crypto_address/bch_spec.rb
 - spec/adequate_crypto_address_spec.rb
 - spec/spec_helper.rb