platon 0.2.7

data/lib/platon/function.rb

@@ -0,0 +1,36 @@
+module Platon
+  class Function
+
+    attr_accessor :name, :inputs, :outputs, :signature, :constant, :function_string 
+
+    def initialize(data)
+      @name = data["name"]
+      @constant = data["constant"]
+      @inputs = data["inputs"].map do |input|
+        Platon::FunctionInput.new(input)
+      end
+      @outputs = data["outputs"].collect do |output|
+        Platon::FunctionOutput.new(output)
+      end
+      @function_string = self.class.calc_signature(@name, @inputs)
+      @signature = self.class.calc_id(@function_string)
+    end
+
+    def self.to_canonical_type(type)
+      type
+      .gsub(/(int)(\z|\D)/, '\1256\2')
+      .gsub(/(uint)(\z|\D)/, '\1256\2')
+      .gsub(/(fixed)(\z|\D)/, '\1128x128\2')
+      .gsub(/(ufixed)(\z|\D)/, '\1128x128\2')
+    end
+
+    def self.calc_signature(name, inputs)
+      "#{name}(#{inputs.collect {|x| self.to_canonical_type(x.type) }.join(",")})"
+    end
+
+    def self.calc_id(signature)
+      Digest::SHA3.hexdigest(signature, 256)[0..7]
+    end
+
+  end
+end

data/lib/platon/function_input.rb

@@ -0,0 +1,13 @@
+module Platon
+  class FunctionInput
+
+    attr_accessor :type, :name
+
+    def initialize(data)
+      @type = data["type"]
+      @name = data["name"]
+    end
+
+  end
+
+end

data/lib/platon/function_output.rb

@@ -0,0 +1,14 @@
+module Platon
+  
+  class FunctionOutput
+
+    attr_accessor :type, :name
+
+    def initialize(data)
+      @type = data["type"]
+      @name = data["name"]
+    end
+
+  end
+
+end

data/lib/platon/gas.rb

@@ -0,0 +1,9 @@
+module Platon
+  class Gas
+
+    GTXCOST = 21000       # TX BASE GAS COST
+    GTXDATANONZERO = 68   # TX DATA NON ZERO BYTE GAS COST
+    GTXDATAZERO = 4       # TX DATA ZERO BYTE GAS COST
+
+  end
+end

data/lib/platon/http_client.rb

@@ -0,0 +1,55 @@
+require 'net/http'
+require 'json'
+module Platon
+  class HttpClient < Client
+    attr_accessor :host, :port, :uri, :ssl, :proxy
+
+    def initialize(host,chain_name, proxy = nil, log = false)
+      super(chain_name,log)
+      uri = URI.parse(host)
+      raise ArgumentError unless ['http', 'https'].include? uri.scheme
+      @host = uri.host
+      @port = uri.port
+      @proxy = proxy
+      
+      @ssl = uri.scheme == 'https'
+      @uri = URI("#{uri.scheme}://#{@host}:#{@port}#{uri.path}")
+    end
+
+    def update_setting(params)  # :host,:proxy, :chain_id, :hrp
+      if params[:host]
+        uri = URI.parse(params[:host])
+        raise ArgumentError unless ['http', 'https'].include? uri.scheme
+        @host = uri.host
+        @port = uri.port
+      end
+      @proxy = proxy if params[:proxy]
+      super(params)
+    end
+
+    def send_single(payload)
+      if @proxy.present?
+        _, p_username, p_password, p_host, p_port = @proxy.gsub(/(:|\/|@)/,' ').squeeze(' ').split
+        http = ::Net::HTTP.new(@host, @port, p_host, p_port, p_username, p_password)
+      else
+        http = ::Net::HTTP.new(@host, @port)
+      end
+
+      if @ssl
+        http.use_ssl = true
+      end
+      header = {'Content-Type' => 'application/json'}
+      request = ::Net::HTTP::Post.new(uri, header)
+      request.body = payload
+      response = http.request(request)
+      response.body
+    end
+
+    def send_batch(batch)
+      result = send_single(batch.to_json)
+      result = JSON.parse(result)
+      result.sort_by! { |c| c['id'] }
+    end
+  end
+
+end

data/lib/platon/ipc_client.rb

