zilliqa 0.1.1

data/README.md

@@ -0,0 +1,175 @@
+# Zilliqa - Zilliqa Blockchain Ruby Library
+
+- [Zilliqa API doc](https://apidocs.zilliqa.com/)
+- The project is still under development.
+
+
+
+## Table of Contents
+
+<!-- TOC depthFrom:1 depthTo:6 withLinks:1 orderedList:0 -->
+
+#### [Requirements](#requirement)
+#### [Installation](#installation)
+#### [Zilliqa KeyTool](#zilliqa-keytool)
+#### [Transaction](#transaction-z)
+#### [Wallet](#wallet-z)
+- [Smart Contract](#contract)
+    - [Create](#contract-create)
+    - [Deploy](#contract-deploy)
+
+<!-- /TOC -->
+
+
+
+## <a name="requirement"></a>Requirement
+
+- Ruby(2.5.3)
+
+
+
+## <a name="installation"></a>Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zilliqa'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zilliqa
+
+
+
+## <a name="zilliqa-keytool"></a>Zilliqa KeyTool
+
+### Generate A new address
+```ruby
+private_key = Zilliqa::Crypto::KeyTool.generate_private_key
+public_key = Zilliqa::Crypto::KeyTool.get_public_key_from_private_key(private_key)
+address = Zilliqa::Crypto::KeyTool.get_address_from_private_key(private_key)
+```
+
+### Validate an address
+```ruby
+address = '2624B9EA4B1CD740630F6BF2FEA82AAC0067070B'
+Zilliqa::Util::Validator.address?(address)
+```
+
+### Validate checksum address
+```ruby
+checksum_address = '0x4BAF5faDA8e5Db92C3d3242618c5B47133AE003C'
+Zilliqa::Util::Validator.checksum_address?(checksum_address)
+```
+
+
+## <a name="transaction-z"></a>Transaction
+
+```ruby
+provider = Zilliqa::Jsonrpc::Provider.new('https://dev-api.zilliqa.com')
+to_addr = 'zil1lpw9fc8p4tse55r85fa37gscnkxf6xq5ahe8uj'
+pub_key = '032cfec301c57acc2a4b18f47247687a1ec51e61336a7d5936e455b7dab3ae712e'
+testnet = 21_823_489
+
+tx_params = {
+  version: testnet,
+  amount: '0',
+  to_addr: to_addr,
+  gas_price: '1000',
+  gas_limit: 1,
+  sender_pub_key: pub_key
+}
+
+wallet = Zilliqa::Account::Wallet.new(provider)
+transaction = Zilliqa::Account::Transaction.new(tx_params, provider)
+
+wallet.add_by_private_key(private_key)
+
+tx = wallet.sign(transaction)
+tx.submit!
+```
+
+## <a name="wallet-z"></a>Wallet
+
+```ruby
+provider = Zilliqa::Jsonrpc::Provider.new('https://dev-api.zilliqa.com')
+wallet = Zilliqa::Account::Wallet.new(provider)
+wallet.add_by_private_key(private_key)
+wallet.transfer('zil1lpw9fc8p4tse55r85fa37gscnkxf6xq5ahe8uj', 10 ** 12)
+```
+
+```
+Successfull output
+{
+"ContractAddress"=>"1e366b36e5a17dec83c46f19d8d6b43434bd1dbb",
+ "Info"=>"Contract Creation txn, sent to shard",
+ "TranID"=>"411c1108800ac85118fcd9a44568d208276dcbdd5287c99119c69167912f344a"
+}
+```
+
+## <a name="contract"> </a>Smart Contract
+
+
+### <a name="contract-create"> </a>Create Smart contract
+```ruby
+private_key = "e19d05c5452598..."
+provider = Zilliqa::Jsonrpc::Provider.new('https://dev-api.zilliqa.com')
+wallet = Zilliqa::Account::Wallet.new(provider)
+address = wallet.add_by_private_key(private_key)
+
+factory = Zilliqa::Contract::ContractFactory.new(provider, wallet)
+
+contract = factory.new_contract(TEST_CONTRACT, [
+  {
+    vname: 'owner',
+    type: 'ByStr20',
+    value: '0x124567890124567890124567890124567890',
+  },
+],
+ABI,
+)
+```
+
+### <a name="contract-deploy"> </a>Deploy contract
+
+##### [How to calculate gas limit for smart contract transaction](https://drive.google.com/file/d/1c0EJXELVe_MxhULPuJgwGvxFGenG7fmK/view?usp=sharing)
+
+```ruby
+gas_limit = TEST_CONTRACT.bytes.size + ABI.to_s.bytes.size
+```
+
+```ruby
+gas_price = 10 ** 12 # 1 zil
+testnet_ver = 21_823_489
+pub_key = '032cfec301...'
+
+deploy_params = Zilliqa::Contract::DeployParams.new(nil, testnet_ver, nil, gas_price, gas_limit, pub_key)
+tx, deployed = contract.deploy(deploy_params)
+
+assert tx.confirmed?
+assert deployed.deployed?
+assert_equal Zilliqa::Contract::CONTRACT_STATUSES[: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: Zilliqa::Util.pack(8, 8),
+        amount: 0,
+        gasPrice: 1000,
+        gasLimit: 1000
+      })
+
+
+receipt = call_tx.receipt
+```

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 "zilliqa"
+
+# 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/lib/zilliqa.rb

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

data/lib/zilliqa/account/account.rb

@@ -0,0 +1,34 @@
+module Zilliqa
+  module Account
+    class Account
+      attr_reader :private_key, :public_key, :address
+      def initialize(private_key)
+        @private_key = private_key
+        @public_key = Zilliqa::Crypto::KeyTool.get_public_key_from_private_key(private_key, true)
+        @address = Zilliqa::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 = Zilliqa::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 = Zilliqa::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)
+
+        Zilliqa::Crypto::Schnorr.sign(message_hex, @private_key, @public_key)
+      end
+    end
+  end
+end

data/lib/zilliqa/account/transaction.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Zilliqa
+  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
+      class StandardLengthError < StandardError
+        def initialize(msg = 'standard length exceeded for value')
+          super
+        end
+      end
+
+      class TrackTxError < StandardError; end
+      class TransactionError < JSONRPC::Error::ServerError; end
+
+      ATTRIBUTES = %i[id version nonce amount gas_price gas_limit signature receipt sender_pub_key to_addr code data to_ds].freeze
+      attr_accessor(*ATTRIBUTES)
+      attr_accessor :provider, :status
+
+      GET_TX_ATTEMPTS = 33
+      MAX_BIGINT_BYTES = 2**128 - 1
+      TX_STATUSES = {
+        initialized: 0,
+        pending: 1,
+        confirmed: 2,
+        rejected: 3
+      }.freeze
+
+      def initialize(tx_params, provider, status = TX_STATUSES[:initialized], to_ds = false)
+        unless tx_params.nil?
+          tx_params.each do |key, value|
+            next unless ATTRIBUTES.include?(key)
+            instance_variable_set("@#{key}", value)
+          end
+        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, TX_STATUSES[:confirmed])
+      end
+
+      # constructs an already-rejected transaction.
+      def self.reject(tx_params, provider)
+        Transaction.new(tx_params, provider, TX_STATUSES[:rejected])
+      end
+
+      def bytes
+        protocol = Zilliqa::Proto::ProtoTransactionCoreInfo.new
+        protocol.version = version.to_i
+        protocol.nonce = nonce.to_i
+        protocol.toaddr = Util.decode_hex(Wallet.to_checksum_address(to_addr).downcase.sub('0x', ''))
+        protocol.senderpubkey = Zilliqa::Proto::ByteArray.new(data: Util.decode_hex(sender_pub_key))
+
+        raise StandardLengthError if amount.to_i > MAX_BIGINT_BYTES
+
+        protocol.amount = Zilliqa::Proto::ByteArray.new(data: bigint_to_bytes(amount.to_i))
+        protocol.gasprice = Zilliqa::Proto::ByteArray.new(data: bigint_to_bytes(gas_price.to_i))
+        protocol.gaslimit = gas_limit.to_i
+        protocol.code = code if code
+        protocol.data = data if data
+
+        Zilliqa::Proto::ProtoTransactionCoreInfo.encode(protocol)
+      end
+
+      def to_payload
+        {
+          version: version.to_i,
+          nonce: nonce.to_i,
+          toAddr: Wallet.to_checksum_address(to_addr),
+          amount: amount.to_s,
+          pubKey: sender_pub_key,
+          gasPrice: gas_price.to_s,
+          gasLimit: gas_limit.to_i,
+          code: code,
+          data: data,
+          signature: signature
+        }
+      end
+
+      def pending?
+        @status == TX_STATUSES[:pending]
+      end
+
+      def initialised?
+        @status == TX_STATUSES[:initialized]
+      end
+
+      def confirmed?
+        @status == TX_STATUSES[:confirmed]
+      end
+
+      def rejected?
+        @status == TX_STATUSES[: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 = TX_STATUSES[:pending]
+        1.upto(max_attempts) do
+          return self if track_tx(tx_hash)
+
+          sleep(interval)
+        end
+
+        self.status = TX_STATUSES[:rejected]
+        throw 'The transaction is still not confirmed after ${maxAttempts} attempts.'
+      end
+
+      def track_tx(tx_hash)
+        begin
+          response = @provider.GetTransaction(tx_hash)
+        rescue TrackTxError
+        end
+
+        if response['error']
+          return false
+        end
+
+        self.id = response['result']['ID']
+        self.receipt = response['result']['receipt']
+        receipt['cumulative_gas'] = response['result']['receipt']['cumulative_gas'].to_i
+        self.status = receipt && receipt['success'] ? TX_STATUSES[:confirmed] : TX_STATUSES[:rejected]
+
+        true
+      end
+
+      def submit!
+        provider.CreateTransaction(to_payload)
+      rescue TransactionError => e
+        { error: e }
+      end
+
+      private
+
+      def bigint_to_bytes(value)
+        raise StandardLengthError if value > MAX_BIGINT_BYTES
+
+        bs = [value / (2**64), value % (2**64)].pack('Q>*')
+      end
+    end
+  end
+end

data/lib/zilliqa/account/transaction_factory.rb

@@ -0,0 +1,16 @@
+module Zilliqa
+  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, Zilliqa::Account::Transaction::TX_STATUSES[:initialized], to_ds)
+      end
+    end
+  end
+end