neb 0.1.0

data/lib/neb/public_key.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  class PublicKey
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    # skip the type flag, 04
+    def to_s
+      encode(:hex)[2..-1]
+    end
+
+    def encode(fmt)
+      case fmt
+      when :decimal
+        value
+      when :bin
+        "\x04#{BaseConvert.encode(value[0], 256, 32)}#{BaseConvert.encode(value[1], 256, 32)}"
+      when :bin_compressed
+        "#{(2+(value[1]%2)).chr}#{BaseConvert.encode(value[0], 256, 32)}"
+      when :hex
+        "04#{BaseConvert.encode(value[0], 16, 64)}#{BaseConvert.encode(value[1], 16, 64)}"
+      when :hex_compressed
+        "0#{2+(value[1]%2)}#{BaseConvert.encode(value[0], 16, 64)}"
+      else
+        raise FormatError, "Invalid format!"
+      end
+    end
+
+    def decode(fmt = nil)
+      fmt ||= format
+
+      case fmt
+      when :decimal
+        raw
+      when :bin
+        [BaseConvert.decode(raw[1, 32], 256), BaseConvert.decode(raw[33, 32], 256)]
+      when :bin_compressed
+        x = BaseConvert.decode raw[1, 32], 256
+        m = x*x*x + Secp256k1::A*x + Secp256k1::B
+        n = Utils.mod_exp(m, (Secp256k1::P+1)/4, Secp256k1::P)
+        q = (n + raw[0].ord) % 2
+        y = q == 1 ? (Secp256k1::P - n) : n
+        [x, y]
+      when :hex
+        [BaseConvert.decode(raw[2, 64], 16), BaseConvert.decode(raw[66, 64], 16)]
+      when :hex_compressed
+        PublicKey.new(Utils.hex_to_bin(raw)).decode :bin_compressed
+      else
+        raise FormatError, "Invalid format!"
+      end
+    end
+
+    def value
+      @value ||= decode
+    end
+
+    def format
+      return :decimal if raw.is_a?(Array)
+      return :bin if raw.size == 65 && raw[0] == "\x04"
+      return :hex if raw.size == 130 && raw[0, 2] == '04'
+      return :bin_compressed if raw.size == 33 && "\x02\x03".include?(raw[0])
+      return :hex_compressed if raw.size == 66 && %w(02 03).include?(raw[0,2])
+
+      raise FormatError, "Pubkey is not in recognized format"
+    end
+
+    def to_address_obj
+      bytes = [
+        BaseConvert.encode(Constant::ADDRESS_PREFIX, 256, 1),
+        BaseConvert.encode(Constant::NORMAL_TYPE, 256, 1),
+        Utils.hash160(encode(:bin))
+      ].join
+
+      Address.new(bytes)
+    end
+
+    def to_address
+      to_address_obj.to_s
+    end
+
+  end
+end

