zilliqa 0.1.1

data/lib/zilliqa/crypto/key_tool.rb

@@ -0,0 +1,61 @@
+require 'secp256k1'
+require 'digest'
+
+module Zilliqa
+  module Crypto
+    class KeyTool
+      include Secp256k1
+      def initialize(private_key)
+        is_raw = private_key.length == 32
+
+        @pk = PrivateKey.new(privkey: private_key, raw: is_raw)
+      end
+
+      def self.generate_private_key
+        Util.encode_hex KeyTool.generate_random_bytes(32)
+      end
+
+      def self.generate_random_bytes(size)
+        SecureRandom.random_bytes(size)
+      end
+
+      # getPubKeyFromPrivateKey
+      #
+      # takes a hex-encoded string (private key) and returns its corresponding
+      # hex-encoded 33-byte public key.
+      #
+      # @param {string} privateKey
+      # @returns {string}
+      def self.get_public_key_from_private_key(private_key, is_compressed = true)
+        is_raw = private_key.length == 32
+
+        pk = PrivateKey.new(privkey: private_key, raw: is_raw)
+
+        (Util.encode_hex pk.pubkey.serialize(compressed: is_compressed)).downcase
+      end
+
+      # getAddressFromPrivateKey
+      #
+      # takes a hex-encoded string (private key) and returns its corresponding
+      # 20-byte hex-encoded address.
+      #
+      # @param {string} privateKey
+      # @returns {string}
+      def self.get_address_from_private_key(private_key)
+        public_key = KeyTool.get_public_key_from_private_key(private_key)
+        KeyTool.get_address_from_public_key(public_key)
+      end
+
+      # getAddressFromPublicKey
+      #
+      # takes hex-encoded string and returns the corresponding address
+      #
+      # @param {string} public_key
+      # @returns {string}
+      def self.get_address_from_public_key(public_key)
+        orig_address = Digest::SHA256.hexdigest Util.decode_hex public_key
+        Util::Bech32.to_bech32(orig_address[24..-1].downcase)
+      end
+    end
+  end
+end

data/lib/zilliqa/crypto/schnorr.rb

