axentro-rb-util 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d00fc176356de2e02ba47caa16f5459c41c0d9a2ce022b7e22aa380f7fab9cde
+  data.tar.gz: 673c47711f9fbd2ff8d401c3c070f85c6421a4e4f8b3cdffe85553b7eed5857b
+SHA512:
+  metadata.gz: a81510252a00f751a1e242f50b1401e4acdc1204d511ac7265e6a92a54c162db3d790c19ef61b767452cfc171b73dac63d95b295fa1c96905fc0b2b288c821eb
+  data.tar.gz: 5c0ac4441f07ce2e59d72aa7bdc946a7f0dce57f1e5bd15149df05c638fefd9e2d8b20fb6c3c6cc82723066e1592bf5c06f7d900108db3583a24cb0f12fdff18

data/lib/axentro-rb-util.rb

@@ -0,0 +1,17 @@
+require "json"
+require "securerandom"
+require 'bigdecimal'
+require "ed25519-hd"
+require "faraday"
+require "crypto/crypto"
+require "crypto/hashes"
+require "crypto/keys/address"
+require "crypto/keys/key_utils"
+require "crypto/keys/private_key"
+require "crypto/keys/public_key"
+require "crypto/keys/wif"
+require "crypto/key_ring"
+require "crypto/transaction"
+
+include Crypto
+include Keys

data/lib/crypto/crypto.rb

@@ -0,0 +1,2 @@
+module Crypto
+end

data/lib/crypto/hashes.rb

@@ -0,0 +1,13 @@
+require "digest"
+
+module Crypto::Hashes
+  extend self
+
+  def sha256(base)
+    Digest::SHA256.hexdigest(base)
+  end
+
+  def ripemd160(base)
+    Digest::RMD160.hexdigest(base)
+  end
+end

data/lib/crypto/key_ring.rb

@@ -0,0 +1,53 @@
+module Crypto::Keys
+  include Crypto::Hashes
+
+  MAINNET = { prefix: "M0", name: "mainnet" }
+  TESTNET = { prefix: "T0", name: "testnet" }
+
+  class KeyRing
+    attr_reader :private_key
+    attr_reader :public_key
+    attr_reader :wif
+    attr_reader :address
+    attr_reader :address
+    attr_reader :seed
+
+    def initialize(private_key, public_key, wif, address, seed = nil)
+      @private_key = private_key
+      @public_key = public_key
+      @wif = wif
+      @address = address
+      @seed = seed
+    end
+
+    def self.generate(network = MAINNET)
+      key_pair = KeyUtils.create_new_keypair
+      private_key = PrivateKey.new(key_pair[:hex_private_key], network)
+      public_key = PublicKey.new(key_pair[:hex_public_key], network)
+      KeyRing.new(private_key, public_key, private_key.wif, public_key.address)
+    end
+
+    def self.generate_hd(seed = nil, derivation = nil, network = MAINNET)
+      _seed = seed.nil? ? SecureRandom.hex(64) : seed
+      keys = (derivation.nil? || derivation.nil? && derivation == "m") ?
+        HDKEY::KeyRing.get_master_key_from_seed(_seed) : HDKEY::KeyRing.derive_path(derivation, _seed, HDKEY::HARDENED_AXENTRO)
+
+      private_key = PrivateKey.new(keys.private_key, network)
+      _public_key = HDKEY::KeyRing.get_public_key(keys.private_key)[2..-1]
+      public_key = PublicKey.new(_public_key, network)
+      KeyRing.new(private_key, public_key, private_key.wif, public_key.address, _seed)
+    end
+
+    def self.is_valid?(public_key, wif, address)
+      address = Address.from(address)
+      wif = Wif.new(wif)
+
+      raise AxentroError, "network mismatch between address and wif" if address.network != wif.network
+
+      public_key = PublicKey.from_hex(public_key, address.network)
+      raise AxentroError, "public key mismatch between public key and wif" if public_key.as_hex != wif.public_key.as_hex
+
+      true
+    end
+  end
+end

