neb 0.1.0

data/lib/neb/client/api.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative "./request"
+require_relative "./response"
+
+module Neb
+  class Client
+    class API
+      attr_reader :host, :api_version, :endpoint
+
+      def initialize
+        @host        = CONFIG[:host]
+        @api_version = CONFIG[:api_version]
+        @endpoint    = CONFIG[:api_endpoint]
+      end
+
+      def get_neb_state
+        send_request(:get, "/nebstate")
+      end
+
+      def latest_irreversible_block
+        send_request(:get, "/lib")
+      end
+
+      def get_account_state(address: , height: 0)
+        send_request(:post, "/accountstate", address: address, height: height)
+      end
+
+      def call(from:, to:, value:, nonce:, gas_price: 1_000_000, gas_limit: 20_000, contract: nil)
+        params = {
+          from:      from,
+          to:        to,
+          value:     value.to_i,
+          nonce:     nonce.to_i,
+          gas_price: gas_price.to_i,
+          gas_limit: gas_limit.to_i,
+          contract:  contract
+        }
+
+        send_request(:post, "/call", params)
+      end
+
+      def send_raw_transaction(data:)
+        send_request(:post, "/rawtransaction", data: data)
+      end
+
+      def get_block_by_hash(hash:, is_full: true)
+        send_request(:post, "/getBlockByHash", hash: hash, full_fill_transaction: is_full)
+      end
+
+      def get_block_by_height(height:, is_full: true)
+        send_request(:post, "/getBlockByHeight", height: height, full_fill_transaction: is_full)
+      end
+
+      def get_transaction_receipt(hash:)
+        send_request(:post, "/getTransactionReceipt", hash: hash)
+      end
+
+      def get_transaction_by_contract(address:)
+        send_request(:post, "/getTransactionByContract", address: address)
+      end
+
+      def subscribe(topics: [])
+        send_request(:post, "/subscribe", topics: topics)
+      end
+
+      def get_gas_price
+        send_request(:get, "/getGasPrice")
+      end
+      alias_method :gas_price, :get_gas_price
+
+      def estimate_gas(from:, to:, value:, nonce:, gas_price: 1_000_000, gas_limit: 20_000, contract: nil, binary: nil)
+        params = {
+          from:      from,
+          to:        to,
+          value:     value.to_i,
+          nonce:     nonce.to_i,
+          gas_price: gas_price.to_i,
+          gas_limit: gas_limit.to_i,
+          contract:  contract,
+          binary:    binary
+        }
+
+        send_request(:post, "/estimateGas", params)
+      end
+
+      def get_events_by_hash(hash:)
+        send_request(:post, "/getEventsByHash", hash: hash)
+      end
+
+      def get_dynasty(height:)
+        send_request(:post, "/dynasty", height: height)
+      end
+
+      private
+
+      def send_request(action, url, payload = {})
+        request_url = host + api_version + endpoint + url
+        Request.new(action, request_url, payload).execute
+      end
+    end
+  end
+end

data/lib/neb/client/request.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  class Client
+    class Request
+      attr_reader :action, :url, :payload
+
+      def initialize(action, url, payload = {}, headers = {})
+        @action  = action
+        @url     = url
+        @payload = payload
+        @headers = headers.blank? ? default_headers : headers
+      end
+
+      def to_s
+        "#{self.class}{action=#{action}, url=#{url}, payload=#{payload}}"
+      end
+
+      def request_args
+        {
+          method:  action,
+          url:     url,
+          payload: payload.deep_camelize_keys(:lower).to_json,
+          headers: { content_type: :json, accept: :json }
+        }
+      end
+
+      def execute
+        Neb.logger.debug(self.to_s)
+        ::RestClient::Request.execute(request_args) do |resp, _, _|
+          Response.new(resp)
+        end
+      end
+
+      private
+
+      def default_headers
+        { content_type: :json, accept: :json }
+      end
+    end
+  end
+end

data/lib/neb/client/response.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  class Client
+    class Response
+      extend Forwardable
+
+      attr_reader :response
+      def_delegators :@response, :code, :body
+
+      SUCCESS_CODE = 200
+
+      def initialize(response)
+        @response = response
+        Neb.logger.debug(self.to_s)
+      end
+
+      def to_s
+        "#{self.class}{code=#{code}, body=#{body}}"
+      end
+
+      def result
+        JSON.parse(body, symbolize_names: true)[:result] if success?
+      end
+
+      def error
+        JSON.parse(body, symbolize_names: true)[:error] if !success?
+      end
+
+      def success?
+        code == SUCCESS_CODE
+      end
+    end
+  end
+end