@@ -0,0 +1,45 @@
+require 'socket'
+module Platon
+  class IpcClient < Client
+    attr_accessor :ipcpath
+
+    IPC_PATHS = [  
+      "#{ENV['HOME']}/platon-node/data/platon.ipc",
+      "#{ENV['HOME']}/alaya-node/data/platon.ipc"
+    ]
+
+    def initialize(ipcpath = nil, log = true)
+      super(nil,log)
+      ipcpath ||= IpcClient.default_path
+      @ipcpath = ipcpath
+    end
+
+    def self.default_path(paths = IPC_PATHS)
+      path = paths.select { |path| File.exist?(path) }.first
+      path || raise("Ipc file not found. Please pass in the file path explicitly to IpcClient initializer")
+    end
+
+    def send_single(payload)
+      socket = UNIXSocket.new(@ipcpath)
+      socket.puts(payload)
+      read = socket.recvmsg(nil)[0]
+      socket.close
+      return read
+    end
+
+    # Note: Guarantees the results are in the same order as defined in batch call.
+    # client.batch do
+    #   client.platon_block_number
+    #   client.platon_mining
+    # end
+    # => [{"jsonrpc"=>"2.0", "id"=>1, "result"=>"0x26"}, {"jsonrpc"=>"2.0", "id"=>2, "result"=>false}] 
+    def send_batch(batch)
+      result = send_single(batch.to_json)
+      result = JSON.parse(result)
+
+      # Make sure the order is the same as it was when batching calls
+      # See 6 Batch here http://www.jsonrpc.org/specification
+      return result.sort_by! { |c| c['id'] }
+    end
+  end
+end

data/lib/platon/key.rb

@@ -0,0 +1,105 @@
+module Platon
+  class Key
+    autoload :Decrypter, 'platon/key/decrypter'
+    autoload :Encrypter, 'platon/key/encrypter'
+
+    attr_reader :private_key, :public_key
+
+    def self.encrypt(key, password)
+      key = new(priv: key) unless key.is_a?(Key)
+
+      Encrypter.perform key.private_hex, password
+    end
+
+    def self.decrypt(data, password)
+      priv = Decrypter.perform data, password
+      new priv: priv
+    end
+
+    def self.encrypt_and_save(key,password,keypath=nil)
+      encrypted_key_info = encrypt(key,password)
+      ## PlatON似乎打算兼容以太地址, 暂时默认以 0x 地址命名 
+      if keypath==nil || keypath=="" 
+        address = key.address
+        dirname = "#{ENV['HOME']}/.platon/keystore/"
+        FileUtils.mkdir_p(dirname) unless Dir.exists?(dirname)
+        File.write File.join(dirname, "#{key.address}.json") , encrypted_key_info
+      else
+        File.write keypath , encrypted_key_info
+      end
+      return encrypted_key_info
+    end
+
+    def self.list_wallets(keypath=nil)
+      if keypath==nil || keypath=="" 
+        Dir.glob("#{ENV['HOME']}/.platon/keystore/*").select { |e| File.file? e }
+      else
+        Dir.glob(keypath + "/*").select { |e| File.file? e }
+      end
+    end
+
+    def self.personal_recover(message, signature)
+      bin_signature = Utils.hex_to_bin(signature).bytes.rotate(-1).pack('c*')
+      OpenSsl.recover_compact(Utils.keccak256(Utils.prefix_message(message)), bin_signature)
+    end
+
+    def initialize(priv: nil)
+      @private_key = MoneyTree::PrivateKey.new key: priv
+      @public_key = MoneyTree::PublicKey.new private_key, compressed: false
+    end
+
+    def private_hex
+      private_key.to_hex
+    end
+
+    def public_bytes
+      public_key.to_bytes
+    end
+
+    def public_hex
+      public_key.to_hex
+    end
+
+    def address
+      Utils.public_key_to_address public_hex
+    end
+
+    def bech32_address(hrp:"atp")
+      Utils.to_bech32_address(hrp,address) ##TODO
+    end
+    alias_method :to_address, :address
+
+    def sign(message)
+      sign_hash message_hash(message)
+    end
+
+    def sign_hash(hash)
+      loop do
+        signature = OpenSsl.sign_compact hash, private_hex, public_hex
+        return signature if valid_s? signature
+      end
+    end
+
+    def verify_signature(message, signature)
+      hash = message_hash(message)
+      public_hex == OpenSsl.recover_compact(hash, signature)
+    end
+
+    def personal_sign(message)
+      Utils.bin_to_hex(sign(Utils.prefix_message(message)).bytes.rotate(1).pack('c*'))
+    end
+
+
+    private
+
+    def message_hash(message)
+      Utils.keccak256 message
+    end
+
+    def valid_s?(signature)
+      s_value = Utils.v_r_s_for(signature).last
+      s_value <= Secp256k1::N/2 && s_value != 0
+    end
+
+  end
+end

data/lib/platon/key/decrypter.rb

