cita-sdk-ruby 0.20.0

data/lib/cita/http.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require "json"
+require "faraday"
+
+module CITA
+  class Http
+    attr_accessor :url
+
+    DEFAULT_JSONRPC = "2.0"
+    DEFAULT_PARAMS = [].freeze
+    DEFAULT_ID = 83
+
+    def initialize(url)
+      @url = url
+    end
+
+    # wrapper for call rpc method
+    #
+    # @param method [String] method you want to call
+    # @param jsonrpc [String] jsonrpc version
+    # @param params [Array] rpc params
+    # @param id [Integer] jsonrpc id
+    #
+    # @return [Faraday::Response]
+    def call_rpc(method, jsonrpc: DEFAULT_JSONRPC, params: DEFAULT_PARAMS, id: DEFAULT_ID)
+      conn.post("/", rpc_params(method, jsonrpc: jsonrpc, params: params, id: id))
+    end
+
+    # wrapper for rpc params
+    #
+    # @param method [String] method you want to call
+    # @param jsonrpc [String] jsonrpc version
+    # @param params [Array] rpc params
+    # @param id [Integer] jsonrpc id
+    #
+    # @return [String] json string
+    def rpc_params(method, jsonrpc: DEFAULT_JSONRPC, params: DEFAULT_PARAMS, id: DEFAULT_ID)
+      {
+        jsonrpc: jsonrpc,
+        id: id,
+        method: method,
+        params: params
+      }.to_json
+    end
+
+    # wrapper faraday object with CITA URL and Content-Type
+    #
+    # @return [Faraday]
+    def conn
+      Faraday.new(url: url) do |faraday|
+        faraday.headers["Content-Type"] = "application/json"
+        faraday.request  :url_encoded # form-encode POST params
+        faraday.adapter  Faraday.default_adapter # make requests with Net::HTTP
+      end
+    end
+  end
+end

data/lib/cita/protos/blockchain_pb.rb