data/lib/neb/client.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative "./client/admin"
+require_relative "./client/api"
+
+module Neb
+  class Client
+    attr_reader :api, :admin
+
+    def initialize(config = {})
+      Neb.configure(config) unless Neb.configured?
+
+      @api   = API.new
+      @admin = Admin.new
+    end
+  end
+end
+

data/lib/neb/configuration.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  class Configuration
+    extend Forwardable
+    def_delegators :@hash, :to_hash, :[], :[]=, :==, :fetch, :delete, :has_key?
+
+    DEFAULTS = {
+      host:           "http://localhost:8685",
+      timeout:        "0",
+      api_version:    "/v1",
+      log:            "log/neb.log",
+      api_endpoint:   "/user",
+      admin_endpoint: "/admin"
+    }.freeze
+
+    def initialize
+      clear
+    end
+
+    def clear
+      @hash = DEFAULTS.dup
+    end
+
+    def merge!(hash)
+      hash = hash.dup
+      @hash = @hash.deep_merge(hash)
+    end
+
+    def merge(hash)
+      instance = self.class.new
+      instance.merge!(to_hash)
+      instance.merge!(hash)
+      instance
+    end
+  end
+end

data/lib/neb/constant.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  module Constant
+
+    BYTE_EMPTY = "".freeze
+    BYTE_ZERO  = "\x00".freeze
+    BYTE_ONE   = "\x01".freeze
+
+    TT32   = 2**32
+    TT40   = 2**40
+    TT160  = 2**160
+    TT256  = 2**256
+    TT64M1 = 2**64 - 1
+
+    UINT_MAX = 2**256 - 1
+    UINT_MIN = 0
+    INT_MAX  = 2**255 - 1
+    INT_MIN  = -2**255
+
+    HASH_ZERO = ("\x00"*32).freeze
+
+    PUBKEY_ZERO      = ("\x00"*32).freeze
+    PRIVKEY_ZERO     = ("\x00"*32).freeze
+    PRIVKEY_ZERO_HEX = ('0'*64).freeze
+
+    CONTRACT_CODE_SIZE_LIMIT = 0x6000
+
+    ADDRESS_LENGTH = 26
+    ADDRESS_PREFIX = 25
+    NORMAL_TYPE    = 87
+    CONTRACT_TYPE  = 88
+  end
+end

data/lib/neb/core_ext.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+class Hash
+  # Returns a new hash with all keys converted to UpperCamelCase strings.If th
+  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+  #
+  #   hash = { my_name: 'Rob', my_age: '28' }
+  #
+  #   hash.camelize_keys
+  #   # => {"MyName"=>"Rob", "MyAge"=>"28"}
+  #
+  #   hash.camelize_keys(:lower)
+  #   # => {"myName"=>"Rob", "myAge"=>"28"}
+  def camelize_keys(first_letter = :upper)
+    transform_keys { |key| key.to_s.camelize(first_letter) rescue key }
+  end
+
+  # Destructively converts all keys to strings. Same as
+  # +camelize_keys+, but modifies +self+.
+  def camelize_keys!(first_letter = :upper)
+    transform_keys! { |key| key.to_s.camelize(first_letter) rescue key }
+  end
+
+  # Returns a new hash with all keys converted to UpperCamelCase strings.If th
+  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+  # This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { my_name: 'Rob', my_age: '28', my_friend: { his_name: "bob" } }
+  #
+  #   hash.deep_camelize_keys
+  #   # => {"MyName"=>"Rob", "MyAge"=>"28", "MyFriend"=>{"HisName"=>"bob"}}
+  def deep_camelize_keys(first_letter = :upper)
+    deep_transform_keys { |key| key.to_s.camelize(first_letter) rescue key }
+  end
+
+  # Destructively converts all keys to strings. Same as
+  # +camelize_keys+, but modifies +self+.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_camelize_keys!(first_letter = :upper)
+    deep_transform_keys! { |key| key.to_s.camelize(first_letter) rescue key }
+  end
+end

data/lib/neb/exceptions.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  class DeprecatedError < StandardError; end
+  class InvalidJSONKeyError < StandardError; end
+  class ChecksumError < StandardError; end
+  class FormatError < StandardError; end
+  class ValidationError < StandardError; end
+  class ValueError < StandardError; end
+  class AssertError < StandardError; end
+  class UnsignError < StandardError; end
+
+  class UnknownParentError < StandardError; end
+  class InvalidBlock < ValidationError; end
+  class InvalidUncles < ValidationError; end
+
+  class InvalidTransaction < ValidationError; end
+  class UnsignedTransactionError < InvalidTransaction; end
+  class InvalidNonce < InvalidTransaction; end
+  class InsufficientStartGas < InvalidTransaction; end
+  class InsufficientBalance < InvalidTransaction; end
+  class BlockGasLimitReached < InvalidTransaction; end
+
+  class InvalidSPVProof < ValidationError; end
+
+  class ContractCreationFailed < StandardError; end
+  class TransactionFailed < StandardError; end
+end

