xgt-ruby 0.1.0

data/examples/operations/do_later/claim_reward_balance2.rb

@@ -0,0 +1,37 @@
+require 'xgt/ruby'
+
+def claim_reward_balance2  
+rpc = Xgt::Ruby::Rpc.new('http://localhost:8751')
+  wif = '5JNHfZYKGaomSFvd4NUdQ9qMcEAC43kujbfjueTHpVapX1Kzq2n'
+  config = rpc.call('database_api.get_config', {})
+  address_prefix = config['XGT_ADDRESS_PREFIX']
+  chain_id = config["XGT_CHAIN_ID"]
+
+  txn = {
+    "extensions": [],
+    "operations": [
+      [
+        "claim_reward_balance2",
+          {
+            "account": "XGT0000000000000",
+            "reward_tokens": [
+              {
+                "amount": "1",
+                "precision": 0,
+                "nai": "@@904705667"
+              }
+            ],
+            "extensions": []
+          }
+      ]
+    ]
+  }
+  
+  signed = Xgt::Ruby::Auth.sign_transaction(rpc, txn, [wif], chain_id)
+  puts JSON.pretty_generate(signed)
+  puts "\n\n"
+  response = rpc.call('network_broadcast_api.broadcast_transaction_synchronous', [signed])
+  puts JSON.pretty_generate(response)
+end
+
+claim_reward_balance2

data/examples/operations/in_progress/create_proposal.rb

@@ -0,0 +1,40 @@
+require 'xgt/ruby'
+
+def create_proposal  
+rpc = Xgt::Ruby::Rpc.new('http://localhost:8751')
+  wif = ENV["WIF"] || '5JNHfZYKGaomSFvd4NUdQ9qMcEAC43kujbfjueTHpVapX1Kzq2n'
+  receiver = ENV["RECEIVER"] || 'XGT0000000000001'
+  config = rpc.call('database_api.get_config', {})
+  address_prefix = config['XGT_ADDRESS_PREFIX']
+  chain_id = config["XGT_CHAIN_ID"]
+  current_time = Time.now
+
+  txn = {
+    "extensions": [],
+    "operations": [
+      [
+        "create_proposal",
+          {
+            "creator": "XGT0000000000000",
+            "receiver": receiver,
+            "start_date": "2020-05-24T09:00:00",
+            "end_date": "2020-05-25T09:00:00",
+            "daily_pay": "3000.000 SBD",
+            "amount": 8000,
+            "precision": 3,
+            "nai": "@@000000013",
+            "subject": "subject",
+            "permlink": "http://test.host"
+          }
+      ]
+    ]
+  }
+  
+  signed = Xgt::Ruby::Auth.sign_transaction(rpc, txn, [wif], chain_id)
+  puts JSON.pretty_generate(signed)
+  puts "\n\n"
+  response = rpc.call('network_broadcast_api.broadcast_transaction_synchronous', [signed])
+  puts JSON.pretty_generate(response)
+end
+
+create_proposal

data/examples/operations/in_progress/escrow_approve.rb

@@ -0,0 +1,36 @@
+require 'xgt/ruby'
+
+def escrow_approve  
+  rpc = Xgt::Ruby::Rpc.new('http://localhost:8751')
+  wif = '5JANXuPvF1DuhEpf2AKCDhMgaY7ZhYj6qM6HtKUfvnLkuZ6JwGZ'
+  wif2 = '5JdgpjVNcAQQhTjhvZgypEQsZqS7nLfPTyURWUgJXze8k65SKiJ'
+  wif3 = '5JWufsfFUfKQKwhsYy26oiVifMpyTy3bCkzuL7bcgYpNrCW731s'
+  config = rpc.call('database_api.get_config', {})
+  address_prefix = config['XGT_ADDRESS_PREFIX']
+  chain_id = config["XGT_CHAIN_ID"]
+
+  txn = {
+    "extensions": [],
+    "operations": [
+      [
+        "escrow_approve",
+          {
+            "from": "XGT0000000000000",
+            "to": "XGT32apWJQf7pVbm",
+            "agent": "XGT25svCHdyiRN1C",
+            "who": "XGT32apWJQf7pVbm",
+            "escrow_id": 59102208,
+            "approve": true
+          }
+      ]
+    ]
+  }
+  
+  signed = Xgt::Ruby::Auth.sign_transaction(rpc, txn, [wif3], chain_id)
+  puts JSON.pretty_generate(signed)
+  puts "\n\n"
+  response = rpc.call('network_broadcast_api.broadcast_transaction_synchronous', [signed])
+  puts JSON.pretty_generate(response)
+end
+
+escrow_approve