data/lib/neb/secp256k1.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  module Secp256k1
+
+    # Elliptic curve parameters
+    P  = 2**256 - 2**32 - 977
+    N  = 115792089237316195423570985008687907852837564279074904382605163141518161494337
+    A  = 0
+    B  = 7
+    Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
+    Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
+    G  = [Gx, Gy].freeze
+
+    SECP256K1 = 1
+
+    class InvalidPrivateKey < StandardError; end
+
+    class << self # extensions
+
+      def sign(msg, priv)
+        priv = PrivateKey.new(priv)
+        privkey = ::Secp256k1::PrivateKey.new(privkey: priv.encode(:bin), raw: true)
+        sig_raw = privkey.ecdsa_sign(msg, raw: true)
+        privkey.ecdsa_serialize_compact(sig_raw) << SECP256K1
+      end
+
+      def priv_to_pub(priv)
+        priv = PrivateKey.new(priv)
+        privkey = ::Secp256k1::PrivateKey.new(privkey: priv.encode(:bin), raw: true)
+        pubkey = privkey.pubkey
+        PublicKey.new(pubkey.serialize).encode(priv.format)
+      end
+
+      def recoverable_sign(msg, privkey)
+        pk = ::Secp256k1::PrivateKey.new(privkey: privkey, raw: true)
+        signature = pk.ecdsa_recoverable_serialize(pk.ecdsa_sign_recoverable(msg, raw: true))
+
+        v = signature[1]
+        r = Utils.big_endian_to_int signature[0][0,32]
+        s = Utils.big_endian_to_int signature[0][32,32]
+
+        [v,r,s]
+      end
+
+      def signature_verify(msg, vrs, pubkey)
+        pk = ::Secp256k1::PublicKey.new(pubkey: pubkey)
+        raw_sig = Utils.zpad_int(vrs[1]) + Utils.zpad_int(vrs[2])
+
+        sig = ::Secp256k1::C::ECDSASignature.new
+        sig[:data].to_ptr.write_bytes(raw_sig)
+
+        pk.ecdsa_verify(msg, sig)
+      end
+
+      def recover_pubkey(msg, vrs, compressed: false)
+        pk = ::Secp256k1::PublicKey.new(flags: ::Secp256k1::ALL_FLAGS)
+        sig = Utils.zpad_int(vrs[1]) + Utils.zpad_int(vrs[2])
+        recsig = pk.ecdsa_recoverable_deserialize(sig, vrs[0])
+        pk.public_key = pk.ecdsa_recover msg, recsig, raw: true
+        pk.serialize compressed: compressed
+      end
+    end
+  end
+end

data/lib/neb/transaction.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  class Transaction
+
+    MAX_GAS_PRICE = 1_000_000_000_000
+    MAX_GAS       = 50_000_000_000
+    GAS_PRICE     = 1_000_000
+    GAS_LIMIT     = 20_000
+
+    PAYLOAD_BINARY_TYPE = "binary".freeze
+    PAYLOAD_DEPLOY_TYPE = "deploy".freeze
+    PAYLOAD_CALL_TYPE   = "call".freeze
+
+    CHAIN_ID_LIST = {
+      1    => { name: "Mainnet",     url: "https://mainnet.nebulas.io" },
+      1001 => { name: "Testnet",     url: "https://testnet.nebulas.io" },
+      100  => { name: "Local Nodes", url: "http://127.0.0.1:8685" }
+    }.freeze
+
+    attr_reader :chain_id, :from_account, :to_address, :value, :nonce,
+                :gas_price, :gas_limit, :timestamp, :data
+    attr_reader :hash, :sign
+
+    def initialize(chain_id:, from_account:, to_address:, value:, nonce:,
+                   gas_price: GAS_PRICE, gas_limit: GAS_LIMIT, contract: {})
+      @chain_id     = chain_id
+      @from_account = from_account
+      @to_address   = Address.new(to_address)
+      @value        = value
+      @nonce        = nonce
+      @gas_price    = gas_price
+      @gas_limit    = gas_limit
+      @data         = parse_contract(contract)
+      @timestamp    = Time.now.to_i
+    end
+
+    def parse_contract(contract)
+      payload_type, payload = nil, nil
+      contract.deep_symbolize_keys!
+
+      if contract[:source].present?
+        payload_type = PAYLOAD_DEPLOY_TYPE
+        payload = {
+          source_type: contract[:source_type],
+          source: contract[:source],
+          args: contract[:args]
+        }
+      elsif contract[:function].present?
+        payload_type = PAYLOAD_CALL_TYPE
+        payload = {
+          function: contract[:function],
+          args: contract[:args]
+        }
+      else
+        payload_type = PAYLOAD_BINARY_TYPE
+        if contract.present?
+          payload = {
+            data: BaseConvert.decode(contract[:binary], 256)
+          }
+        end
+      end
+
+      if payload.present?
+        payload = String.new(JSON.dump(payload.deep_camelize_keys(:upper)).html_safe)
+        { type: payload_type, payload: payload }
+      else
+        { type: payload_type }
+      end
+    end
+
+    def to_proto
+      raise UnsignError.new("Must sign_hash first") if sign.blank?
+
+      tx = Corepb::Transaction.new(
+        hash:      hash,
+        from:      from_account.address_obj.encode(:bin_extended),
+        to:        to_address.encode(:bin_extended),
+        value:     Utils.zpad(Utils.int_to_big_endian(value), 16),
+        nonce:     nonce,
+        timestamp: timestamp,
+        data:      Corepb::Data.new(data),
+        chain_id:  chain_id,
+        gas_price: Utils.zpad(Utils.int_to_big_endian(gas_price), 16),
+        gas_limit: Utils.zpad(Utils.int_to_big_endian(gas_limit), 16),
+        alg:       Secp256k1::SECP256K1,
+        sign:      sign
+      )
+
+      tx.to_proto
+    end
+
+    def to_proto_str
+      Utils.encode64(to_proto)
+    end
+
+    def calculate_hash
+      buffer = [
+        from_account.address_obj.encode(:bin_extended),
+        to_address.encode(:bin_extended),
+        Utils.zpad(Utils.int_to_big_endian(value), 16),
+        Utils.zpad(Utils.int_to_big_endian(nonce), 8),
+        Utils.zpad(Utils.int_to_big_endian(timestamp), 8),
+        Corepb::Data.new(data).to_proto,
+        Utils.zpad(Utils.int_to_big_endian(chain_id), 4),
+        Utils.zpad(Utils.int_to_big_endian(gas_price), 16),
+        Utils.zpad(Utils.int_to_big_endian(gas_limit), 16)
+      ].join
+
+      Utils.keccak256(buffer)
+    end
+
+    def sign_hash
+      @hash = calculate_hash
+      @sign = Secp256k1.sign(@hash, from_account.private_key)
+    end
+
+  end
+end