data/lib/neb/key.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  class Key
+    KDF         = "scrypt".freeze
+    CIPHER_NAME = "aes-128-ctr".freeze
+    MACHASH     = "sha3256".freeze
+
+    KDF_N = 1 << 12
+    KDF_R = 8
+    KDF_P = 1
+    DKLEN = 32
+
+    KEY_CURRENT_VERSION = 4
+    KEY_VERSION_3       = 3
+
+    attr_accessor :address, :private_key, :password, :salt, :iv, :mac
+
+    def initialize(address: nil, private_key: nil, password: nil, salt: nil, iv: nil)
+      @address     = Address.new(address) if address
+      @private_key = PrivateKey.new(private_key) if private_key
+      @password    = password
+      @salt        = self.class.convert_salt(salt || Utils.random_bytes(32))
+      @iv          = self.class.convert_iv(iv || Utils.random_bytes(16))
+    end
+
+    def encrypt
+      derived_key    = Utils.scrypt(password, salt, KDF_N, KDF_R, KDF_P, DKLEN)
+      ciphertext_bin = Utils.aes_encrypt(private_key.encode(:bin), derived_key[0, 16], iv)
+      mac_bin        = Utils.keccak256([derived_key[16, 16], ciphertext_bin, iv, CIPHER_NAME].join)
+
+      {
+        version: KEY_CURRENT_VERSION,
+        id: Utils.uuid,
+        address: address.to_s,
+        crypto: {
+          ciphertext: Utils.bin_to_hex(ciphertext_bin),
+          cipherparams: {
+            iv: Utils.bin_to_hex(iv)
+          },
+          cipher: CIPHER_NAME,
+          kdf: KDF,
+          kdfparams: {
+            dklen: DKLEN,
+            salt: Utils.bin_to_hex(salt),
+            n: KDF_N,
+            r: KDF_R,
+            p: KDF_P
+          },
+          mac: Utils.bin_to_hex(mac_bin),
+          machash: MACHASH
+        }
+      }
+    end
+
+    class << self
+
+      def encrypt(address, private_key, password)
+        new(address: address, private_key: private_key, password: password).encrypt
+      end
+
+      def decrypt(key_data, password)
+        key_data = Utils.from_json(key_data) if key_data.is_a?(String)
+        key_data = key_data.deep_symbolize_keys!
+
+        raise InvalidJSONKeyError("key data validate failed") if !validate?(key_data)
+
+        version = key_data[:version]
+        address = key_data[:address]
+        crypto  = key_data[:crypto]
+
+        cipher = crypto[:cipher]
+        salt   = convert_salt(crypto[:kdfparams][:salt])
+        dklen  = crypto[:kdfparams][:dklen]
+        kdf_n  = crypto[:kdfparams][:n]
+        kdf_r  = crypto[:kdfparams][:r]
+        kdf_p  = crypto[:kdfparams][:p]
+        iv     = convert_iv(crypto[:cipherparams][:iv])
+
+        derived_key    = Utils.scrypt(password, salt, kdf_n, kdf_r, kdf_p, dklen)
+        ciphertext_bin = Utils.hex_to_bin(crypto[:ciphertext])
+
+        if version == KEY_CURRENT_VERSION
+          mac = Utils.keccak256([derived_key[16, 16], ciphertext_bin, iv, cipher].join)
+        else
+          mac = Utils.keccak256([derived_key[16, 16], ciphertext_bin].join)  # KeyVersion3
+        end
+
+        raise InvalidJSONKeyError.new("mac is wrong") if Utils.bin_to_hex(mac) != crypto[:mac]
+
+        private_key = Utils.aes_decrypt(ciphertext_bin, derived_key[0, 16], iv)
+        Utils.bin_to_hex(private_key)
+      end
+
+      def validate?(key_data)
+        key_data = Utils.from_json(key_data) if key_data.is_a?(String)
+
+        [:version, :id, :address, :crypto].each do |k|
+          return false if !key_data.keys.include?(k)
+        end
+
+        return false if key_data[:version] != KEY_CURRENT_VERSION && key_data[:version] != KEY_VERSION_3
+
+        [:ciphertext, :cipherparams, :cipher, :kdf, :kdfparams, :mac, :machash].each do |k|
+          return false if !key_data[:crypto].keys.include?(k)
+        end
+
+        return false if !key_data[:crypto][:cipherparams].keys.include?(:iv)
+
+        [:dklen, :salt, :n, :r, :p].each do |k|
+          return false if !key_data[:crypto][:kdfparams].keys.include?(k)
+        end
+
+        true
+      end
+
+      def convert_salt(salt)
+        return salt if salt.length == 32
+        return Utils.hex_to_bin(salt) if salt.length == 64
+
+        raise ArgumentError.new("salt must be 32 bytes")
+      end
+
+      def convert_iv(iv)
+        return iv if iv.length == 16
+        return Utils.hex_to_bin(iv) if iv.length == 32
+
+        raise ArgumentError.new("iv must be 16 bytes")
+      end
+    end
+  end
+end

