laksa 0.1.0

data/lib/laksa/contract/contract.rb

@@ -0,0 +1,148 @@
+require 'json'
+
+module Laksa
+  module Contract
+    class Contract
+      include Account
+
+      NIL_ADDRESS = "0000000000000000000000000000000000000000";
+
+      attr_reader :factory, :provider, :signer, :code, :abi, :init, :state, :address, :status
+
+      def initialize(factory, code, abi, address, init, state)
+        @factory = factory
+        @provider = factory.provider
+        @signer = factory.signer
+
+        @code = code
+        @abi = abi
+        @init = init
+        @state = state
+
+        if address && !address.empty?
+          @address = address
+          @status = ContractStatus::DEPLOYED
+        else
+          @status = ContractStatus::INITIALISED
+        end
+      end
+
+      def initialised?
+        return @status === ContractStatus::INITIALISED
+      end
+
+      def deployed?
+        return @status === ContractStatus::DEPLOYED
+      end
+
+      def rejected?
+        return @status === ContractStatus::REJECTED
+      end
+
+      def deploy(deploy_params, attempts = 33, interval = 1000, to_ds = false) 
+        raise 'Cannot deploy without code or initialisation parameters.' if @code == nil || @code == ''
+        raise 'Cannot deploy without code or initialisation parameters.' if @init == nil || @init.length == 0
+
+        tx_params = TxParams.new
+        tx_params.id = deploy_params.id
+        tx_params.version = deploy_params.version
+        tx_params.nonce = deploy_params.nonce
+        tx_params.sender_pub_key = deploy_params.sender_pub_key
+        tx_params.gas_price = deploy_params.gas_price
+        tx_params.gas_limit = deploy_params.gas_limit
+
+        tx_params.to_addr = NIL_ADDRESS
+        tx_params.amount = '0'
+        tx_params.code = @code.gsub("/\\", "")
+        tx_params.data = @init.to_json.gsub('\\"', '"')
+
+        tx = Transaction.new(tx_params, @provider)
+
+        tx = self.prepare_tx(tx, attempts, interval);
+
+        if tx.rejected?
+          @status = ContractStatus::REJECTED
+          
+          return [tx, self]
+        end
+
+        @status = ContractStatus::DEPLOYED
+        @address = ContractFactory.get_address_for_contract(tx)
+
+        [tx, self]
+      end
+
+      def call(transition, args, params, attempts = 33, interval = 1000, to_ds = false)
+        data = {
+          _tag: transition,
+          params: args,
+        };
+
+        return 'Contract has not been deployed!' unless @address
+
+        tx_params = TxParams.new
+        tx_params.id = params['id'] if params.has_key?('id')
+        tx_params.version = params['version'] if params.has_key?('version') 
+        tx_params.nonce = params['nonce'] if params.has_key?('nonce') 
+        tx_params.sender_pub_key = params['sender_pub_key'] if params.has_key?('sender_pub_key') 
+        tx_params.gas_price = params['gas_price'] if params.has_key?('gas_price') 
+        tx_params.gas_limit = params['gas_limit'] if params.has_key?('gas_limit') 
+
+        tx_params.to_addr = @address
+        tx_params.data = JSON.generate(data)
+
+        tx = Transaction.new(tx_params, @provider, TxStatus::INITIALIZED, to_ds)
+
+        tx = self.prepare_tx(tx, attempts, interval)
+      end
+
+      def state
+        return [] unless self.deployed
+
+        response = @provider.GetSmartContractState(@address)
+        return response.result
+      end
+
+      def prepare_tx(tx, attempts, interval)
+        tx = @signer.sign(tx);
+
+        response = @provider.CreateTransaction(tx.to_payload)
+
+        if response['error']
+          tx.status = TxStatus::REJECTED
+        else
+          tx.confirm(response['result']['TranID'], attempts, interval)
+        end
+        
+        tx
+      end
+    end
+
+    class ContractStatus
+      DEPLOYED = 0
+      REJECTED = 1
+      INITIALISED = 2
+    end
+
+    class Value
+      attr_reader :vname, :type, :value
+      def initialize(vname, type, value)
+        @vname = vname
+        @type = type
+        @value = value
+      end
+    end
+
+    class DeployParams 
+      attr_reader :id, :version, :nonce, :gas_price, :gas_limit, :sender_pub_key
+      def initialize(id, version, nonce, gas_price, gas_limit, sender_pub_key)
+        @id = id
+        @version = version
+        @nonce = nonce
+        @gas_price = gas_price
+        @gas_limit = gas_limit
+        @sender_pub_key = sender_pub_key
+      end
+    end
+  end
+end

data/lib/laksa/contract/contract_factory.rb

@@ -0,0 +1,47 @@
+require 'digest'
+
+module Laksa
+  module Contract
+    # ContractFactory
+    #
+    # individual `Contract` instances are instead obtained by
+    # calling `ContractFactory.at` (for an already-deployed contract) and
+    # `ContractFactory.new` (to deploy a new contract).
+    class ContractFactory
+
+      attr_reader :provider, :signer
+
+      def initialize(provider, signer)
+        @provider = provider
+        @signer = signer
+      end
+
+      def self.get_address_for_contract(tx)
+        sha256 = Digest::SHA256.new
+
+        sender_address = Laksa::Crypto::KeyTool.get_address_from_public_key(tx.sender_pub_key)
+
+        sha256 << Util.decode_hex(sender_address)
+
+        nonce = 0;
+        if tx.nonce && !tx.nonce.empty?
+          nonce = tx.nonce.to_i - 1
+        end
+        
+        nonce_hex = [nonce].pack('Q>*')
+
+        sha256 << nonce_hex
+
+        sha256.hexdigest[24..-1]
+      end
+
+      def new_contract(code, init, abi) 
+        Contract.new(self, code, abi, nil, init, nil)
+      end
+
+      def at_contract(address, code, init, abi)
+        Contract.new(self, code, abi, address, init, nil)
+      end
+    end
+  end
+end