@@ -0,0 +1,112 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: blockchain.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "Proof" do
+    optional :content, :bytes, 1
+    optional :type, :enum, 2, "ProofType"
+  end
+  add_message "BlockHeader" do
+    optional :prevhash, :bytes, 1
+    optional :timestamp, :uint64, 2
+    optional :height, :uint64, 3
+    optional :state_root, :bytes, 4
+    optional :transactions_root, :bytes, 5
+    optional :receipts_root, :bytes, 6
+    optional :quota_used, :uint64, 7
+    optional :quota_limit, :uint64, 8
+    optional :proof, :message, 9, "Proof"
+    optional :proposer, :bytes, 10
+  end
+  add_message "Status" do
+    optional :hash, :bytes, 1
+    optional :height, :uint64, 2
+  end
+  add_message "AccountGasLimit" do
+    optional :common_quota_limit, :uint64, 1
+    map :specific_quota_limit, :string, :uint64, 2
+  end
+  add_message "RichStatus" do
+    optional :hash, :bytes, 1
+    optional :height, :uint64, 2
+    repeated :nodes, :bytes, 3
+    optional :interval, :uint64, 4
+    optional :version, :uint32, 5
+    repeated :validators, :bytes, 6
+  end
+  add_message "Transaction" do
+    optional :to, :string, 1
+    optional :nonce, :string, 2
+    optional :quota, :uint64, 3
+    optional :valid_until_block, :uint64, 4
+    optional :data, :bytes, 5
+    optional :value, :bytes, 6
+    optional :chain_id, :uint32, 7
+    optional :version, :uint32, 8
+    optional :to_v1, :bytes, 9
+    optional :chain_id_v1, :bytes, 10
+  end
+  add_message "UnverifiedTransaction" do
+    optional :transaction, :message, 1, "Transaction"
+    optional :signature, :bytes, 2
+    optional :crypto, :enum, 3, "Crypto"
+  end
+  add_message "SignedTransaction" do
+    optional :transaction_with_sig, :message, 1, "UnverifiedTransaction"
+    optional :tx_hash, :bytes, 2
+    optional :signer, :bytes, 3
+  end
+  add_message "BlockBody" do
+    repeated :transactions, :message, 1, "SignedTransaction"
+  end
+  add_message "Block" do
+    optional :version, :uint32, 1
+    optional :header, :message, 2, "BlockHeader"
+    optional :body, :message, 3, "BlockBody"
+  end
+  add_message "BlockWithProof" do
+    optional :blk, :message, 1, "Block"
+    optional :proof, :message, 2, "Proof"
+  end
+  add_message "BlockTxs" do
+    optional :height, :uint64, 1
+    optional :body, :message, 3, "BlockBody"
+  end
+  add_message "BlackList" do
+    repeated :black_list, :bytes, 1
+    repeated :clear_list, :bytes, 2
+  end
+  add_message "StateSignal" do
+    optional :height, :uint64, 1
+  end
+  add_enum "ProofType" do
+    value :AuthorityRound, 0
+    value :Raft, 1
+    value :Bft, 2
+  end
+  add_enum "Crypto" do
+    value :SECP, 0
+    value :SM2, 1
+  end
+end
+
+module CITA::Protos
+  Proof = Google::Protobuf::DescriptorPool.generated_pool.lookup("Proof").msgclass
+  BlockHeader = Google::Protobuf::DescriptorPool.generated_pool.lookup("BlockHeader").msgclass
+  Status = Google::Protobuf::DescriptorPool.generated_pool.lookup("Status").msgclass
+  AccountGasLimit = Google::Protobuf::DescriptorPool.generated_pool.lookup("AccountGasLimit").msgclass
+  RichStatus = Google::Protobuf::DescriptorPool.generated_pool.lookup("RichStatus").msgclass
+  Transaction = Google::Protobuf::DescriptorPool.generated_pool.lookup("Transaction").msgclass
+  UnverifiedTransaction = Google::Protobuf::DescriptorPool.generated_pool.lookup("UnverifiedTransaction").msgclass
+  SignedTransaction = Google::Protobuf::DescriptorPool.generated_pool.lookup("SignedTransaction").msgclass
+  BlockBody = Google::Protobuf::DescriptorPool.generated_pool.lookup("BlockBody").msgclass
+  Block = Google::Protobuf::DescriptorPool.generated_pool.lookup("Block").msgclass
+  BlockWithProof = Google::Protobuf::DescriptorPool.generated_pool.lookup("BlockWithProof").msgclass
+  BlockTxs = Google::Protobuf::DescriptorPool.generated_pool.lookup("BlockTxs").msgclass
+  BlackList = Google::Protobuf::DescriptorPool.generated_pool.lookup("BlackList").msgclass
+  StateSignal = Google::Protobuf::DescriptorPool.generated_pool.lookup("StateSignal").msgclass
+  ProofType = Google::Protobuf::DescriptorPool.generated_pool.lookup("ProofType").enummodule
+  Crypto = Google::Protobuf::DescriptorPool.generated_pool.lookup("Crypto").enummodule
+end