data/lib/neb/private_key.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Neb
+  class PrivateKey
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def to_s
+      encode(:hex)
+    end
+
+    def encode(fmt)
+      return self.class.new(value).encode(fmt) unless raw.is_a?(Numeric)
+
+      case fmt
+      when :decimal
+        raw
+      when :bin
+        BaseConvert.encode(raw, 256, 32)
+      when :bin_compressed
+        "#{BaseConvert.encode(raw, 256, 32)}\x01"
+      when :hex
+        BaseConvert.encode(raw, 16, 64)
+      when :hex_compressed
+        "#{BaseConvert.encode(raw, 16, 64)}01"
+      else
+        raise ArgumentError, "invalid format: #{fmt}"
+      end
+    end
+
+    def decode(fmt = nil)
+      fmt ||= format
+
+      case fmt
+      when :decimal
+        raw
+      when :bin
+        BaseConvert.decode(raw, 256)
+      when :bin_compressed
+        BaseConvert.decode(raw[0, 32], 256)
+      when :hex
+        BaseConvert.decode(raw, 16)
+      when :hex_compressed
+        BaseConvert.decode(raw[0, 64], 16)
+      else
+        raise ArgumentError, "WIF does not represent privkey"
+      end
+    end
+
+    def value
+      @value ||= decode
+    end
+
+    def format
+      return :decimal if raw.is_a?(Numeric)
+      return :bin if raw.size == 32
+      return :bin_compressed if raw.size == 33
+      return :hex if raw.size == 64
+      return :hex_compressed if raw.size == 66
+    end
+
+    def to_pubkey
+      to_pubkey_obj.to_s
+    end
+
+    def to_pubkey_obj
+      raise ValidationError, "Invalid private key" if value >= Secp256k1::N
+      PublicKey.new(Secp256k1.priv_to_pub(encode(:bin)))
+    end
+
+    def to_address_obj
+      PublicKey.new(to_pubkey_obj.encode(:bin)).to_address
+    end
+
+    def to_address
+      to_address_obj.to_s
+    end
+
+    class << self
+
+      def random
+        new(Utils.random_bytes)
+      end
+    end
+
+  end
+end

data/lib/neb/proto/transaction.proto

@@ -0,0 +1,40 @@
+// Copyright (C) 2017 go-nebulas authors
+//
+// This file is part of the go-nebulas library.
+//
+// the go-nebulas library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// the go-nebulas library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with the go-nebulas library.  If not, see <http://www.gnu.org/licenses/>.
+//
+syntax = "proto3";
+package corepb;
+
+message Data {
+    string type = 1;
+    bytes payload = 2;
+}
+
+message Transaction {
+    bytes hash  = 1;
+    bytes from = 2;
+    bytes to = 3;
+    bytes value = 4;
+    uint64 nonce = 5;
+    int64 timestamp = 6;
+    Data data = 7;
+    uint32 chain_id = 8;
+    bytes gas_price = 9;
+    bytes gas_limit = 10;
+
+    uint32 alg = 11;
+    bytes sign = 12;
+}

data/lib/neb/proto/transaction_pb.rb

@@ -0,0 +1,30 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lib/neb/proto/transaction.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "corepb.Data" do
+    optional :type, :string, 1
+    optional :payload, :bytes, 2
+  end
+  add_message "corepb.Transaction" do
+    optional :hash, :bytes, 1
+    optional :from, :bytes, 2
+    optional :to, :bytes, 3
+    optional :value, :bytes, 4
+    optional :nonce, :uint64, 5
+    optional :timestamp, :int64, 6
+    optional :data, :message, 7, "corepb.Data"
+    optional :chain_id, :uint32, 8
+    optional :gas_price, :bytes, 9
+    optional :gas_limit, :bytes, 10
+    optional :alg, :uint32, 11
+    optional :sign, :bytes, 12
+  end
+end
+
+module Corepb
+  Data = Google::Protobuf::DescriptorPool.generated_pool.lookup("corepb.Data").msgclass
+  Transaction = Google::Protobuf::DescriptorPool.generated_pool.lookup("corepb.Transaction").msgclass
+end