laksa 0.1.0

data/README.md

@@ -0,0 +1,94 @@
+# Laksa
+
+Laksa -- Zilliqa Blockchain Ruby Library
+
+The project is still under development.
+
+## Requirement
+
+Ruby(2.5.3)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'laksa'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install laksa
+
+## Usage
+
+### Generate A new address
+```ruby
+private_key = Laksa::Crypto::KeyTool.generate_private_key
+public_key = Laksa::Crypto::KeyTool.get_public_key_from_private_key(private_key)
+address = Laksa::Crypto::KeyTool.get_address_from_private_key(private_key)
+```
+
+### Validate an address
+```ruby
+address = '2624B9EA4B1CD740630F6BF2FEA82AAC0067070B'
+Laksa::Util::Validator.address?(address)
+```
+
+### Validate checksum address
+```ruby
+checksum_address = '0x4BAF5faDA8e5Db92C3d3242618c5B47133AE003C'
+Laksa::Util::Validator.checksum_address?(checksum_address)
+```
+
+### Deploy and Call a transaction
+```ruby
+private_key = "e19d05c5452598e24caad4a0d85a49146f7be089515c905ae6a19e8a578a6930"
+
+provider = Laksa::Jsonrpc::Provider.new('https://dev-api.zilliqa.com')
+wallet = Laksa::Account::Wallet.new(provider)
+address = wallet.add_by_private_key(private_key)
+
+factory = Laksa::Contract::ContractFactory.new(provider, wallet)
+
+contract = factory.new_contract(TEST_CONTRACT, [
+  {
+    vname: 'owner',
+    type: 'ByStr20',
+    value: '0x124567890124567890124567890124567890',
+  },
+],
+ABI,
+)
+
+deploy_params = Laksa::Contract::DeployParams.new(nil, Laksa::Util.pack(8, 8), nil, 1000, 1000, nil)
+tx, deployed = contract.deploy(deploy_params)    
+
+assert tx.confirmed?
+assert deployed.deployed?
+assert_equal Laksa::Contract::ContractStatus::DEPLOYED, deployed.status
+
+assert /[A-F0-9]+/ =~ contract.address
+
+# call a deployed contract
+call_tx = deployed.call(
+      'setHello',
+      [
+        { vname: 'msg', type: 'String', value: 'Hello World!' },
+      ],
+      {
+        version: Laksa::Util.pack(8, 8),
+        amount: 0,
+        gasPrice: 1000,
+        gasLimit: 1000
+      })
+
+
+receipt = call_tx.tx_params.receipt
+```
+
+the definition of [TEST_CONTRACT](https://github.com/FireStack-Lab/LaksaRuby/blob/master/test/contract/test_contract.rb) and [ABI](https://github.com/FireStack-Lab/LaksaRuby/blob/master/test/contract/test_abi.rb) can be found in this folder. 

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "laksa"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/laksa.gemspec

@@ -0,0 +1,46 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "laksa/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "laksa"
+  spec.version       = Laksa::VERSION
+  spec.authors       = ["cenyongh"]
+  spec.email         = ["cenyongh@gmail.com"]
+
+  spec.summary       = %q{LaksaRuby -- Zilliqa Blockchain  Library}
+  spec.description   = %q{LaksaRuby -- Zilliqa Blockchain  Library}
+  spec.homepage      = "https://github.com/FireStack-Lab/LaksaRuby"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/FireStack-Lab/LaksaRuby"
+    spec.metadata["changelog_uri"] = "https://github.com/FireStack-Lab/LaksaRuby"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_dependency "bitcoin-secp256k1"
+  spec.add_dependency "scrypt"
+  spec.add_dependency "pbkdf2-ruby"
+  spec.add_dependency "jsonrpc-client"
+  spec.add_dependency 'google-protobuf'
+  spec.add_dependency 'bitcoin-ruby'
+end

data/lib/laksa.rb

@@ -0,0 +1,21 @@
+require "laksa/version"
+require 'laksa/crypto/key_tool'
+require 'laksa/crypto/key_store'
+require 'laksa/crypto/schnorr'
+require 'laksa/jsonrpc/provider'
+require 'laksa/account/account'
+require 'laksa/account/wallet'
+require 'laksa/account/transaction_factory'
+require 'laksa/account/transaction'
+require 'laksa/proto/message_pb'
+require 'laksa/contract/contract_factory'
+require 'laksa/contract/contract'
+require 'laksa/util/validator'
+require 'laksa/util/util'
+require 'laksa/util/unit'
+require 'laksa/util/bech32'
+
+
+module Laksa
+  
+end

data/lib/laksa/account/account.rb

@@ -0,0 +1,34 @@
+module Laksa
+  module Account
+    class Account
+      attr_reader :private_key, :public_key, :address
+      def initialize(private_key)
+        @private_key = private_key
+        @public_key = Laksa::Crypto::KeyTool.get_public_key_from_private_key(private_key, true)
+        @address = Laksa::Crypto::KeyTool.get_address_from_public_key(@public_key)
+      end
+
+      # Takes a JSON-encoded keystore and passphrase, returning a fully
+      # instantiated Account instance.
+      def self.from_file(file, passphrase)
+        key_store = Laksa::Crypto::KeyStore.new
+        private_key = key_store.decrypt_private_key(file, passphrase)
+        Account.new(private_key)
+      end
+
+      # Convert an Account instance to a JSON-encoded keystore.
+      def to_file(passphrase, type)
+        key_store = Laksa::Crypto::KeyStore.new
+        json = key_store.encrypt_private_key(@private_key, passphrase, type);
+      end
+
+      # sign the passed in transaction with the account's private and public key
+      def sign_transaction(tx)
+        message = tx.bytes
+        message_hex = Util.encode_hex(message)
+        
+        Laksa::Crypto::Schnorr.sign(message_hex, @private_key, @public_key)
+      end
+    end
+  end
+end

data/lib/laksa/account/transaction.rb

@@ -0,0 +1,184 @@
+module Laksa
+  module Account
+    # 
+    # Transaction
+    # 
+    # Transaction is a functor. Its purpose is to encode the possible states a
+    # Transaction can be in:  Confirmed, Rejected, Pending, or Initialised (i.e., not broadcasted).
+    class Transaction
+      attr_accessor :id, :version, :nonce, :amount, :gas_price, :gas_limit, :signature, :receipt, :sender_pub_key, :to_addr, :code, :data, :to_ds
+      attr_accessor :provider, :status
+
+      GET_TX_ATTEMPTS = 33
+
+      def initialize(tx_params, provider, status = TxStatus::INITIALIZED, to_ds = false)
+        if tx_params
+          @version = tx_params.version;
+          @nonce = tx_params.nonce
+          @amount = tx_params.amount
+          @gas_price = tx_params.gas_price
+          @gas_limit = tx_params.gas_limit
+          @signature = tx_params.signature
+          @receipt = tx_params.receipt
+          @sender_pub_key = tx_params.sender_pub_key
+          @to_addr = tx_params.to_addr.downcase
+          @code = tx_params.code
+          @data = tx_params.data
+        end
+
+        @provider = provider
+        @status = status
+        @to_ds = to_ds
+      end
+
+      # constructs an already-confirmed transaction.
+      def self.confirm(tx_params, provider)
+        Transaction.new(tx_params, provider, TxStatus::CONFIRMED)
+      end
+
+      # constructs an already-rejected transaction.
+      def self.reject(tx_params, provider) 
+        Transaction.new(tx_params, provider, TxStatus::REJECTED)
+      end
+
+      def bytes
+        protocol = Laksa::Proto::ProtoTransactionCoreInfo.new
+        protocol.version = self.version
+        protocol.nonce = self.nonce
+        protocol.toaddr =  Util.decode_hex(self.to_addr.downcase.sub('0x',''))
+        protocol.senderpubkey = Laksa::Proto::ByteArray.new(data: Util.decode_hex(self.sender_pub_key))
+
+        raise 'standard length exceeded for value' if self.amount.to_i > 2 ** 128 - 1
+
+        protocol.amount = Laksa::Proto::ByteArray.new(data: bigint_to_bytes(self.amount.to_i))
+        protocol.gasprice = Laksa::Proto::ByteArray.new(data: bigint_to_bytes(self.gas_price.to_i))
+        protocol.gaslimit = self.gas_limit
+        protocol.code = self.code if self.code
+        protocol.data = self.data if self.data
+
+        Laksa::Proto::ProtoTransactionCoreInfo.encode(protocol)
+      end
+
+      def tx_params
+        tx_params = TxParams.new
+
+        tx_params.id = self.id
+        tx_params.version = self.version
+        tx_params.nonce = self.nonce
+        tx_params.amount = self.amount
+        tx_params.gas_price = self.gas_price
+        tx_params.gas_limit = self.gas_limit
+        tx_params.signature = self.signature
+        tx_params.receipt = self.receipt
+        tx_params.sender_pub_key = self.sender_pub_key
+        tx_params.to_addr = Wallet.to_checksum_address(self.to_addr)
+        tx_params.code = self.code
+        tx_params.data = self.data
+
+        tx_params
+      end
+
+      def to_payload
+        {
+          version: self.version.to_i,
+          nonce: self.nonce.to_i,
+          toAddr: Wallet.to_checksum_address(self.to_addr),
+          amount: self.amount,
+          pubKey: self.sender_pub_key,
+          gasPrice: self.gas_price,
+          gasLimit: self.gas_limit,
+          code: self.code,
+          data: self.data,
+          signature: self.signature
+        }
+      end
+
+      def pending?
+        @status == TxStatus::PENDING
+      end
+
+      def initialised?
+        @status === TxStatus::INITIALIZED
+      end
+
+      def confirmed?
+        @status === TxStatus::CONFIRMED;
+      end 
+
+      def rejected?
+        @status === TxStatus::REJECTED;
+      end
+
+      # This sets the Transaction instance to a state
+      # of pending. Calling this function kicks off a passive loop that polls the
+      # lookup node for confirmation on the txHash.
+      #
+      # The polls are performed with a linear backoff:
+      #
+      # This is a low-level method that you should generally not have to use
+      # directly.
+      def confirm(tx_hash, max_attempts = GET_TX_ATTEMPTS, interval = 1)
+        @status = TxStatus::PENDING
+        1.upto(max_attempts) do 
+          if self.track_tx(tx_hash)
+            return self
+          else
+            sleep(interval)
+          end
+        end
+
+        self.status = TxStatus::REJECTED
+        throw 'The transaction is still not confirmed after ${maxAttempts} attempts.'
+      end
+      
+      def track_tx(tx_hash) 
+        puts "tracking transaction: #{tx_hash}"
+
+        begin
+          response = @provider.GetTransaction(tx_hash)
+        rescue Exception => e
+          puts "transaction not confirmed yet"
+          puts e
+        end
+
+        if response['error']
+          puts "transaction not confirmed yet"
+          return false;
+        end
+
+        self.id = response['result']['ID']
+        self.receipt = response['result']['receipt']
+        self.receipt['cumulative_gas'] = response['result']['receipt']['cumulative_gas'].to_i
+
+        if self.receipt && self.receipt['success']
+          puts "Transaction confirmed!"
+          self.status = TxStatus::CONFIRMED
+        else
+          puts "Transaction rejected!"
+          self.status = TxStatus::REJECTED
+        end
+
+        true
+      end
+
+      private
+      def bigint_to_bytes(value)
+        raise 'standard length exceeded for value' if value > 2 ** 128 - 1
+        bs = [value / (2 ** 64), value % (2 ** 64)].pack('Q>*')
+      end
+    end
+
+    class TxParams
+      attr_accessor :id, :version, :nonce, :amount, :gas_price, :gas_limit, :signature, :receipt, :sender_pub_key, :to_addr, :code, :data
+      def initialize
+      end
+    end
+
+    class TxStatus
+      INITIALIZED = 0
+      PENDING = 1
+      CONFIRMED = 2
+      REJECTED = 3
+    end
+  end
+end

data/lib/laksa/account/transaction_factory.rb

@@ -0,0 +1,16 @@
+module Laksa
+  module Account
+    class TransactionFactory
+      attr_reader :provider, :signer
+
+      def initialize(provider, signer)
+        @provider = provider
+        @signer = signer
+      end
+
+      def new(tx_params, to_ds = false)
+        Transaction.new(tx_params, @provider, TxStatus::INITIALIZED, to_ds)
+      end
+    end
+  end
+end

data/lib/laksa/account/wallet.rb

@@ -0,0 +1,129 @@
+require 'digest'
+
+module Laksa
+  module Account
+    class Wallet
+      # 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 = Laksa::Crypto::KeyTool.generate_private_key
+        account = Laksa::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 = Laksa::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 = Laksa::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)
+        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
+
+      # signs an unsigned transaction with the default account.
+      def sign(tx)
+        tx_params = tx.tx_params
+        if tx_params.sender_pub_key
+          # attempt to find the address
+          address = Laksa::Crypto::KeyTool.get_address_from_public_key(tx_params.sender_pub_key)
+          account = @accounts[address]
+          raise 'Could not sign the transaction with address as it does not exist' unless account 
+
+          self.sign_with(tx, address)
+        else
+          raise 'This wallet has no default account.' unless @default_account
+
+          self.sign_with(tx, @default_account.address)  
+        end
+      end
+
+      def sign_with(tx, address)
+        account = @accounts[address]
+
+        raise 'The selected account does not exist on this Wallet instance.' unless account 
+
+        if tx.nonce == nil
+          result = @provider.GetBalance(account.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