data/lib/cita/rpc.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+require "active_support/inflector"
+
+module CITA
+  class RPC
+    attr_reader :url, :http
+
+    # CITA v0.18 RPC list
+    METHOD_NAMES = %w(
+      peerCount
+      blockNumber
+      sendRawTransaction
+      getBlockByHash
+      getBlockByNumber
+      getTransaction
+      getTransactionReceipt
+      getLogs
+      call
+      getTransactionCount
+      getCode
+      getAbi
+      getBalance
+      newFilter
+      newBlockFilter
+      uninstallFilter
+      getFilterChanges
+      getFilterLogs
+      getTransactionProof
+      getMetaData
+      getBlockHeader
+      getStateProof
+    ).freeze
+
+    def initialize(url)
+      @url = url
+      @http = Http.new(@url)
+    end
+
+    # generate rpc methods
+    METHOD_NAMES.each do |name|
+      define_method name do |*params|
+        call_rpc(name, params: params)
+      end
+
+      define_method name.underscore do |*params|
+        send(name, *params)
+      end
+    end
+
+    # @return [Hash] response body
+    def call_rpc(method, jsonrpc: Http::DEFAULT_JSONRPC, params: Http::DEFAULT_PARAMS, id: Http::DEFAULT_ID)
+      resp = http.call_rpc(method, params: params, jsonrpc: jsonrpc, id: id)
+      JSON.parse(resp.body)
+    end
+
+    # @param transaction [CITA::Transaction]
+    # @return [Hash]
+    def send_transaction(transaction, private_key)
+      content = TransactionSigner.encode(transaction, private_key)
+      send_raw_transaction(content)
+    end
+
+    # easy to transfer tokens
+    #
+    # @param to [String] to address
+    # @param private_key [String]
+    # @param value [String | Integer] hex string or decimal integer
+    # @param quota [Integer] default to 30_000
+    #
+    # @return [Hash]
+    def transfer(to:, private_key:, value:, quota: 30_000)
+      valid_until_block = block_number["result"].hex + 88
+      meta_data = get_meta_data("latest")["result"]
+      version = meta_data["version"]
+      chain_id = if version.zero?
+                   meta_data["chainId"]
+                 elsif version == 1
+                   meta_data["chainIdV1"]
+                 end
+      transaction = Transaction.new(nonce: Utils.nonce, valid_until_block: valid_until_block, chain_id: chain_id, to: to, value: value, quota: quota, version: version)
+      send_transaction(transaction, private_key)
+    end
+  end
+end

data/lib/cita/transaction.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require "active_support/core_ext/string"
+
+module CITA
+  class Transaction
+    class VersionError < StandardError
+    end
+
+    attr_accessor :to, :nonce, :quota, :valid_until_block, :data, :value, :chain_id, :version
+
+    # @param nonce [String] default is SecureRandom.hex; if you provide with nil or empty string, it will be assigned a random string.
+    # @param valid_until_block [Integer]
+    # @param chain_id [Integer | String] hex string if version == 1
+    # @param version [Integer]
+    # @param to [String]
+    # @param data [String]
+    # @param value: [String | Integer] hex string or decimal integer
+    # @param quota [Integer]
+    #
+    # @return [void]
+    def initialize(valid_until_block:, chain_id:, nonce: nil, version: 1, to: nil, data: nil, value: "0", quota: 1_000_000) # rubocop:disable Metrics/ParameterLists
+      raise VersionError, "transaction version error, expected 0 or 1, got #{version}" unless [0, 1].include?(version)
+
+      @to = to
+      @nonce = nonce.blank? ? SecureRandom.hex : nonce
+      @quota = quota
+      @valid_until_block = valid_until_block
+      @data = data
+      @chain_id = if chain_id.is_a?(String)
+                    chain_id.delete("-")
+                  else
+                    chain_id
+                  end
+      @version = version
+      @value = if value.is_a?(Integer)
+                 Utils.to_hex(value)
+               else
+                 value
+               end
+    end
+
+    def self.from_hash(hash)
+      h = hash.map { |k, v| { k.to_sym => v } }.reduce({}, :merge)
+
+      new(
+        nonce: h[:nonce],
+        valid_until_block: h[:valid_until_block],
+        chain_id: h[:chain_id],
+        to: h[:to],
+        data: h[:data],
+        version: h[:version] || 1,
+        value: h[:value] || "0",
+        quota: h[:quota] || 1_000_000
+      )
+    end
+  end
+end