data/lib/neb/utils.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  module Utils
+    extend self
+
+    include Constant
+
+    def to_json(h)
+      JSON.generate(h)
+    end
+
+    def from_json(s)
+      JSON.parse(s, symbolize_names: true)
+    end
+
+    def secure_compare(a, b)
+      ActiveSupport::SecurityUtils.secure_compare(a, b)
+    end
+
+    # args: n, r, p, key_len
+    def scrypt(secret, salt, *args)
+      SCrypt::Engine.scrypt(secret, salt, *args)
+    end
+
+    def aes_encrypt(raw, bin_key, bin_iv)
+      cipher = OpenSSL::Cipher::AES128.new(:ctr)
+      cipher.encrypt
+      cipher.key = bin_key
+      cipher.iv = bin_iv
+
+      result = cipher.update(raw)
+      result += cipher.final
+      result
+    end
+
+    def aes_decrypt(ciphertext, bin_key, bin_iv)
+      cipher = OpenSSL::Cipher::AES128.new(:ctr)
+      cipher.decrypt
+      cipher.key = bin_key
+      cipher.iv = bin_iv
+
+      result = cipher.update(ciphertext)
+      result += cipher.final
+      result
+    end
+
+    def uuid
+      SecureRandom.uuid
+    end
+
+    def encode64(str)
+      Base64.strict_encode64(str)
+    end
+
+    def big_endian_to_int(s)
+      RLP::Sedes.big_endian_int.deserialize(s.sub(/\A(\x00)+/, ''))
+    end
+
+    def int_to_big_endian(n)
+      RLP::Sedes.big_endian_int.serialize(n)
+    end
+
+    def bin_to_hex(bytes)
+      BaseConvert.convert(bytes, 256, 16, bytes.size * 2).force_encoding('utf-8')
+    end
+
+    def hex_to_bin(hex)
+      BaseConvert.convert(hex, 16, 256, hex.size / 2).force_encoding('ascii-8bit')
+    end
+
+    def random_bytes(size = 32)
+      SecureRandom.random_bytes(size)
+    end
+
+    def keccak256(x)
+      SHA3::Digest::SHA256.digest(x)
+    end
+
+    def keccak512(x)
+      SHA3::Digest::SHA512.digest(x)
+    end
+
+    def sha256(x)
+      Digest::SHA256.digest(x)
+    end
+
+    def ripemd160(x)
+      Digest::RMD160.digest(x)
+    end
+
+    def hash160(x)
+      ripemd160(keccak256(x))
+    end
+
+    def base58(x)
+      Base58.binary_to_base58(x, :bitcoin)
+    end
+    alias_method :binary_to_base58, :base58
+
+    def base58_to_binary(b)
+      Base58.base58_to_binary(b, :bitcoin)
+    end
+
+    def lpad(x, symbol, l)
+      return x if x.size >= l
+      symbol * (l - x.size) + x
+    end
+
+    def rpad(x, symbol, l)
+      return x if x.size >= l
+      x + symbol * (l - x.size)
+    end
+
+    def zpad(x, l)
+      lpad(x, BYTE_ZERO, l)
+    end
+
+    def mod_exp(x, y, n)
+      x.to_bn.mod_exp(y, n).to_i
+    end
+
+    def mod_mul(x, y, n)
+      x.to_bn.mod_mul(y, n).to_i
+    end
+  end
+end