@@ -0,0 +1,147 @@
+require 'secp256k1'
+require 'digest'
+require 'openssl'
+
+module Zilliqa
+  module Crypto
+    class Schnorr
+      include Secp256k1
+
+      N = OpenSSL::BN.new('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 16)
+      G = OpenSSL::BN.new('79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798', 16)
+
+      def initialize
+      end
+
+      # sign
+      #
+      # @param {String} msg
+      # @param {String} key
+      def self.sign(message, private_key, public_key)
+        sig = nil
+        until sig
+          k = Util.encode_hex SecureRandom.random_bytes(32)
+          k_bn = OpenSSL::BN.new(k, 16)
+
+          sig = try_sign(message, private_key, k_bn, public_key)
+          sig = Zilliqa::Util::Validator.signature?(sig.to_s) ? sig : nil
+        end
+
+        sig
+      end
+
+      # trySign
+      #
+      # @param {String} message - the message to sign over
+      # @param {String} privateKey - the private key
+      # @param {BN} k_bn - output of the HMAC-DRBG
+      #
+      # @returns {Signature | null =>}
+      def self.try_sign(message, private_key, k_bn, public_key)
+        group = OpenSSL::PKey::EC::Group.new('secp256k1')
+
+        prikey_bn = OpenSSL::BN.new(private_key, 16)
+
+        pubkey_bn = OpenSSL::BN.new(public_key, 16)
+        pubkey_point = OpenSSL::PKey::EC::Point.new(group, pubkey_bn)
+
+        throw 'Bad private key.' if prikey_bn.zero? || prikey_bn >= N
+
+        # 1a. check that k is not 0
+        return nil if k_bn.zero?
+
+        # 1b. check that k is < the order of the group
+        return nil if k_bn >= N
+
+        # 2. Compute commitment Q = kG, where g is the base point
+        q_point = pubkey_point.mul(0, k_bn)
+
+        # 3. Compute the challenge r = H(Q || pubKey || msg)
+        # mod reduce the r value by the order of secp256k1, n
+        r_bn = hash(q_point, pubkey_point, message) % N
+
+        return nil if r_bn.zero?
+
+        # 4. Compute s = k - r * prv
+        # 4a. Compute r * prv
+        s_bn = r_bn * prikey_bn % N
+        # 4b. Compute s = k - r * prv mod n
+        s_bn = k_bn.mod_sub(s_bn, N)
+
+        return nil if s_bn.zero?
+
+        Signature.new(r_bn.to_s(16), s_bn.to_s(16))
+      end
+
+
+      # Verify signature.
+      #
+      # @param {Buffer} message
+      # @param {Buffer} sig
+      # @param {Buffer} public_key
+      #
+      # @returns {boolean}
+      #
+      # 1. Check if r,s is in [1, ..., order-1]
+      # 2. Compute Q = sG + r*kpub
+      # 3. If Q = O (the neutral point), return 0;
+      # 4. r' = H(Q, kpub, m)
+      # 5. return r' == r
+      def self.verify(message, sig, public_key)
+        pubkey = PublicKey.new
+        pubkey.deserialize Util.decode_hex(public_key)
+
+        r = sig.r
+        r_bn = OpenSSL::BN.new(r, 16)
+
+        s = sig.s
+        s_bn = OpenSSL::BN.new(s, 16)
+
+        throw 'Invalid signature' if (s_bn.zero? || r_bn.zero?)
+
+        throw 'Invalid signature' if (s_bn.negative? || r_bn.negative?)
+
+        throw 'Invalid signature' if (s_bn >= N || r_bn >= N)
+
+        group = OpenSSL::PKey::EC::Group.new('secp256k1')
+        pubkey_bn = OpenSSL::BN.new(public_key, 16)
+        pubkey_point = OpenSSL::PKey::EC::Point.new(group, pubkey_bn)
+
+        throw 'Invalid public key' unless pubkey_point.on_curve?
+
+        q_point = pubkey_point.mul(r_bn, s_bn)
+
+        throw 'Invalid intermediate point.' if q_point.infinity?
+
+        h_bn = self.hash(q_point, pubkey_point, message) % N
+
+        throw 'Invalid hash.' if (h_bn.zero?)
+
+        h_bn.eql?(r_bn)
+      end
+
+
+      # Hash (r | M).
+      def self.hash(q_point, pubkey_point, message)
+        sha256 = Digest::SHA256.new
+        sha256 << q_point.to_octet_string(:compressed)
+        sha256 << pubkey_point.to_octet_string(:compressed)
+        sha256 << Util.decode_hex(message)
+
+        OpenSSL::BN.new(sha256.hexdigest, 16)
+      end
+    end
+
+    class Signature
+      attr_reader :r, :s
+      def initialize(r, s)
+        @r = r
+        @s = s
+      end
+
+      def to_s
+        "#{@r}#{@s}"
+      end
+    end
+  end
+end

data/lib/zilliqa/jsonrpc/provider.rb

@@ -0,0 +1,31 @@
+require 'jsonrpc-client'
+
+module JSONRPC
+  class Base
+    def self.make_id
+      "1"
+    end
+  end
+end
+
+module Zilliqa
+  module Jsonrpc
+    class Provider
+      def initialize(endpoint)
+        conn = Faraday.new { |connection|
+          connection.adapter Faraday.default_adapter
+        }
+        @client = JSONRPC::Client.new(endpoint, { connection: conn })
+        @endpoint = endpoint
+      end
+
+      def method_missing(sym, *args)
+        @client.invoke(sym.to_s, args)
+      end
+
+      def testnet?
+        @endpoint && !@endpoint.match('dev').nil?
+      end
+    end
+  end
+end

data/lib/zilliqa/proto/message.proto

@@ -0,0 +1,44 @@
+syntax = "proto2";
+
+package laksa.proto;
+
+// ============================================================================
+// Primitives
+// ============================================================================
+
+        message ByteArray
+        {
+         required bytes data = 1;
+        }
+
+        message ProtoTransactionCoreInfo
+        {
+        optional uint32 version      = 1;
+        optional uint64 nonce        = 2;
+        optional bytes toaddr           = 3;
+        optional ByteArray senderpubkey = 4;
+        optional ByteArray amount       = 5;
+        optional ByteArray gasprice     = 6;
+        optional uint64 gaslimit     = 7;
+        optional bytes code             = 8;
+        optional bytes data             = 9;
+        }
+
+        message ProtoTransaction
+        {
+        optional bytes tranid                  = 1;
+        optional ProtoTransactionCoreInfo info = 2;
+        optional ByteArray signature           = 3;
+        }
+
+        message ProtoTransactionReceipt
+        {
+        optional bytes receipt    = 1;
+        optional uint64 cumgas = 2;
+        }
+
+        message ProtoTransactionWithReceipt
+        {
+        optional ProtoTransaction transaction    = 1;
+        optional ProtoTransactionReceipt receipt = 2;
+        }

data/lib/zilliqa/proto/message_pb.rb

@@ -0,0 +1,46 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: message.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("message.proto", :syntax => :proto2) do
+    add_message "laksa.proto.ByteArray" do
+      required :data, :bytes, 1
+    end
+    add_message "laksa.proto.ProtoTransactionCoreInfo" do
+      optional :version, :uint32, 1
+      optional :nonce, :uint64, 2
+      optional :toaddr, :bytes, 3
+      optional :senderpubkey, :message, 4, "laksa.proto.ByteArray"
+      optional :amount, :message, 5, "laksa.proto.ByteArray"
+      optional :gasprice, :message, 6, "laksa.proto.ByteArray"
+      optional :gaslimit, :uint64, 7
+      optional :code, :bytes, 8
+      optional :data, :bytes, 9
+    end
+    add_message "laksa.proto.ProtoTransaction" do
+      optional :tranid, :bytes, 1
+      optional :info, :message, 2, "laksa.proto.ProtoTransactionCoreInfo"
+      optional :signature, :message, 3, "laksa.proto.ByteArray"
+    end
+    add_message "laksa.proto.ProtoTransactionReceipt" do
+      optional :receipt, :bytes, 1
+      optional :cumgas, :uint64, 2
+    end
+    add_message "laksa.proto.ProtoTransactionWithReceipt" do
+      optional :transaction, :message, 1, "laksa.proto.ProtoTransaction"
+      optional :receipt, :message, 2, "laksa.proto.ProtoTransactionReceipt"
+    end
+  end
+end
+
+module Zilliqa
+  module Proto
+    ByteArray = Google::Protobuf::DescriptorPool.generated_pool.lookup("laksa.proto.ByteArray").msgclass
+    ProtoTransactionCoreInfo = Google::Protobuf::DescriptorPool.generated_pool.lookup("laksa.proto.ProtoTransactionCoreInfo").msgclass
+    ProtoTransaction = Google::Protobuf::DescriptorPool.generated_pool.lookup("laksa.proto.ProtoTransaction").msgclass
+    ProtoTransactionReceipt = Google::Protobuf::DescriptorPool.generated_pool.lookup("laksa.proto.ProtoTransactionReceipt").msgclass
+    ProtoTransactionWithReceipt = Google::Protobuf::DescriptorPool.generated_pool.lookup("laksa.proto.ProtoTransactionWithReceipt").msgclass
+  end
+end

data/lib/zilliqa/util/bech32.rb

@@ -0,0 +1,28 @@
+require 'bitcoin'
+
+module Zilliqa
+  module Util
+    class Bech32
+
+      def self.to_bech32(address)
+        raise 'Invalid address format.' unless Validator.address?(address)
+
+        address = address.sub('0x','')
+
+        ret = Bitcoin::Bech32.convert_bits(Util.decode_hex(address).bytes, from_bits: 8, to_bits: 5, pad: false)
+
+        Bitcoin::Bech32.encode('zil', ret);
+      end
+
+      def self.from_bech32(address)
+        data = Bitcoin::Bech32.decode(address)
+
+        raise 'Expected hrp to be zil' unless data[0] == 'zil'
+
+        ret = Bitcoin::Bech32.convert_bits(data[1], from_bits: 5, to_bits: 8, pad: false)
+
+        Zilliqa::Account::Wallet.to_checksum_address(Util.encode_hex(ret.pack('c*'))).sub('0x', '')
+      end
+    end
+  end
+end

data/lib/zilliqa/util/unit.rb

@@ -0,0 +1,37 @@
+module Zilliqa
+  module Util
+    class Unit
+      ZIL = 'zil'
+      LI = 'li'
+      QA = 'qa'
+
+      def self.from_qa(qa, unit, is_pack = false)
+        ret = case unit
+        when ZIL
+          qa / 1000000000000.0
+        when LI
+          qa / 1000000.0
+        when QA
+          qa
+        end
+
+        if is_pack
+          ret.round
+        else
+          ret
+        end
+      end
+
+      def self.to_qa(qa, unit)
+        case unit
+        when ZIL
+          qa * 1000000000000
+        when LI
+          qa * 1000000
+        when QA
+          qa
+        end
+      end
+    end
+  end
+end

data/lib/zilliqa/util/util.rb

@@ -0,0 +1,17 @@
+module Zilliqa
+  module Util
+    extend self
+
+    def pack(a, b)
+      a << 16 + b
+    end
+
+    def encode_hex(b)
+      b.unpack('H*').first
+    end
+
+    def decode_hex(s)
+      [s].pack('H*')
+    end
+  end
+end

data/lib/zilliqa/util/validator.rb

@@ -0,0 +1,41 @@
+module Zilliqa
+  module Util
+    class Validator
+      def self.public_key?(public_key)
+        m = /(0x)?\h{66}/ =~ public_key
+        m != nil
+      end
+
+      def self.private_key?(private_key)
+        m = /(0x)?\h{64}/ =~ private_key
+        m != nil
+      end
+
+      def self.address?(address)
+        return true if bech32?(address)
+        m = /(0x)?\h{40}/ =~ address
+        m != nil
+      end
+
+      def self.signature?(signature)
+        m = /(0x)?\h{128}/ =~ signature
+        m != nil
+      end
+
+      # checksum_address?
+      #
+      # takes hex-encoded string and returns boolean if address is checksumed
+      #
+      # @param {string} address
+      # @returns {boolean}
+      def self.checksum_address?(address)
+        self.address?(address) && Zilliqa::Account::Wallet::to_checksum_address(address) == address
+      end
+
+      def self.bech32?(address)
+        m = /^zil1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38}/ =~ address
+        m != nil
+      end
+    end
+  end
+end