data/lib/cita/transaction_signer.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "ciri/utils"
+require "ciri/crypto"
+
+module CITA
+  class TransactionSigner
+    class << self
+      # sign transaction
+      #
+      # @param transaction [CITA::Transaction]
+      # @param private_key [String]
+      def encode(transaction, private_key)
+        tx = CITA::Protos::Transaction.new
+
+        to = CITA::Utils.remove_hex_prefix(transaction.to)&.downcase
+
+        tx.nonce = transaction.nonce
+        tx.quota = transaction.quota
+        tx.data = CITA::Utils.to_bytes(transaction.data)
+        tx.value = hex_to_bytes(transaction.value)
+        tx.version = transaction.version
+        tx.valid_until_block = transaction.valid_until_block
+
+        if transaction.version.zero?
+          tx.to = to unless to.nil?
+          tx.chain_id = transaction.chain_id
+        elsif transaction.version == 1
+          tx.to_v1 = Utils.to_bytes(to) unless to.nil?
+          tx.chain_id_v1 = hex_to_bytes(transaction.chain_id)
+        end
+
+        encoded_tx = Protos::Transaction.encode(tx)
+
+        private_key_bytes = CITA::Utils.to_bytes(private_key)
+
+        protobuf_hash = Utils.keccak256(encoded_tx)
+
+        signature = Ciri::Crypto.ecdsa_signature(private_key_bytes, protobuf_hash).signature
+
+        unverified_tx = Protos::UnverifiedTransaction.new(transaction: tx, signature: signature)
+
+        encoded_unverified_tx = Protos::UnverifiedTransaction.encode(unverified_tx)
+
+        CITA::Utils.from_bytes(encoded_unverified_tx)
+      end
+
+      # unsign transaction
+      #
+      # @param tx_content [String] hex string
+      def simple_decode(tx_content)
+        content_bytes = CITA::Utils.to_bytes(tx_content)
+        unverified_transaction = Protos::UnverifiedTransaction.decode(content_bytes)
+
+        signature = unverified_transaction["signature"]
+
+        transaction = unverified_transaction["transaction"]
+        msg = Protos::Transaction.encode(transaction)
+        msg_hash = CITA::Utils.keccak256(msg)
+        pubkey = Ciri::Crypto.ecdsa_recover(msg_hash, signature)
+        pubkey_hex = Utils.from_bytes(pubkey[1..-1])
+
+        from_address = Utils.keccak256(pubkey[1..-1])[-20..-1]
+        from_address_hex = Utils.from_bytes(from_address)
+
+        sender = {
+          address: from_address_hex,
+          public_key: pubkey_hex
+        }
+
+        {
+          unverified_transaction: unverified_transaction.to_h,
+          sender: sender
+        }
+      end
+
+      # decode and support forks
+      #
+      # @param tx_content [String] hex string
+      # @return [Hash]
+      def original_decode(tx_content)
+        data = simple_decode(tx_content)
+        utx = data[:unverified_transaction]
+        tx = utx[:transaction]
+        version = tx[:version]
+
+        if version == 0 # rubocop:disable Style/NumericPredicate
+          tx.delete(:to_v1)
+          tx.delete(:chain_id_v1)
+        elsif version == 1
+          tx[:to] = tx.delete(:to_v1)
+          tx[:chain_id] = tx.delete(:chain_id_v1)
+        else
+          raise Transaction::VersionError, "transaction version error, expected 0 or 1, got #{version}"
+        end
+
+        data
+      end
+
+      # decode and parse bytes to hex string
+      #
+      # @param tx_content [String] hex string
+      # @return [Hash]
+      def decode(tx_content)
+        data = original_decode(tx_content)
+        utx = data[:unverified_transaction]
+        tx = utx[:transaction]
+        version = tx[:version]
+
+        tx[:value] = Utils.from_bytes(tx[:value])
+        tx[:data] = Utils.from_bytes(tx[:data])
+        tx[:nonce] = Utils.add_prefix_for_not_blank(tx[:nonce])
+        utx[:signature] = Utils.from_bytes(utx[:signature])
+
+        if version == 0 # rubocop:disable Style/NumericPredicate
+          tx.delete(:to_v1)
+          tx.delete(:chain_id_v1)
+          tx[:to] = Utils.add_prefix_for_not_blank(tx[:to])
+        elsif version == 1
+          tx[:to] = Utils.from_bytes(tx[:to])
+          tx[:chain_id] = Utils.from_bytes(tx[:chain_id])
+        end
+
+        data
+      end
+
+      private
+
+      # @param value [String] hex string with or without `0x` prefix
+      # @param length [Integer] length, default is 64
+      # @return [String] byte code string
+      def hex_to_bytes(value, length = 64)
+        CITA::Utils.to_bytes(CITA::Utils.remove_hex_prefix(value).rjust(length, "0"))
+      end
+    end
+  end
+end