data/examples/operations/in_progress/witness_set_properties.rb

@@ -0,0 +1,62 @@
+require 'pathname'
+require 'erb'
+require 'pp'
+require 'benchmark'
+require 'yaml'
+require 'bigdecimal'
+require 'uri'
+require 'openssl'
+$LOAD_PATH.unshift(%(#{File.dirname(__FILE__)}/../xgt-ruby/lib))
+require'xgt/ruby'
+
+def msg(message)
+  puts "\e[36m#{message}\e[0m"
+end
+
+def witness_set_properties
+  rpc = Xgt::Ruby::Rpc.new("http://localhost:8751")
+  recovery_wif = '5JkEZbn8i8BDRpzTAt38Cj9jhAytkcsPuxbFB6R8kd2L7sGWcbE'
+  config = rpc.call('database_api.get_config', {})
+  witness_schedule = rpc.call('database_api.get_witness_schedule', {}) || {}
+  chain_properties = witness_schedule['median_props']
+  address_prefix = config['XGT_ADDRESS_PREFIX']
+  chain_id = config['XGT_CHAIN_ID']
+  signing_private = Xgt::Ruby::Auth.random_wif
+  signing_public = Xgt::Ruby::Auth.wif_to_public_key(signing_private, address_prefix)
+  amount = (chain_properties['account_creation_fee'] || {})['amount'].to_f * 0.001
+  currency_symbol = config['XGT_SYMBOL_STR']
+  fee = "#{'%0.3f' % amount} #{currency_symbol}"
+  components = fee.split(' ')
+  decimal = BigDecimal(components.first) * 1
+  final_fee = decimal.truncate.to_s + '.' + sprintf('%03d', (decimal.frac * 1000).truncate) + ' ' + components.last
+
+  txn = {
+    "operations": [[
+      "witness_set_properties",
+      {
+        "owner": "XGT0000000000000",
+        "maximum_block_size": 65536,
+        "props": [
+          "new_signing_key": "5JANXuPvF1DuhEpf2AKCDhMgaY7ZhYj6qM6HtKUfvnLkuZ6JwGZ",
+        ]
+      }
+    ]]
+  }
+
+  signed = Xgt::Ruby::Auth.sign_transaction(rpc, txn, [recovery_wif], chain_id)
+  puts JSON.pretty_generate(signed)
+  puts "\n\n"
+
+  msg %(Registering witness "XGT272up7iTGKArE" with recovery private WIF "#{recovery_wif}"...)
+  msg %(Signing keypair is #{signing_private} (private) and #{signing_public} (public)...)
+  response = rpc.call('network_broadcast_api.broadcast_transaction_synchronous', [signed])
+  puts "\n\n"
+  puts JSON.pretty_generate(response)
+
+  {
+    signing_private: signing_private,
+    signing_public: signing_public
+  }
+end
+
+witness_set_properties

data/lib/xgt/ruby.rb

@@ -0,0 +1,200 @@
+require 'securerandom'
+require 'faraday'
+require 'faraday_middleware'
+require 'bitcoin'
+require 'base58'
+require 'time'
+require 'xgt/ruby/version'
+
+module Xgt
+  module Ruby
+    class Error < StandardError; end
+    class RpcError < Error
+      attr_reader :response
+      def initialize(msg, response)
+        super(msg)
+        @response = response
+      end
+    end
+
+    class Rpc
+      def initialize(url, client: nil)
+        @url = url
+        @client = client || Faraday::Connection.new(url: @url) do |faraday|
+          faraday.request(:json)
+          faraday.request :retry,
+            max: 10,
+            interval: 0.05,
+            interval_randomness: 0.5,
+            backoff_factor: 2,
+            # TODO: Make this more specific
+            exceptions: ['Error']
+          faraday.response(:json)
+          faraday.response(:logger) if ENV['LOGGING_ENABLED']
+          faraday.adapter(Faraday.default_adapter)
+        end
+      end
+
+      def call(mthd, params)
+        id = SecureRandom.hex(6).to_i(16)
+        payload = {
+          'jsonrpc' => '2.0',
+          'method' => mthd,
+          'id' => id
+        }
+        payload['params'] = params unless params.nil?
+
+        response = @client.post('/', payload)
+
+        # TODO: Verify status code
+        unless response.body
+          raise RpcError.new(%(No response body!\n#{response.inspect}), response)
+        end
+
+        if response.body['error']
+          raise RpcError.new(%(Endpoint returned an error response!\n#{JSON.pretty_generate(response.body['error'])}), response)
+        end
+
+        unless response.body['result']
+          raise RpcError.new(%(No result in response body!\n#{response.inspect}), response)
+        end
+
+        # TODO: XXX: Breaking change!
+        response.body['result']
+      end
+
+      def broadcast_transaction(txn, wifs, chain_id)
+        signed = Xgt::Ruby::Auth.sign_transaction(self, txn, wifs, chain_id)
+        response = self.call('transaction_api.broadcast_transaction', [signed])
+        response['id']
+      end
+
+      def transaction_ready?(id)
+        begin
+          self.call('wallet_history_api.get_transaction', { 'id' => id })
+          true
+        rescue Xgt::Ruby::RpcError => e
+          message = e&.response
+                     &.body
+                     &.fetch('error', nil)
+                     &.fetch('message', nil)
+          wait_regexps = Regexp.union(%r(transaction.*?>.*?trx_in_block))
+          raise e unless message.match(wait_regexps)
+          false
+        end
+      end
+    end
+
+    class Auth
+      def self.sign_transaction(rpc, txn, wifs, chain_id)
+        # Get the last irreversible block number
+        response = rpc.call('database_api.get_dynamic_global_properties', {})
+        chain_date = response['time'] + 'Z'
+        last_irreversible_block_num = response['last_irreversible_block_num']
+        ref_block_num = (last_irreversible_block_num - 1) & 0xffff
+        # Get ref block info to append to the transaction
+        response = rpc.call('block_api.get_block_header', { 'block_num' => last_irreversible_block_num })
+        header = response['header']
+        head_block_id = (header && header['previous']) ? header['previous'] : '0000000000000000000000000000000000000000'
+        ref_block_prefix = [head_block_id].pack('H*')[4...8].unpack('V').first
+        expiration = (Time.parse(chain_date) + 600).iso8601.gsub(/Z$/, '')
+        # Append ref block info to the transaction
+        txn['ref_block_num'] = ref_block_num
+        txn['ref_block_prefix'] = ref_block_prefix
+        txn['expiration'] = expiration
+        # Get a hex digest of the transactioon
+        response = rpc.call('transaction_api.get_transaction_hex', [txn])
+        transaction_hex = response[0..-3]
+        unhexed = unhexlify(chain_id + transaction_hex)
+        digest_hex = Digest::SHA256.hexdigest(unhexed)
+        private_keys = wifs.map { |wif| Bitcoin::Key.from_base58(wif) }
+        ec = Bitcoin::OpenSSL_EC
+        count = 0
+        sig = nil
+
+        # Calculate signatures and add them to the transaction
+        txn['signatures'] ||= []
+        private_keys.each do |private_key|
+          loop do
+            count += 1
+            # TODO: Periodically check that count doesn't spin out of control
+            public_key_hex = private_key.pub
+            digest = unhexlify(digest_hex)
+            sig = ec.sign_compact(digest, private_key.priv, public_key_hex, false)
+            next if public_key_hex != ec.recover_compact(digest, sig)
+            break if canonical?(sig)
+          end
+          txn['signatures'] << hexlify(sig)
+        end
+        txn
+      end
+
+      def self.random_wif()
+        private_key = unhexlify('80' + SecureRandom.hex(32))
+        checksum = Digest::SHA256.digest( Digest::SHA256.digest(private_key) ).byteslice(0, 4)
+        to_base_58(private_key + checksum)
+      end
+
+      def self.generate_wif(name, password, role)
+        brain_key = (name + role + password).strip.split(/[\t\n\v\f\r ]+/).join(' ')
+        key = "\x80".b + Digest::SHA256.digest(brain_key)
+        checksum = Digest::SHA256.digest(Digest::SHA256.digest(key))[0...4]
+        to_base_58(key + checksum)
+      end
+
+      def self.wif_to_public_key(wif, address_prefix)
+        private_wif = unhexlify(Bitcoin.decode_base58(wif))
+        version = private_wif[0]
+        checksum = private_wif[-4..-1]
+        # TODO: Verify version and checksum
+        private_key = private_wif[1...-4]
+        big_num = OpenSSL::BN.new(hexlify(private_key).to_i(16))
+        group = OpenSSL::PKey::EC::Group.new('secp256k1')
+        product = group.generator.mul(big_num).to_bn
+        public_key_buffer = OpenSSL::PKey::EC::Point.new(group, product).to_octet_string(:compressed)
+        checksum = Digest::RMD160.digest(public_key_buffer)
+        address_prefix + to_base_58(public_key_buffer + checksum[0...4])
+      end
+
+      def self.generate_wallet_name(*public_keys)
+        hashed = Digest::SHA256.hexdigest(public_keys.join(''))
+        base58 = Base58.binary_to_base58([hashed].pack('H*'), :bitcoin, true)
+        address_prefix = 'XGT'
+        "#{address_prefix}#{base58[0...40]}"
+      end
+
+      def self.to_base_58(bytes)
+        Bitcoin.encode_base58(hexlify(bytes))
+      end
+
+      def self.from_base_58(string)
+        unhexlify(Bitcoin.decode_base58(string))
+      end
+
+      def self.hexlify(s)
+        a = []
+        if s.respond_to?(:each_byte)
+          s.each_byte { |b| a << sprintf('%02X', b) }
+        else
+          s.each { |b| a << sprintf('%02X', b) }
+        end
+        a.join.downcase
+      end
+
+      def self.unhexlify(s)
+        s.split.pack('H*')
+      end
+
+      def self.canonical?(sig)
+        sig = sig.unpack('C*')
+
+        !(
+          ((sig[0] & 0x80 ) != 0) || ( sig[0] == 0 ) ||
+          ((sig[1] & 0x80 ) != 0) ||
+          ((sig[32] & 0x80 ) != 0) || ( sig[32] == 0 ) ||
+          ((sig[33] & 0x80 ) != 0)
+        )
+      end
+    end
+  end
+end

data/lib/xgt/ruby/version.rb

@@ -0,0 +1,5 @@
+module Xgt
+  module Ruby
+    VERSION = '0.1.0'
+  end
+end

data/payloads.txt

@@ -0,0 +1,461 @@
+{
+  "jsonrpc": "2.0",
+  "method": "database_api.find_accounts",
+  "params": {
+    "accounts": [
+      "foo45fb448c"
+    ]
+  },
+  "id": 18466466518669
+}
+{
+  "jsonrpc": "2.0",
+  "result": {
+    "accounts": [
+      {
+        "id": 13,
+        "name": "foo45fb448c",
+        "owner": {
+          "weight_threshold": 1,
+          "account_auths": [
+
+          ],
+          "key_auths": [
+            [
+              "TST7xue5ESY1xHhDZj6dw2igXCwoHobA3cnxffacvp4XMzwfzLZu4",
+              1
+            ]
+          ]
+        },
+        "active": {
+          "weight_threshold": 1,
+          "account_auths": [
+
+          ],
+          "key_auths": [
+            [
+              "TST6Yp3zeaYNU7XJF2MxoHhDcWT4vGgVkzTLEvhMY6g5tvmwzn3tN",
+              1
+            ]
+          ]
+        },
+        "posting": {
+          "weight_threshold": 1,
+          "account_auths": [
+
+          ],
+          "key_auths": [
+            [
+              "TST5Q7ZdopjQWZMwiyZk11W5Yhvsfu1PG3f4qsQN58A7XfHP34Hig",
+              1
+            ]
+          ]
+        },
+        "memo_key": "TST5u69JnHZ3oznnwn71J6VA4r5oVJX6Xu3dpbFVoHpJoZXnbDfaW",
+        "json_metadata": "",
+        "proxy": "",
+        "last_owner_update": "1970-01-01T00:00:00",
+        "last_account_update": "1970-01-01T00:00:00",
+        "created": "2019-04-24T06:44:48",
+        "mined": false,
+        "recovery_account": "initminer",
+        "last_account_recovery": "1970-01-01T00:00:00",
+        "reset_account": "null",
+        "comment_count": 0,
+        "lifetime_vote_count": 0,
+        "post_count": 0,
+        "can_vote": true,
+        "voting_manabar": {
+          "current_mana": 0,
+          "last_update_time": 1556088288
+        },
+        "balance": {
+          "amount": "0",
+          "precision": 3,
+          "nai": "@@000000021"
+        },
+        "savings_balance": {
+          "amount": "0",
+          "precision": 3,
+          "nai": "@@000000021"
+        },
+        "sbd_balance": {
+          "amount": "0",
+          "precision": 3,
+          "nai": "@@000000013"
+        },
+        "sbd_seconds": "0",
+        "sbd_seconds_last_update": "1970-01-01T00:00:00",
+        "sbd_last_interest_payment": "1970-01-01T00:00:00",
+        "savings_sbd_balance": {
+          "amount": "0",
+          "precision": 3,
+          "nai": "@@000000013"
+        },
+        "savings_sbd_seconds": "0",
+        "savings_sbd_seconds_last_update": "1970-01-01T00:00:00",
+        "savings_sbd_last_interest_payment": "1970-01-01T00:00:00",
+        "savings_withdraw_requests": 0,
+        "reward_sbd_balance": {
+          "amount": "0",
+          "precision": 3,
+          "nai": "@@000000013"
+        },
+        "reward_steem_balance": {
+          "amount": "0",
+          "precision": 3,
+          "nai": "@@000000021"
+        },
+        "reward_vesting_balance": {
+          "amount": "0",
+          "precision": 6,
+          "nai": "@@000000037"
+        },
+        "reward_vesting_steem": {
+          "amount": "0",
+          "precision": 3,
+          "nai": "@@000000021"
+        },
+        "vesting_shares": {
+          "amount": "0",
+          "precision": 6,
+          "nai": "@@000000037"
+        },
+        "delegated_vesting_shares": {
+          "amount": "0",
+          "precision": 6,
+          "nai": "@@000000037"
+        },
+        "received_vesting_shares": {
+          "amount": "0",
+          "precision": 6,
+          "nai": "@@000000037"
+        },
+        "vesting_withdraw_rate": {
+          "amount": "0",
+          "precision": 6,
+          "nai": "@@000000037"
+        },
+        "next_vesting_withdrawal": "1969-12-31T23:59:59",
+        "withdrawn": 0,
+        "to_withdraw": 0,
+        "withdraw_routes": 0,
+        "curation_rewards": 0,
+        "posting_rewards": 0,
+        "proxied_vsf_votes": [
+          0,
+          0,
+          0,
+          0
+        ],
+        "witnesses_voted_for": 0,
+        "last_post": "1970-01-01T00:00:00",
+        "last_root_post": "1970-01-01T00:00:00",
+        "last_vote_time": "1970-01-01T00:00:00",
+        "post_bandwidth": 0,
+        "pending_claimed_accounts": 0,
+        "is_smt": false
+      }
+    ]
+  },
+  "id": "7133625920894"
+}
+{
+  "jsonrpc": "2.0",
+  "method": "database_api.get_dynamic_global_properties",
+  "params": {
+  },
+  "id": 275146661212172
+}
+{
+  "jsonrpc": "2.0",
+  "id": 275146661212172,
+  "result": {
+    "time": "2019-04-30T00:34:12",
+    "last_irreversible_block_num": 32482872
+  }
+}
+{
+  "jsonrpc": "2.0",
+  "method": "block_api.get_block_header",
+  "params": {
+    "block_num": 32482872
+  },
+  "id": 249008441062077
+}
+{
+  "jsonrpc": "2.0",
+  "id": 249008441062077,
+  "result": {
+    "header": {
+      "previous": "01efa63783c4180b05e39fa94dde4febca9cc91d"
+    }
+  }
+}
+{
+  "jsonrpc": "2.0",
+  "method": "network_broadcast_api.get_transaction_hex",
+  "params": [
+    {
+      "extensions": [
+
+      ],
+      "operations": [
+        [
+          "account_create",
+          {
+            "fee": "0.000 TESTS",
+            "creator": "initminer",
+            "new_account_name": "foo41700a44",
+            "owner": {
+              "weight_threshold": 1,
+              "account_auths": [
+
+              ],
+              "key_auths": [
+                [
+                  "TST7xue5ESY1xHhDZj6dw2igXCwoHobA3cnxffacvp4XMzwfzLZu4",
+                  1
+                ]
+              ]
+            },
+            "active": {
+              "weight_threshold": 1,
+              "account_auths": [
+
+              ],
+              "key_auths": [
+                [
+                  "TST6Yp3zeaYNU7XJF2MxoHhDcWT4vGgVkzTLEvhMY6g5tvmwzn3tN",
+                  1
+                ]
+              ]
+            },
+            "posting": {
+              "weight_threshold": 1,
+              "account_auths": [
+
+              ],
+              "key_auths": [
+                [
+                  "TST5Q7ZdopjQWZMwiyZk11W5Yhvsfu1PG3f4qsQN58A7XfHP34Hig",
+                  1
+                ]
+              ]
+            },
+            "memo_key": "TST5u69JnHZ3oznnwn71J6VA4r5oVJX6Xu3dpbFVoHpJoZXnbDfaW",
+            "json_metadata": "",
+            "extensions": [
+
+            ]
+          }
+        ]
+      ],
+      "ref_block_num": 42551,
+      "ref_block_prefix": 186172547,
+      "expiration": "2019-04-30T00:44:12"
+    }
+  ],
+  "id": 116156454840173
+}
+{
+  "jsonrpc": "2.0",
+  "id": 116156454840173,
+  "result": "37a683c4180b5c9ac75c01090000000000000000035445535453000009696e69746d696e65720b666f6f343137303061343401000000000103951f1e294b4f9e535708bcfa85d8d21240bda7585424b2e6fa0d0f1e9a756e8c010001000000000102dab63701259352fa01048a97ac76d44def848552518c7991e4bb2feb893e6eef0100010000000001024343ff4fcd3a2ddfbb53fbd178b09ed02c457dbd88d1ff2f49ce967d7c3f5637010002850edf288f0e9fdc4bf83839d352d3b9e65bdefb309147ad3642b4a63e0a6c660000ff"
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 113281388192823
+}
+{
+  "jsonrpc": "2.0",
+  "error": {
+    "code": -32002,
+    "message": "Assert Exception:method_itr != api_itr->second.end(): Could not find method get_chain_properties",
+    "data": {
+      "code": 10,
+      "name": "assert_exception",
+      "message": "Assert Exception",
+      "stack": [
+        {
+          "context": {
+            "level": "error",
+            "file": "json_rpc_plugin.cpp",
+            "line": 209,
+            "method": "find_api_method",
+            "hostname": "",
+            "timestamp": "2020-04-01T19:44:15"
+          },
+          "format": "method_itr != api_itr->second.end(): Could not find method ${method}",
+          "data": {
+            "method": "get_chain_properties"
+          }
+        }
+      ]
+    }
+  },
+  "id": "113281388192823"
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 197736107532241
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 168893335992264
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 159203180196081
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 162443573580019
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 265628521302471
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 23335772442202
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 189541321007961
+}
+{
+  "jsonrpc": "2.0",
+  "error": {
+    "code": -32002,
+    "message": "Assert Exception:method_itr != api_itr->second.end(): Could not find method get_chain_properties",
+    "data": {
+      "code": 10,
+      "name": "assert_exception",
+      "message": "Assert Exception",
+      "stack": [
+        {
+          "context": {
+            "level": "error",
+            "file": "json_rpc_plugin.cpp",
+            "line": 209,
+            "method": "find_api_method",
+            "hostname": "",
+            "timestamp": "2020-04-03T22:18:41"
+          },
+          "format": "method_itr != api_itr->second.end(): Could not find method ${method}",
+          "data": {
+            "method": "get_chain_properties"
+          }
+        }
+      ]
+    }
+  },
+  "id": "189541321007961"
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 251458499472850
+}
+{
+  "jsonrpc": "2.0",
+  "error": {
+    "code": -32002,
+    "message": "Assert Exception:method_itr != api_itr->second.end(): Could not find method get_chain_properties",
+    "data": {
+      "code": 10,
+      "name": "assert_exception",
+      "message": "Assert Exception",
+      "stack": [
+        {
+          "context": {
+            "level": "error",
+            "file": "json_rpc_plugin.cpp",
+            "line": 209,
+            "method": "find_api_method",
+            "hostname": "",
+            "timestamp": "2020-04-03T22:50:20"
+          },
+          "format": "method_itr != api_itr->second.end(): Could not find method ${method}",
+          "data": {
+            "method": "get_chain_properties"
+          }
+        }
+      ]
+    }
+  },
+  "id": "251458499472850"
+}
+{
+  "jsonrpc": "2.0",
+  "method": "condenser_api.get_chain_properties",
+  "params": [
+
+  ],
+  "id": 66742030768951
+}
+{
+  "jsonrpc": "2.0",
+  "error": {
+    "code": -32002,
+    "message": "Assert Exception:method_itr != api_itr->second.end(): Could not find method get_chain_properties",
+    "data": {
+      "code": 10,
+      "name": "assert_exception",
+      "message": "Assert Exception",
+      "stack": [
+        {
+          "context": {
+            "level": "error",
+            "file": "json_rpc_plugin.cpp",
+            "line": 209,
+            "method": "find_api_method",
+            "hostname": "",
+            "timestamp": "2020-04-03T23:02:56"
+          },
+          "format": "method_itr != api_itr->second.end(): Could not find method ${method}",
+          "data": {
+            "method": "get_chain_properties"
+          }
+        }
+      ]
+    }
+  },
+  "id": "66742030768951"
+}