zilliqa 0.1.1

data/lib/zilliqa/account/wallet.rb

@@ -0,0 +1,146 @@
+require 'digest'
+
+module Zilliqa
+  module Account
+    class Wallet
+      MAINNET = 65_537
+
+      # Takes an array of Account objects and instantiates a Wallet instance.
+      def initialize(provider = nil, accounts = {})
+        @provider = provider
+        @accounts = accounts
+        if accounts.length > 0
+          @default_account = accounts[0]
+        else
+          @default_account = nil
+        end
+      end
+
+      # Creates a new keypair with a randomly-generated private key. The new
+      # account is accessible by address.
+      def create
+        private_key = Zilliqa::Crypto::KeyTool.generate_private_key
+        account = Zilliqa::Account::Account.new(private_key)
+
+        @accounts[account.address] = account
+
+        @default_account = account unless @default_account
+
+        account.address
+      end
+
+      # Adds an account to the wallet by private key.
+      def add_by_private_key(private_key)
+        account = Zilliqa::Account::Account.new(private_key)
+
+        @accounts[account.address] = account
+
+        @default_account = account unless @default_account
+
+        account.address
+      end
+
+
+      # Adds an account by keystore
+      def add_by_keystore(keystore, passphrase)
+        account = Zilliqa::Account::Account.from_file(keystore, passphrase)
+
+        @accounts[account.address] = account
+
+        @default_account = account unless @default_account
+
+        account.address
+      end
+
+      # Removes an account from the wallet and returns boolean to indicate
+      # failure or success.
+
+      def remove(address)
+        if @accounts.has_key?(address)
+          @accounts.delete(address)
+
+          true
+        else
+          false
+        end
+      end
+
+      # Sets the default account of the wallet.
+      def set_default(address)
+        @default_account = @accounts[address]
+      end
+
+      # to_checksum_address
+      #
+      # takes hex-encoded string and returns the corresponding address
+      #
+      # @param {string} address
+      # @returns {string}
+      def self.to_checksum_address(address)
+        return Zilliqa::Util::Bech32.from_bech32(address) if Zilliqa::Util::Validator.bech32?(address)
+        address = address.downcase.gsub('0x', '')
+
+        s1 = Digest::SHA256.hexdigest(Util.decode_hex(address))
+        v = s1.to_i(base=16)
+
+        ret = ['0x']
+        address.each_char.each_with_index do |c, idx|
+          if '1234567890'.include?(c)
+            ret << c
+          else
+            ret << ((v & (2 ** (255 - 6 * idx))) < 1 ? c.downcase : c.upcase)
+          end
+        end
+
+        ret.join
+      end
+
+      def transfer(to_addr, amount)
+        gas_price = Integer(@provider.GetMinimumGasPrice)
+        gas_limit = 1
+
+        tx = sign(Zilliqa::Account::Transaction.new({
+          version: MAINNET,
+          amount: amount.to_s,
+          to_addr: to_addr,
+          gas_price: gas_price.to_s,
+          gas_limit: gas_limit
+        }, @provider))
+        tx.submit!
+      end
+
+      # signs an unsigned transaction with the default account.
+      def sign(tx)
+        if tx.sender_pub_key
+          # attempt to find the address
+          address = Zilliqa::Crypto::KeyTool.get_address_from_public_key(tx.sender_pub_key)
+          account = @accounts[address]
+          raise 'Could not sign the transaction with address as it does not exist' unless account
+
+          sign_with(tx, address)
+        else
+          raise 'This wallet has no default account.' unless @default_account
+
+          sign_with(tx, @default_account.address)
+        end
+      end
+
+      def sign_with(tx, address)
+        account = @accounts[address]
+        address = @provider.testnet? ? Zilliqa::Util::Bech32.from_bech32(account.address) : account.address
+
+        raise 'The selected account does not exist on this Wallet instance.' unless account
+
+        if tx.nonce.nil?
+          result = @provider.GetBalance(address)
+          tx.nonce = result['nonce'].to_i + 1
+        end
+
+        tx.sender_pub_key = account.public_key
+        sig = account.sign_transaction(tx)
+        tx.signature = sig.to_s
+        tx
+      end
+    end
+  end
+end

data/lib/zilliqa/contract/contract.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Zilliqa
+  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?
+        @status == ContractStatus::INITIALISED
+      end
+
+      def deployed?
+        @status == ContractStatus::DEPLOYED
+      end
+
+      def rejected?
+        @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.zero?
+
+        tx_params = {
+          id: deploy_params.id,
+          version: deploy_params.version,
+          nonce: deploy_params.nonce,
+          sender_pub_key: deploy_params.sender_pub_key,
+          gas_price: deploy_params.gas_price,
+          gas_limit: deploy_params.gas_limit,
+          to_addr: NIL_ADDRESS,
+          amount: '0',
+          code: @code.gsub('/\\', ''),
+          data: @init.to_json.gsub('\\"', '"')
+        }
+
+        tx = Transaction.new(tx_params, @provider)
+
+        tx = 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 = {
+          id: params['id'],
+          version: params['version'],
+          nonce: params['nonce'],
+          sender_pub_key: params['sender_pub_key'],
+          gas_price: params['gas_price'],
+          gas_limit: params['gas_limit'],
+          to_addr: @address,
+          data: JSON.generate(data)
+        }
+
+        tx = Transaction.new(tx_params, @provider, Zilliqa::Account::Transaction::TX_STATUSES[:initialized], to_ds)
+
+        prepare_tx(tx, attempts, interval)
+      end
+
+      def state
+        return [] unless deployed
+
+        response = @provider.GetSmartContractState(@address)
+        response.result
+      end
+
+      def prepare_tx(tx, attempts, interval)
+        tx = @signer.sign(tx)
+
+        response = @provider.CreateTransaction(tx.to_payload)
+
+        if response['error']
+          tx.status = Zilliqa::Account::Transaction::TX_STATUSES[: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/zilliqa/contract/contract_factory.rb

@@ -0,0 +1,47 @@
+require 'digest'
+
+module Zilliqa
+  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 = Zilliqa::Crypto::KeyTool.get_address_from_public_key(tx.sender_pub_key)
+
+        sha256 << Util.decode_hex(sender_address)
+
+        nonce = 0
+        if tx.nonce
+          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/zilliqa/crypto/key_store.rb

@@ -0,0 +1,113 @@
+require 'pbkdf2'
+require 'scrypt'
+require 'openssl'
+require 'digest'
+require 'json'
+
+module Zilliqa
+  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