@@ -0,0 +1,113 @@
+require 'json'
+require 'scrypt'
+
+class Platon::Key::Decrypter
+  include Platon::Utils
+
+  def self.perform(data, password)
+    new(data, password).perform
+  end
+
+  def initialize(data, password)
+    @data = JSON.parse(data)
+    @password = password
+  end
+
+  def perform
+    derive_key password
+    check_macs
+    bin_to_hex decrypted_data
+  end
+
+
+  private
+
+  attr_reader :data, :key, :password
+
+  def derive_key(password)
+    case kdf
+    when 'pbkdf2'
+      @key = OpenSSL::PKCS5.pbkdf2_hmac(password, salt, iterations, key_length, digest)
+    when 'scrypt'
+      # OpenSSL 1.1 inclues OpenSSL::KDF.scrypt, but it is not available usually, otherwise we could do: OpenSSL::KDF.scrypt(password, salt: salt, N: n, r: r, p: p, length: key_length)
+      @key = SCrypt::Engine.scrypt(password, salt, n, r, p, key_length)
+    else
+      raise "Unsupported key derivation function: #{kdf}!"
+    end
+  end
+
+  def check_macs
+    mac1 = keccak256(key[(key_length/2), key_length] + ciphertext)
+    mac2 = hex_to_bin crypto_data['mac']
+
+    if mac1 != mac2
+      raise "Message Authentications Codes do not match!"
+    end
+  end
+
+  def decrypted_data
+    @decrypted_data ||= cipher.update(ciphertext) + cipher.final
+  end
+
+  def crypto_data
+    @crypto_data ||= data['crypto'] || data['Crypto']
+  end
+
+  def ciphertext
+    hex_to_bin crypto_data['ciphertext']
+  end
+
+  def cipher_name
+    "aes-128-ctr"
+  end
+
+  def cipher
+    @cipher ||= OpenSSL::Cipher.new(cipher_name).tap do |cipher|
+      cipher.decrypt
+      cipher.key = key[0, (key_length/2)]
+      cipher.iv = iv
+    end
+  end
+
+  def iv
+    hex_to_bin crypto_data['cipherparams']['iv']
+  end
+
+  def salt
+    hex_to_bin crypto_data['kdfparams']['salt']
+  end
+
+  def iterations
+    crypto_data['kdfparams']['c'].to_i
+  end
+
+  def kdf
+    crypto_data['kdf']
+  end
+
+  def key_length
+    crypto_data['kdfparams']['dklen'].to_i
+  end
+
+  def n
+    crypto_data['kdfparams']['n'].to_i
+  end
+
+  def r
+    crypto_data['kdfparams']['r'].to_i
+  end
+
+  def p
+    crypto_data['kdfparams']['p'].to_i
+  end
+
+  def digest
+    OpenSSL::Digest.new digest_name
+  end
+
+  def digest_name
+    "sha256"
+  end
+  
+
+end

data/lib/platon/key/encrypter.rb

@@ -0,0 +1,128 @@
+require 'json'
+require 'securerandom'
+
+class Platon::Key::Encrypter
+  include Platon::Utils
+
+  def self.perform(key, password, options = {})
+    new(key, options).perform(password)
+  end
+
+  def initialize(key, options = {})
+    @key = key
+    @options = options
+  end
+
+  def perform(password)
+    derive_key password
+    encrypt
+
+    data.to_json
+  end
+
+  def data
+    {
+      crypto: {
+        cipher: cipher_name,
+        cipherparams: {
+          iv: bin_to_hex(iv),
+        },
+        ciphertext: bin_to_hex(encrypted_key),
+        kdf: "pbkdf2",
+        kdfparams: {
+          c: iterations,
+          dklen: 32,
+          prf: prf,
+          salt: bin_to_hex(salt),
+        },
+        mac: bin_to_hex(mac),
+      },
+      id: id,
+      version: 3,
+    }.tap do |data|
+      data[:address] = address unless options[:skip_address]
+    end
+  end
+
+  def id
+    @id ||= options[:id] || SecureRandom.uuid
+  end
+
+
+  private
+
+  attr_reader :derived_key, :encrypted_key, :key, :options
+
+  def cipher
+    @cipher ||= OpenSSL::Cipher.new(cipher_name).tap do |cipher|
+      cipher.encrypt
+      cipher.iv = iv
+      cipher.key = derived_key[0, (key_length/2)]
+    end
+  end
+
+  def digest
+    @digest ||= OpenSSL::Digest.new digest_name
+  end
+
+  def derive_key(password)
+    @derived_key = OpenSSL::PKCS5.pbkdf2_hmac(password, salt, iterations, key_length, digest)
+  end
+
+  def encrypt
+    @encrypted_key = cipher.update(hex_to_bin key) + cipher.final
+  end
+
+  def mac
+    keccak256(derived_key[(key_length/2), key_length] + encrypted_key)
+  end
+
+  def cipher_name
+    "aes-128-ctr"
+  end
+
+  def digest_name
+    "sha256"
+  end
+
+  def prf
+    "hmac-#{digest_name}"
+  end
+
+  def key_length
+    32
+  end
+
+  def salt_length
+    32
+  end
+
+  def iv_length
+    16
+  end
+
+  def iterations
+    options[:iterations] || 262_144
+  end
+
+  def salt
+    @salt ||= if options[:salt]
+      hex_to_bin options[:salt]
+    else
+      SecureRandom.random_bytes(salt_length)
+    end
+  end
+
+  def iv
+    @iv ||= if options[:iv]
+      hex_to_bin options[:iv]
+    else
+      SecureRandom.random_bytes(iv_length)
+    end
+  end
+
+  def address
+    Platon::Key.new(priv: key).address
+  end
+
+end