data/lib/cita/utils.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module CITA
+  class Utils
+    HEX_PREFIX = "0x"
+
+    class << self
+      # add `0x` prefix to hex string
+      #
+      # @param hex [String]
+      def add_hex_prefix(hex)
+        return if hex.nil?
+        return hex if hex.start_with?(HEX_PREFIX)
+
+        HEX_PREFIX + hex
+      end
+
+      # add `0x` prefix to not blank hex string
+      #
+      # @param hex [String]
+      def add_prefix_for_not_blank(hex)
+        return add_hex_prefix(hex) unless hex.blank?
+
+        hex
+      end
+
+      # remove `0x` prefix from hex string
+      #
+      # @param hex [String]
+      def remove_hex_prefix(hex)
+        return if hex.nil?
+        return hex.gsub(HEX_PREFIX, "") if hex.start_with?(HEX_PREFIX)
+
+        hex
+      end
+
+      # convert decimal value to hex string without `0x` prefix
+      #
+      # @param decimal [Integer]
+      # @return [String]
+      def to_hex(decimal)
+        add_hex_prefix decimal.to_s(16)
+      end
+
+      # convert hex string to decimal value
+      #
+      # @param hex [String]
+      # @return [Integer]
+      def to_decimal(hex)
+        hex.hex
+      end
+
+      # to byte code value
+      # remove `0x` prefix first
+      #
+      # @param str [String] normal string
+      # @return [String] byte code string
+      def to_bytes(str)
+        [CITA::Utils.remove_hex_prefix(str)].pack("H*")
+      end
+
+      # byte code to string value, with `0x` prefix
+      #
+      # @param bytes_str [String] byte code string
+      # @return [String] normal string
+      def from_bytes(bytes_str)
+        hex = bytes_str.unpack1("H*")
+        return CITA::Utils.add_hex_prefix(hex) unless hex.blank?
+
+        hex
+      end
+
+      # keccak 256 hash
+      #
+      def keccak256(*data)
+        Ciri::Utils.keccak(*data)
+      end
+
+      # get nonce
+      #
+      # @return [String]
+      def nonce
+        SecureRandom.hex
+      end
+    end
+  end
+end

data/lib/cita/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CITA
+  VERSION = "0.20.0"
+end

data/lib/cita.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "cita/version"
+
+module CITA
+  # Your code goes here...
+  require "cita/protos/blockchain_pb"
+
+  require "web3_eth/contract"
+
+  require "cita/address"
+  require "cita/transaction"
+  require "cita/transaction_signer"
+  require "cita/utils"
+  require "cita/http"
+  require "cita/rpc"
+  require "cita/client"
+  require "cita/contract"
+end

data/lib/web3_eth/contract.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "web3/eth"
+
+module Web3
+  module Eth
+    class Contract
+      class ContractInstance
+        def function_data(method_name, *args)
+          @contract.function_data(method_name.to_s, args)
+        end
+      end
+
+      class ContractMethod
+        def function_data(args)
+          ["0x" + signature_hash + encode_hex(encode_abi(input_types, args)), output_types]
+        end
+      end
+
+      def function_data(method_name, args)
+        function = functions[method_name]
+        raise "No method found in ABI: #{method_name}" unless function
+
+        function.function_data args
+      end
+    end
+  end
+end