data/lib/neb/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  VERSION = "0.1.0".freeze
+end

data/lib/neb.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "logger"
+require "pathname"
+require "digest"
+require "sha3"
+require "openssl"
+require "base58"
+require "securerandom"
+require "scrypt"
+require "active_support/all"
+require "json"
+require "forwardable"
+require "rest-client"
+require "secp256k1"
+require "rlp"
+require "google/protobuf"
+require "base64"
+
+require "neb/version"
+require "neb/exceptions"
+require "neb/constant"
+require "neb/utils"
+require "neb/core_ext"
+require "neb/configuration"
+require "neb/base_convert"
+require "neb/client"
+require "neb/secp256k1"
+require "neb/private_key"
+require "neb/public_key"
+require "neb/address"
+require "neb/account"
+require "neb/key"
+require "neb/transaction"
+require "neb/proto/transaction_pb"
+
+module Neb
+  extend self
+  CONFIG = Configuration.new
+
+  attr_reader :configured, :logger
+  alias_method :configured?, :configured
+
+  def configure(config = {})
+    CONFIG.merge!(config)
+    setup_general_logger!
+    @configured = true
+  end
+
+  def clear!
+    CONFIG.clear
+    @logger = nil
+    @configured = false
+  end
+
+  def root
+    Pathname.new(File.expand_path('../..', __FILE__))
+  end
+
+  private
+
+  def setup_general_logger!
+    if [:info, :debug, :error, :warn].all?{ |meth| CONFIG[:log].respond_to?(meth) }
+      @logger = CONFIG[:log]
+    else
+      @logger = ::Logger.new(CONFIG[:log])
+      @logger.formatter = ::Logger::Formatter.new
+    end
+  end
+end

data/neb.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "neb/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "neb"
+  spec.version       = Neb::VERSION
+  spec.authors       = ["Spirit"]
+  spec.email         = ["neverlandxy.naix@gmail.com"]
+
+  spec.summary       = %q{the Nebulas compatible Ruby API}
+  spec.description   = %q{the Nebulas compatible Ruby API}
+  spec.homepage      = "https://github.com/NaixSpirit/neb.rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pry", "~> 0.11"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-minitest", "~> 2.4"
+
+  spec.add_dependency "rest-client", "~> 2.0"
+  spec.add_dependency "activesupport", "~> 5"
+  spec.add_dependency "rlp", "~> 0.7.3"
+  spec.add_dependency "bitcoin-secp256k1", "~> 0.4"
+  spec.add_dependency "ffi", "~> 1.9"
+  spec.add_dependency "sha3", "~> 1.0"
+  spec.add_dependency "base58", "~> 0.2"
+  spec.add_dependency "scrypt", "~> 3.0"
+  spec.add_dependency "google-protobuf", "~> 3.5"
+end