data/lib/laksa/crypto/key_store.rb

@@ -0,0 +1,113 @@
+require 'pbkdf2'
+require 'scrypt'
+require 'openssl'
+require 'digest'
+require 'json'
+
+module Laksa
+  module Crypto
+    class KeyStore
+      T_PBKDF2 = 'pbkdf2' 
+      T_SCRYPT = 'scrypt'
+
+      def initialize
+      end
+
+      # encryptPrivateKey
+      #
+      # Encodes and encrypts an account in the format specified by
+      # https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition.
+      # However, note that, in keeping with the hash function used by Zilliqa's
+      # core protocol, the MAC is generated using sha256 instead of keccak.
+      #
+      # NOTE: only scrypt and pbkdf2 are supported.
+      #
+      # @param {string} private_key - hex-encoded private key
+      # @param {string} password - a password used for encryption
+      # @param {KDF} kdf_type - the key derivation function to be used
+      def encrypt_private_key(private_key, password, kdf_type)
+        address = KeyTool.get_address_from_private_key(private_key)
+
+        iv = KeyTool.generate_random_bytes(16)
+        salt = KeyTool.generate_random_bytes(32)
+
+        case kdf_type
+        when T_PBKDF2
+          derived_key = PBKDF2.new(password: password, salt: salt, key_length: 32, iterations: 262144).value
+        when T_SCRYPT
+          derived_key = SCrypt::Engine.scrypt(password, salt, 8192, 8, 1, 32)
+        end
+
+        encrypt_key = derived_key[0..15]
+
+        cipher = OpenSSL::Cipher.new('aes-128-ctr')
+        cipher.encrypt
+        cipher.iv = iv
+        cipher.key = encrypt_key
+        cipher.padding = 0
+        
+        ciphertext = cipher.update(Util.decode_hex(private_key)) + cipher.final
+
+        mac = generate_mac(derived_key, ciphertext)
+
+        datas = {address: address, 
+          crypto: {
+            cipher: 'aes-128-ctr', 
+            cipherparams: {'iv': Util.encode_hex(iv)}, 
+            ciphertext: Util.encode_hex(ciphertext), 
+            kdf: kdf_type, 
+            kdfparams: {n: 8192, c:262144, r:8, p:1, dklen: 32, salt: salt.bytes}, 
+            mac: mac
+          },
+          id: SecureRandom.uuid, 
+          version: 3
+        }
+
+        datas.to_json
+      end
+
+      # decrypt_private_key
+      #
+      # Recovers the private key from a keystore file using the given passphrase.
+      #
+      # @param {KeystoreV3} encrypt_json
+      # @param {string} password
+      def decrypt_private_key(encrypt_json, password)
+        datas = JSON.parse(encrypt_json)
+
+        ciphertext = Util.decode_hex(datas['crypto']['ciphertext'])
+        iv = Util.decode_hex(datas['crypto']['cipherparams']['iv'])
+        kdfparams = datas['crypto']['kdfparams']
+        kdf_type = datas['crypto']['kdf']
+
+        case kdf_type
+        when T_PBKDF2
+          derived_key = PBKDF2.new(password: password, salt: kdfparams['salt'].pack('c*'), key_length: kdfparams['dklen'], iterations: kdfparams['c']).value
+        when T_SCRYPT
+          derived_key = SCrypt::Engine.scrypt(password, kdfparams['salt'].pack('c*'), kdfparams['n'], kdfparams['r'], kdfparams['p'], kdfparams['dklen'])
+        end
+
+        encrypt_key = derived_key[0..15]
+
+        mac = generate_mac(derived_key, ciphertext)
+        
+        raise 'Failed to decrypt.' if mac.casecmp(datas['crypto']['mac']) != 0
+
+        cipher = OpenSSL::Cipher.new(datas['crypto']['cipher'])
+        cipher.decrypt 
+        cipher.iv = iv
+        cipher.key = encrypt_key
+        cipher.padding = 0
+        
+        private_key = cipher.update(ciphertext) + cipher.final
+
+        return Util.encode_hex private_key
+      end
+
+      private
+      def generate_mac(derived_key, ciphertext)
+        Digest::SHA256.hexdigest(derived_key[16..32] + ciphertext)
+      end
+    end
+  end
+end

data/lib/laksa/crypto/key_tool.rb

@@ -0,0 +1,61 @@
+require 'secp256k1'
+require 'digest'
+
+module Laksa
+  module Crypto
+    class KeyTool
+      include Secp256k1
+      def initialize(private_key)
+        is_raw = private_key.length == 32 ? true : false
+
+        @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 ? true : false
+
+        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
+        orig_address[24..-1].downcase
+      end
+    end
+  end
+end

data/lib/laksa/crypto/schnorr.rb

@@ -0,0 +1,146 @@
+require 'secp256k1'
+require 'digest'
+require 'openssl'
+
+module Laksa
+  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
+        while !sig
+          k = Util.encode_hex SecureRandom.random_bytes(32)
+          k_bn = OpenSSL::BN.new(k, 16)
+
+          sig = self.try_sign(message, private_key, k_bn, public_key)
+        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