data/lib/crypto/keys/address.rb

@@ -0,0 +1,66 @@
+require "base64"
+
+class AxentroError < StandardError
+end
+
+module Crypto::Keys
+  class Address
+    attr_reader :network
+
+    def initialize(hex_address, network = MAINNET, name = "generic")
+      @hex_address = hex_address
+      @network = network
+      @name = name
+      unless is_valid?
+        raise AxentroError, "invalid '#{@name}' address checksum for: '#{@hex_address}'"
+      end
+    end
+
+    def as_hex
+      @hex_address
+    end
+
+    def self.from(hex_address, name = "")
+      network = get_network_from_address(hex_address)
+      Address.new(hex_address, network, name)
+    end
+
+    def is_valid?
+      Address.is_valid?(@hex_address)
+    end
+
+    def self.is_valid?(hex_address)
+      begin
+        decoded_address = Base64.strict_decode64(hex_address)
+        return false unless decoded_address.size == 48
+        version_address = decoded_address[0..-7]
+        hashed_address = Crypto::Hashes.sha256(Crypto::Hashes.sha256(version_address))
+        checksum = decoded_address[-6..-1]
+        checksum == hashed_address[0..5]
+      rescue AxentroError => e
+        false
+      end
+    end
+
+    def self.get_network_from_address(hex_address)
+      begin
+        decoded_address = Base64.strict_decode64(hex_address)
+      rescue => e
+        raise AxentroError, "invalid address: #{e}"
+      end
+
+      case decoded_address[0..1]
+      when MAINNET[:prefix]
+        MAINNET
+      when TESTNET[:prefix]
+        TESTNET
+      else
+        raise AxentroError, "invalid network: #{decoded_address[0..1]} for address: #{hex_address}"
+      end
+    end
+
+    def to_s
+      as_hex
+    end
+  end
+end

data/lib/crypto/keys/key_utils.rb

@@ -0,0 +1,61 @@
+module Crypto::Keys
+    class KeyUtils
+        def self.verify_signature(message, signature_hex, hex_public_key)
+            begin
+            verify_key = Ed25519::VerifyKey.new([hex_public_key].pack("H*"))
+            verify_key.verify([signature_hex].pack("H*"), message)
+            rescue => e
+                raise AxentroError, "Verify fail: #{e.message}"
+            end
+        end
+
+        def self.sign(hex_private_key, message)
+            signing_key = Ed25519::SigningKey.new([hex_private_key].pack("H*"))
+            signing_key.sign(message).unpack("H*").first
+        end
+
+        def self.create_new_keypair
+            signing_key = Ed25519::SigningKey.generate
+            private_key = signing_key.keypair.unpack("H*").first[0..63]
+            public_key = signing_key.keypair.unpack("H*").first[64..-1]
+            {
+                hex_private_key: private_key,
+                hex_public_key: public_key
+            }
+        end
+
+        def self.to_hex(bytes)
+            bytes.pack("c*").unpack("H*").first
+        end
+
+        def self.to_bytes(hex)
+            [hex].pack('H*').bytes.to_a
+        end
+
+        def self.get_address_from_public_key(public_key)
+            hashed_address = Crypto::Hashes.ripemd160(Crypto::Hashes.sha256(public_key.as_hex))
+            network_address = public_key.network[:prefix] + hashed_address
+            hashed_address_again = Crypto::Hashes.sha256(Crypto::Hashes.sha256(network_address))
+            checksum = hashed_address_again[0..5]
+            Base64.strict_encode64(network_address + checksum)
+        end
+
+        def self.to_wif(key, network)
+            private_key = key.as_hex
+            network_key = network[:prefix] + private_key
+            hashed_key = Crypto::Hashes.sha256(Crypto::Hashes.sha256(network_key))
+            checksum = hashed_key[0..5]
+            encoded_key = Base64.strict_encode64(network_key + checksum)
+            Wif.new(encoded_key)
+        end
+
+        def self.from_wif(wif)
+            decoded_wif = Base64.strict_decode64(wif.as_hex)
+            network_prefix = decoded_wif[0..1]
+            network = network_prefix == "M0" ? MAINNET : TESTNET
+            private_key_hex = decoded_wif[2..-7]
+            private_key = PrivateKey.from_hex(private_key_hex)
+            {private_key: private_key, network: network}
+        end
+    end
+end

