appchain.rb 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/appchain.gemspec

@@ -0,0 +1,47 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "appchain/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "appchain.rb"
+  spec.version       = AppChain::VERSION
+  spec.authors       = ["classicalliu"]
+  spec.email         = ["classicalliu@gmail.com"]
+
+  spec.summary       = %q{Ruby Nervos AppChain SDK}
+  spec.description   = %q{Ruby Nervos AppChain SDK for signature and rpc call}
+  spec.homepage      = "https://github.com/cryptape/appchain.rb"
+  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["allowed_push_host"] = "https://rubygems.org"
+  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 "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.11"
+  spec.add_development_dependency "awesome_print", "~> 1.8"
+  spec.add_development_dependency "rubocop", "~> 0.59"
+
+  spec.add_dependency "google-protobuf", "~> 3.6"
+  spec.add_dependency "ciri-crypto", "0.1.1"
+  spec.add_dependency "faraday", "~> 0.15.3"
+  spec.add_dependency "activesupport", "~> 5.2.1"
+  spec.add_dependency "web3-eth", "~> 0.2.16"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "appchain"
+
+# 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/appchain.rb

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

data/lib/appchain/address.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module AppChain
+  class Address
+    # @param str [String]
+    def initialize(str)
+      @addr = Utils.remove_hex_prefix(str)
+    end
+
+    # get address with `0x` prefix
+    #
+    # @return [String] address hex string with `0x` prefix
+    def addr
+      Utils.add_hex_prefix(@addr)
+    end
+
+    # compare address is equal
+    #
+    # @param other [AppChain::Address]
+    def ==(other)
+      addr.casecmp(other.addr)
+    end
+
+    # TODO: valid? method that check address is valid?
+  end
+end

data/lib/appchain/client.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AppChain
+  class Client
+    attr_reader :url, :rpc, :http, :contract
+
+    def initialize(url)
+      @url = url
+      @rpc = RPC.new(url)
+      @http = rpc.http
+    end
+
+    def contract_at(abi, address)
+      @contract = Contract.new(abi, url, address, rpc)
+    end
+  end
+end

data/lib/appchain/contract.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "web3/eth"
+
+module AppChain
+  class Contract
+    include Web3::Eth::Abi::AbiCoder
+
+    attr_reader :url, :abi, :address, :rpc
+
+    # @param abi [String | Hash] json string or hash
+    # @param url [String] chain url
+    # @param address [String] contract address
+    # @param rpc [AppChain::RPC]
+    #
+    # @return [void]
+    def initialize(abi, url, address = nil, rpc = nil)
+      @url = url
+      @abi = abi
+      @address = address
+      @rpc = rpc
+      parse_url
+    end
+
+    # wrapper Web3::Eth abi encoder for encoded data
+    #
+    # @param method_name [Symbol | String] method name you call
+    # @param *params [Array] method params you call
+    #
+    # @return [String] hex data
+    def function_data(method_name, *params)
+      data, _output_types = function_data_with_ot(method_name, *params)
+      data
+    end
+
+    # call contract functions by rpc `call` method
+    #
+    # @param method [Symbol | String] the method name you call
+    # @param params [Array] the method params you call
+    # @param tx [Hash] see rpc `call` doc for more info
+    #
+    # @return [any]
+    def call_func(method:, params: [], tx: {})
+      data, output_types = function_data_with_ot(method, *params)
+      resp = @rpc.call_rpc(:call, params: [tx.merge(data: data, to: address), "latest"])
+      result = resp["result"]
+
+      data = [Utils.remove_hex_prefix(result)].pack("H*")
+      return if data.nil?
+
+      re = decode_abi output_types, data
+      re.length == 1 ? re.first : re
+    end
+
+    # call contract functions by sendRawTransaction
+    #
+    # @param tx [Hash | AppChain::Transaction]
+    # @param private_key [String] hex string
+    # @param method [Symbol | String] method name you call
+    # @param *params [Array] your params
+    #
+    # @return [nil | Hash] {hash: "", status: ""}, sendRawTransactionResult
+    def send_func(tx:, private_key:, method:, params: [])
+      data, _output_types = function_data_with_ot(method, *params)
+      transaction = if tx.is_a?(Hash)
+                      Transaction.from_hash(tx)
+                    else
+                      tx
+                    end
+      transaction.data = data
+      resp = @rpc.send_transaction(transaction, private_key)
+
+      resp&.dig("result")
+    end
+
+    private
+
+    # parse url to host, port and scheme
+    def parse_url
+      uri = URI.parse(@url)
+      @host = uri.host
+      @port = uri.port
+      @scheme = uri.scheme
+    end
+
+    # is this url in https?
+    def https?
+      @scheme == "https"
+    end
+
+    # wrapper Web3::Eth abi encoder for encoded data
+    def function_data_with_ot(method_name, *params)
+      web3 = Web3::Eth::Rpc.new host: @host, port: @port, connect_options: { use_ssl: https? }
+      contract = web3.eth.contract(abi).at(address)
+      contract.function_data(method_name, *params)
+    end
+  end
+end

data/lib/appchain/http.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require "json"
+require "faraday"
+
+module AppChain
+  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 AppChain 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/appchain/protos/blockchain_pb.rb

@@ -0,0 +1,110 @@
+# 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 :gas_used, :uint64, 7
+    optional :gas_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_gas_limit, :uint64, 1
+    map :specific_gas_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
+  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
+  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 AppChain::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/appchain/rpc.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require "active_support/inflector"
+
+module AppChain
+  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 [AppChain::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
+      chain_id = get_meta_data("latest").dig "result", "chainId"
+      transaction = Transaction.new(nonce: Utils.nonce, valid_until_block: valid_until_block, chain_id: chain_id, to: to, value: value, quota: quota)
+      send_transaction(transaction, private_key)
+    end
+  end
+end