exocrypto 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 675e5aafa265e33dec84cb3427d8c71afcd3fec9ab3118210be650e96c5b3101
+  data.tar.gz: eff4eeb5a746b56925a0860e6c867ced98f4bb480477c48f14cabdb777487297
+SHA512:
+  metadata.gz: 20e268da580a84adfcc9563fa2004037b41e05ef288523925d4c5fc070aa9d0f454dbcda19ae8b65a0e5abab82d144faa4e3e1dee5a5f83e25cf838f236ddb6a
+  data.tar.gz: bfff000fe68bbb3affd5360fdcc94e63b4d714812cc0402dc0c05ecab307d2782e8ec9694e5a028f851788d5db4d0b2882e0155abcaf0275935282829da224a5

data/README.md

@@ -0,0 +1,27 @@
+# ExoCrypto
+
+CryptoHelpers: This gem provides helpers for crypto calculus.
+
+  - Addresses
+  - HD Wallets
+
+[reference for gem creation: [newgem-template](https://github.com/wycats/newgem-template)]
+
+[reference for git init: [github init](https://gist.github.com/seankross/8830032)]
+
+
+## Getting started
+
+`bundle`
+
+`rake build`
+
+`gem push [GEM.gem]`
+
+
+### Requirements
+
+- Ruby 2.5+
+- Bitcoin-ruby 0.0.20
+- BIP44 0.2.18
+- ExoBasic 0.1.0

data/lib/exocrypto/bip44_wallet_provider.rb

@@ -0,0 +1,317 @@
+require 'set'
+require 'openssl'
+require 'ecdsa'
+require 'digest'
+require 'digest/sha3'
+require 'rlp'
+require 'money-tree'
+require 'bip_mnemonic'
+require 'eth'
+require "bip44/version"
+require 'bip44/utils'
+require 'bip44/bitcoin'
+require 'bip44/ethereum'
+require 'bip44/wallet'
+
+module ExoCrypto
+  # see: https://github.com/wuminzhe/bip44
+  class Bip44WalletProvider
+    TESTNET_TICKER = 'TESTNET'
+
+    # see: https://github.com/satoshilabs/slips/blob/master/slip-0044.md
+    def self.ticker_map
+      {
+        'TESTNET' => {
+          :slip => 1,
+          :precision => 8
+        },
+        'BTC' => {
+          :slip => 0,
+          :precision => 8
+        },
+        'ETH' => {
+          :slip => 60,
+          :precision => 18
+        },
+        'DASH' => {
+          :slip => 5,
+          :precision => 8
+        },
+        'DOGE' => {
+          :slip => 3,
+          :precision => 8
+        },
+        'LTC' => {
+          :slip => 2,
+          :precision => 8
+        }
+      }
+    end
+
+    def self.coins
+      Bip44WalletProvider.ticker_map.keys.to_set.delete(Bip44WalletProvider::TESTNET_TICKER)
+    end
+
+    def self.precision_of(ticker)
+      Bip44WalletProvider.ticker_map[ticker][:precision]
+    end
+
+    # see: https://github.com/citizen010/bitcoin-prefixes-address-list
+    def self.address_details(sub_wallet, is_testnet, include_private)
+      if include_private
+        {
+          :bitcoin_address => sub_wallet.bitcoin_address(testnet: is_testnet),
+          :ethereum_address => sub_wallet.ethereum_address,
+          :public_hex => sub_wallet.public_key,
+          :private_hex => sub_wallet.private_key,
+          :private_wif => sub_wallet.wif(testnet: is_testnet)
+        }
+      else
+        {
+          :bitcoin_address => sub_wallet.bitcoin_address(testnet: is_testnet),
+          :ethereum_address => sub_wallet.ethereum_address,
+          :public_hex => sub_wallet.public_key
+        }
+      end
+    end
+
+    def self.master_details(mnemonic, wallet, is_testnet)
+      {
+        :mnemonic => mnemonic,
+        :seed_hex => BipMnemonic.to_seed(mnemonic: mnemonic),
+        :xpub => wallet.xpub(testnet: is_testnet),
+        :xprv => wallet.xprv(testnet: is_testnet),
+        :details => Bip44WalletProvider.address_details(wallet, is_testnet, true)
+      }
+    end
+
+    def self.create_wallet(coin_ticker='BTC')
+      words = BipMnemonic.to_mnemonic(bits: 128)
+      seed  = BipMnemonic.to_seed(mnemonic: words)
+
+      coin    = ticker_map[coin_ticker][:slip]
+      path    = "m/44'/#{coin}'/0'"
+      wallet  = Bip44::Wallet.from_seed(seed, path)
+      testnet = coin_ticker == Bip44WalletProvider::TESTNET_TICKER
+
+      {
+        :obj => wallet,
+        :seed_hex => seed,
+        :path => path,
+        :details => Bip44WalletProvider.master_details(words, wallet, testnet)
+      }
+    end
+
+    def self.create_subwallet(xpub, sub_path, is_testnet=false)
+      wallet     = Bip44::Wallet.from_xpub(xpub)
+      sub_wallet = wallet.sub_wallet(sub_path)
+
+      {
+        :obj => sub_wallet,
+        :path => sub_path,
+        :details => Bip44WalletProvider.address_details(sub_wallet, is_testnet, false)
+      }
+    end
+
+    def self.seed_of(mnemonic, password=nil)
+      #BipMnemonic.to_seed(mnemonic: mnemonic)
+      OpenSSL::PKCS5.pbkdf2_hmac(mnemonic,
+                                 "mnemonic#{password}",
+                                 2048,
+                                 64,
+                                 OpenSSL::Digest::SHA512.new)
+                    .unpack('H*').first
+    end
+
+    def self.btc_address_details_of(seed, path, is_testnet=false)
+      wallet  = Bip44::Wallet.from_seed(seed, path)
+      details = Bip44WalletProvider.address_details(wallet, is_testnet, true)
+      details[:address] = details[:bitcoin_address]
+      details.delete(:bitcoin_address)
+      details.delete(:ethereum_address)
+      details
+    end
+
+    def self.from_absolute_path(path)
+      elements   = path.split('/')
+      derivation = "m/#{elements.take(4).drop(1).join('/')}"
+      relative   = "m/#{elements.drop(4).join('/')}"
+
+      {
+        :absolute_path => path,
+        :derivation => derivation,
+        :relative_path => relative
+      }
+    end
+
+    #
+    # see: https://gobittest.appspot.com/PrivateKey
+    #      https://github.com/dougal/base58/blob/master/lib/base58.rb
+    #      http://royalforkblog.github.io/2014/07/31/address-gen
+    #
+    def self.sha256(hex)
+      Digest::SHA256.hexdigest([hex].pack('H*'))
+    end
+
+    def self.ripemd160(hex)
+      Digest::RMD160.hexdigest([hex].pack('H*'))
+    end
+
+    def self.checksum(hex)
+      Bip44WalletProvider.sha256(Bip44WalletProvider.sha256(hex))[0...8]
+    end
+
+    def self.int_to_hex(int)
+      hex = int.to_s(16)
+      #
+      # The hex string must always consist of an even number of characters,
+      # otherwise the pack() parsing will be misaligned.
+      #
+      (hex.length % 2 == 0) ? hex : ('0' + hex)
+    end
+
+    def self.btc_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.btc_encode_base58(hex)
+      leading_zero_bytes = (hex.match(/^([0]+)/) ? $1 : '').size / 2
+      ('1' * leading_zero_bytes) + Bip44WalletProvider.btc_int_to_base58(hex.to_i(16))
+    end
+
+    def self.btc_base58_to_int(base58_val)
+      alpha         = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+      int_val, base = 0, alpha.size
+      base58_val.reverse.split(//).each_with_index do |char, index|
+        char_index = alpha.index(char)
+        int_val   += char_index * base**index
+      end
+
+      int_val
+    end
+
+    def self.btc_decode_base58(base58_val)
+      nzeroes = base58_val.chars.find_index { |c| c != '1' } || base58_val.length - 1
+      prefix  = nzeroes < 0 ? '' : '00' * nzeroes
+      decoded = Bip44WalletProvider.int_to_hex(Bip44WalletProvider.btc_base58_to_int(base58_val))
+
+      [prefix + decoded].pack('H*')
+    end
+
+    def self.btc_wif_of_privkey(hex, is_compressed=false, is_testnet=false)
+      priv_key_version = is_testnet ? 'ef' : '80'
+      data = priv_key_version + hex
+      if is_compressed
+        data += '01'
+      end
+
+      Bip44WalletProvider.btc_encode_base58(data + Bip44WalletProvider.checksum(data))
+    end
+
+    def self.btc_privkey_of_wif(wif, is_compressed=false)
+      result = Bip44WalletProvider.btc_decode_base58(wif)[1..-5].unpack('H*').first
+      if is_compressed
+        result = result[0...-2]
+      end
+      result
+    end
+
+    def self.btc_pubkey_of_wif(wif, is_compressed=false, is_testnet=false)
+      priv_key                    = Bip44WalletProvider.btc_privkey_of_wif(wif, is_compressed)
+      group                       = OpenSSL::PKey::EC::Group.new('secp256k1')
+      public_key                  = group.generator.mul(OpenSSL::BN.new(priv_key, 16))
+      decompressed_public_key_hex = public_key.to_bn.to_s(16)
+
+      # NOTE: for compression
+      public_key_hex = decompressed_public_key_hex
+      if is_compressed
+        x              = decompressed_public_key_hex[2..-1][0..63]
+        y              = decompressed_public_key_hex[2..-1][64..-1]
+        leader         = y.to_i(16) % 2 == 0 ? '02' : '03'
+        public_key_hex = leader + x
+      end
+
+      public_key_hash = Bip44WalletProvider.ripemd160(Bip44WalletProvider.sha256(public_key_hex))
+      network         = is_testnet ? '6f' : '00'
+      data            = network + public_key_hash
+
+      public_address =
+        Bip44WalletProvider.btc_encode_base58(data + Bip44WalletProvider.checksum(data))
+
+      {
+        :decompressed_public_key => decompressed_public_key_hex,
+        :public_key => public_key_hex,
+        :bitcoin_address => public_address
+      }
+    end
+    def self.btc_pubkey_of_wif_ecdsa(wif, is_compressed=false, is_testnet=false)
+      priv_key = Bip44WalletProvider.btc_privkey_of_wif(wif, is_compressed)
+
+      # kpub = kpriv * G
+      curve         = ECDSA::Group::Secp256k1
+      pub_key_point = curve.generator.multiply_by_scalar(priv_key.to_i(16))
+
+      #
+      # uncompressed, pub key is in form 0x04 + x + y
+      # compressed, pub key is in form
+      #   0x02 + x if y is even
+      #   0x03 + x if y is odd
+      # Getting encodings right is difficult...pub.x is a Bignum.  Bignum + Bignum is
+      # a biggernum, which isn't really what we want.  We want string concatenation. To do that,
+      # we translate to hex, concatenate the hex, and pack it back into a string to
+      # concatenate with our leading byte
+      #
+      # pub.x is a Bignum,
+      # so we must concatenate our compression byte with the hex representation of pub_key.x
+      #
+      decompressed_pub_key = "\x04" +
+                             [pub_key_point.x.to_s(16)].pack('H*') +
+                             [pub_key_point.y.to_s(16)].pack('H*')
+      pub_key              = decompressed_pub_key
+      if is_compressed
+        leader  = pub_key_point.y % 2 == 0 ? "\x02" : "\x03"
+        pub_key = leader + [pub_key_point.x.to_s(16)].pack('H*')
+      end
+
+      # ripe160(sha256(pub_key))
+      pub_key_hash = Digest::RMD160.digest(Digest::SHA256.digest(pub_key))
+
+      #
+      # prepend version to our double hashed pub key, append checksum
+      # Bitcoin: 0x00
+      # Testnet: 0x6f
+      #
+      network                  = is_testnet ? "\x6f" : "\x00"
+      pub_key_hash_and_version = network + pub_key_hash
+
+      # add checksum
+      pub_key_hash_and_version_str          = pub_key_hash_and_version.unpack('H*').first
+      pub_key_hash_and_version_and_checksum = pub_key_hash_and_version_str +
+                                              Bip44WalletProvider.checksum(
+                                                pub_key_hash_and_version_str)
+
+      # base58 encode version, hash, checksum
+      pub_addr = Bip44WalletProvider.btc_encode_base58(pub_key_hash_and_version_and_checksum)
+
+      {
+        :decompressed_public_key => decompressed_pub_key.unpack("H*").first,
+        :public_key => pub_key.unpack("H*").first,
+        :bitcoin_address => pub_addr
+      }
+    end
+
+    def self.btc_pubkey_of_privkey(hex, is_compressed=false, is_testnet=false)
+      priv = Bip44WalletProvider.btc_wif_of_privkey(hex, is_compressed, is_testnet)
+
+      Bip44WalletProvider.btc_pubkey_of_wif(priv, is_compressed, is_testnet)
+    end
+
+  end
+end

data/lib/exocrypto/crypto_calc.rb

@@ -0,0 +1,97 @@
+module ExoCrypto
+  class CryptoCalc
+    def self.mul(a, b)
+      BigDecimal(a) * BigDecimal(b)
+    end
+
+    def self.s_to_satoshis(amount, precision)
+      (BigDecimal(amount) * BigDecimal(10 ** precision)).to_i
+    end
+
+    def self.s_from_satoshis(amount, precision)
+      (amount / BigDecimal(10 ** precision)).to_s
+    end
+
+    def self.fixed_length_to_s(amount, precision)
+      "%.#{precision}f" % amount
+    end
+
+    def self.to_fixed_length(amount, currency)
+      precision = Bip44WalletProvider.precision_of(currency)
+      CryptoCalc.fixed_length_to_s(CryptoCalc.s_from_satoshis(amount, precision), precision)
+    end
+
+    # see: https://reinteractive.com/posts/373-diving-into-the-ruby-source-code-bigdecimal-rounding-options
+    def self.get_satoshis(currency, exchange_rate, remaining)
+      precision         = Bip44WalletProvider.precision_of(currency)
+      amount_to_be_paid = 0
+      rate              = BigDecimal(exchange_rate)
+      if !rate.zero?
+        amount_to_be_paid = BigDecimal(remaining) / rate
+        amount_to_be_paid = (amount_to_be_paid.round(precision) * BigDecimal(10 ** precision)).to_i
+      end
+
+      amount_to_be_paid
+    end
+
+    def self.do_partial_payments(request, payments)
+      epoch = ExoBasic::Timer::EPOCH.to_datetime
+      xs = payments.map do |payment|
+        if payment[:paid]
+          precision = Bip44WalletProvider.precision_of(payment[:currency])
+          satoshis  = BigDecimal(payment[:amount_paid]) * BigDecimal(payment[:exchange_rate])
+
+          [satoshis / BigDecimal(10 ** precision), payment[:date]]
+        else
+          [BigDecimal(0), epoch]
+        end
+      end
+      total_paid = xs.map { |x| x[0] }.sum
+      paid_date  = xs.map { |x| x[1] }.max
+      if paid_date == epoch
+        paid_date = nil
+      end
+      request_amount       = request[:amount]
+      request_precision    = request[:precision]
+      total_paid_rounded_s = CryptoCalc.fixed_length_to_s(total_paid.round(request_precision),
+                                                          request_precision)
+      remaining            = BigDecimal(request[:amount]) - BigDecimal(total_paid_rounded_s)
+      remaining_rounded_s  = CryptoCalc.fixed_length_to_s(remaining.round(request_precision),
+                                                          request_precision)
+      n_paid               = payments.select { |payment| payment[:paid] == true }.length
+      n_unpaid             = payments.length - n_paid
+      remaining_rounded    = BigDecimal(remaining_rounded_s)
+      needs_change         = remaining_rounded < BigDecimal(0)
+      is_fully_paid        = remaining_rounded.zero? || needs_change
+      is_partially_paid    = !is_fully_paid && remaining_rounded < BigDecimal(request_amount)
+
+      {
+        :n_paid => n_paid,
+        :n_unpaid => n_unpaid,
+        :paid_date => paid_date,
+        :amount_paid => total_paid_rounded_s,
+        :amount_remaining => remaining_rounded_s,
+        :overpaid => needs_change,
+        :is_fully_paid => is_fully_paid,
+        :is_partially_paid => is_partially_paid
+      }
+    end
+
+    def self.apply_fun(f, args)
+      args_prime = args.map { |i| BigDecimal(i) }
+
+      lambdas = {
+        'fst'         => lambda { |args| args[0] },
+        '1/fst'       => lambda { |args| 1.0 / args[0] },
+        'fst,snd'     => lambda { |args| [args[0], args[1]] },
+        'fst*snd'     => lambda { |args| args[0] * args[1] },
+        'fst/snd'     => lambda { |args| args[0] / args[1] },
+        'snd/fst'     => lambda { |args| args[1] / args[0] },
+        '1/(fst*snd)' => lambda { |args| 1.0 / (args[0] * args[1]) },
+      }
+
+      lambdas[f].call(args_prime)
+    end
+
+  end
+end

data/lib/exocrypto/network.rb

@@ -0,0 +1,19 @@
+module ExoCrypto
+  class Network
+    SETTINGS_SECTION = 'crypto_network'
+
+    @@conf = ExoBasic::Settings.loaded
+    ExoBasic::Settings.add_on_load_observer(Network)
+
+    def self.is_testnet?
+      ExoBasic::Settings.try_get_nested_key(@@conf,
+                                            false,
+                                            [Network::SETTINGS_SECTION, 'testnet'])
+    end
+
+    def self.settings_reloaded
+      @@conf = ExoBasic::Settings.loaded
+    end
+
+  end
+end

data/lib/exocrypto/version.rb

@@ -0,0 +1,3 @@
+module ExoCrypto
+  VERSION = "0.1.0"
+end

data/lib/exocrypto.rb

@@ -0,0 +1,3 @@
+require 'exocrypto/bip44_wallet_provider.rb'
+require 'exocrypto/crypto_calc.rb'
+require 'exocrypto/network.rb'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: exocrypto
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dionysios Kakolyris
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bitcoin-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.20
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.20
+- !ruby/object:Gem::Dependency
+  name: bip44
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.18
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.18
+- !ruby/object:Gem::Dependency
+  name: exobasic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: Exotic Crypto Helpers
+email:
+- contact@exotic.industries
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/exocrypto.rb
+- lib/exocrypto/bip44_wallet_provider.rb
+- lib/exocrypto/crypto_calc.rb
+- lib/exocrypto/network.rb
+- lib/exocrypto/version.rb
+homepage: https://bitbucket.org/vertigoindustries/exotic-crypto
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubygems_version: 3.0.6
+signing_key:
+specification_version: 4
+summary: CryptoHelpers
+test_files: []