data/lib/crypto/keys/private_key.rb

@@ -0,0 +1,45 @@
+module Crypto::Keys
+    class PrivateKey
+        attr_reader :network
+
+        def initialize(private_key_hex, network = MAINNET)
+            @private_key_hex = private_key_hex
+            @network = network
+            raise AxentroError, "invalid private key: '#{@private_key_hex}'" unless is_valid?
+        end
+
+        def self.from_hex(hex, network = MAINNET)
+            PrivateKey.new(hex, network)
+        end
+
+        def self.from_bytes(bytes, network = MAINNET)
+            PrivateKey.new(KeyUtils.to_hex(bytes), network)
+        end
+
+        def as_hex
+            @private_key_hex
+        end
+
+        def as_bytes
+            KeyUtils.to_bytes(@private_key_hex)
+        end
+
+        def wif 
+            Wif.from(self, @network)
+        end
+
+        def public_key
+            signing_key = Ed25519::SigningKey.new([@private_key_hex].pack("H*"))
+            hex_public_key = signing_key.keypair.unpack("H*").first[64..-1]
+            PublicKey.new(hex_public_key, @network)
+        end
+
+        def address 
+            Address.new(KeyUtils.get_address_from_public_key(self.public_key), @network)
+        end
+
+        def is_valid?
+            !@private_key_hex.nil? && @private_key_hex.size == 64
+        end
+    end
+end

data/lib/crypto/keys/public_key.rb

@@ -0,0 +1,35 @@
+module Crypto::Keys
+    class PublicKey
+        attr_reader :network
+
+        def initialize(public_key_hex, network = MAINNET)
+            @public_key_hex = public_key_hex
+            @network = network
+            raise AxentroError, "invalid public key: #{@public_key_hex}" unless is_valid?
+        end
+
+        def self.from_hex(hex, network = MAINNET)
+            PublicKey.new(hex, network)
+        end
+
+        def self.from_bytes(bytes, network = MAINNET)
+            PublicKey.new(KeyUtils.to_hex(bytes), network)
+        end
+
+        def as_hex
+            @public_key_hex
+        end
+
+        def as_bytes
+         KeyUtils.to_bytes(@public_key_hex)
+        end
+
+        def address
+            Address.new(KeyUtils.get_address_from_public_key(self), @network)
+        end
+
+        def is_valid?
+            !@public_key_hex.nil? && @public_key_hex.size == 64
+        end
+    end
+end

data/lib/crypto/keys/wif.rb

@@ -0,0 +1,49 @@
+module Crypto::Keys
+    class Wif
+        def initialize(wif_hex)
+            @wif_hex = wif_hex
+            raise AxentroError, "invalid wif: #{@wif_hex}" unless is_valid?
+        end
+
+        def as_hex
+            @wif_hex
+        end
+
+        def self.from(private_key, network = MAINNET)
+            wif = KeyUtils.to_wif(private_key, network)
+            raise AxentroError, "invalid wif: #{wif.as_hex}" unless wif.is_valid?
+            wif
+        end
+
+        def private_key
+            KeyUtils.from_wif(self)[:private_key]
+        end
+
+        def public_key
+            KeyUtils.from_wif(self)[:private_key].public_key
+        end
+
+        def network
+            KeyUtils.from_wif(self)[:network]
+        end
+
+        def address 
+            res = KeyUtils.from_wif(self)
+            public_key = res[:private_key].public_key
+            network = res[:network]
+            Address.new(KeyUtils.get_address_from_public_key(public_key), network)
+        end
+
+        def is_valid?
+            begin
+            decoded_wif = Base64.strict_decode64(@wif_hex)
+            network_key = decoded_wif[0..-7]
+            hashed_key = Crypto::Hashes.sha256(Crypto::Hashes.sha256(network_key))
+            checksum = hashed_key[0..5]
+            checksum == decoded_wif[-6..-1]
+            rescue 
+                false
+            end
+        end
+    end
+end

data/lib/crypto/transaction.rb

@@ -0,0 +1,57 @@
+module Crypto::Transaction
+  extend self
+  SCALE_DECIMAL = 100000000
+
+  def create_signed_send_transaction(from_address, from_public_key, wif, to_address, amount, fee = "0.0001", speed = "FAST")
+    from_private_key = __get_private_key_from_wif(wif)
+    __create_signed_send_token_transaction(from_address, from_public_key, from_private_key, to_address, amount, fee, speed)
+  end
+
+  def post_transaction(transaction_json, url = "https://mainnet.axentro.io")
+    begin
+      response = Faraday.post("#{url}/api/v1/transaction", transaction_json, "Content-Type" => "application/json")
+      raise "status code was: #{response.status}" if response.status != 200
+      json_response = JSON.parse(response.body)
+      json_response["result"]["id"].to_s
+    rescue => e
+      puts "Error sending transaction: #{e}"
+    end
+  end
+
+  def __create_signed_send_token_transaction(from_address, from_public_key, from_private_key, to_address, amount, fee = "0.0001", speed = "FAST")
+    transaction_id = __create_id
+    timestamp = __timestamp
+    scaled_amount = __scale_i64(amount)
+    scaled_fee = __scale_i64(fee)
+
+    unsigned_transaction = %Q{{"id":"#{transaction_id}","action":"send","senders":[{"address":"#{from_address}","public_key":"#{from_public_key}","amount":#{scaled_amount},"fee":#{scaled_fee},"signature":"0"}],"recipients":[{"address":"#{to_address}","amount":#{scaled_amount}}],"message":"","token":"AXNT","prev_hash":"0","timestamp":#{timestamp},"scaled":1,"kind":"#{speed}","version":"V1"}}
+
+    payload_hash = Hashes.sha256(unsigned_transaction)
+    signature = KeyUtils.sign(from_private_key, payload_hash)
+    signed_transaction = __to_signed(unsigned_transaction, signature)
+
+    %Q{{"transaction": #{signed_transaction}}}
+  end
+
+  def __create_id
+    tmp_id = SecureRandom.hex(32)
+    return __create_id if tmp_id[0] == "0"
+    tmp_id
+  end
+
+  def __timestamp
+    Time.now.to_i * 1000
+  end
+
+  def __to_signed(unsigned_transaction, signature)
+    unsigned_transaction.gsub(%Q{"signature":"0"}, %Q{"signature":"#{signature}"})
+  end
+
+  def __get_private_key_from_wif(wif)
+    Base64.strict_decode64(wif)[2..-7]
+  end
+
+  def __scale_i64(value)
+    (BigDecimal(value) * SCALE_DECIMAL).to_i
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: axentro-rb-util
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kingsley Hendrickse
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.4
+  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.4
+- !ruby/object:Gem::Dependency
+  name: ed25519-hd-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Sending transactions
+email: kingsley@axentro.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/axentro-rb-util.rb
+- lib/crypto/crypto.rb
+- lib/crypto/hashes.rb
+- lib/crypto/key_ring.rb
+- lib/crypto/keys/address.rb
+- lib/crypto/keys/key_utils.rb
+- lib/crypto/keys/private_key.rb
+- lib/crypto/keys/public_key.rb
+- lib/crypto/keys/wif.rb
+- lib/crypto/transaction.rb
+homepage: https://rubygems.org/gems/axentro-rb-util
+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: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Tools for Axentro blockchain crypto in Ruby
+test_files: []