bitcoind – RPC errors raised by each command

Based on this question, is there a comprehensive list of the errors that any RPC command can return?

For example. Let's say I want to run getbestblockhash or getblockcount, I am not sure which errors are to be expected.

I do not think that such documentation exists. You would have to read the source code for a particular RPC. Because some functions of RPCs are shared and can return certain errors, it may not be easy to list all the errors.

Also, I'm not sure if there's a common error code that can be returned in many cases (RPC_MISC_ERROR for example).

If there is an error for which there is no separate capture and validation (ie, an exception is raised that the RPC does not capture), then RPC_MISC_ERROR Will be returned.

json rpc – How do I use the rpc listunspent command with bitcore-lib to create a transaction and get the transaction hash?

I'm trying to use the rpc command listunspent to get all the UTXOs that are relevant to an address, and then I try to pass them to a transaction with bitcore-lib.
Below is my code:

const Client = require('bitcoin-core');
const bitcore = require('bitcore-lib');
const client = new Client({ 
  network: 'regtest', 
  username: 'bitcoinuser', 
  password: 'bitcoinpass', 
  port: 18443 
});

var tx = new bitcore.Transaction();

var sourceAddress = ("mwkT2k1o6k4dF7ZZQ2VBbw7VedBkQA2CBK");
var minconf = 6;
var maxconf = 999999;
var targetAddress = "2Mw3iwZdVXjeb7BN5hWqegFs8VdfZo5Rmdo";
var privateKey = "cQqVxdtPz95monJe8QJUE4h5JVtSSAjTQ1SU6z8PL9pmFj5V7ieA";

var txns = ();
client.listUnspent(minconf, maxconf, sourceAddress)
    .then(function(help){
    txns = help.slice();
    return txns;
  }).then(function(txns){
    return tx.from(txns).to(targetAddress, 15000).sign(privateKey);
  }).then(function(result){
    console.log(result);
  });

The result is similar to the transaction object.

I want to receive the transaction hash, which I can then send.

Note: I'm trying to run my core in RTEST mode. I do not want to use Livenet or Testnet. I have also announced the public and private keys, as they have no real value.

The first lines of the output look like this:

Transaction {
  inputs:
   ( PublicKeyInput {
       witnesses: (),
       output:
        Output {
          _satoshisBN:
           BN { negative: 0, words: ( 16972032, 37 ), length: 2, red: null 
},
          _satoshis: 2500000000,
          _scriptBuffer:
           ,
          _script:
           Script {
             chunks:
              ( { buf:
                   ,
                  len: 33,
                  opcodenum: 33 },
                { opcodenum: 172 } ),
             _isOutput: true } },
       prevTxId:
        ,
       outputIndex: 0,
       sequenceNumber: 4294967295,
       _script: Script { chunks: (), _isInput: true },
       _scriptBuffer:  },
     PublicKeyInput {
       witnesses: (),
       output:
        Output {
          _satoshisBN:

Bitcoin Core – The RPC call "createpsbt" does not provide PSBT inputs and outputs

I'm trying to create a PSBT with RPC:

bitcoin-cli createpsbt (({"txid": "1d76879500aecafde541770b5d44ccec5955b4c1a455fae446bf1df7b5ea43e9", "vout": 0}, {"txid": "e5a8dfa9459ac154fe62652e1d43049dae13f11815da36cc32881e27917a0dff", "vout": 1}), ({"bcrt1qnv3tl3z9cll9faqf79ppfn3rrp7pn9wwmq04p5gqgqtxg55xfxuslkyk94": "0.20000000"}, {"bcrt1qa4h6amsgyc878k094grqh6ktmgvp97dt6et9cy5hjmyxlgd9q63q3p6hch": "1.79900000"}), 0, true)

This is the PSBT I receive in return:

cHNidP8BALICAAAAAulD6rX3Hb9G5PpVpMG0VVnszERdC3dB5f3KrgCVh3YdAAAAAAD9/////w16kSceiDLMNtoVGPETrp0EQx0uZWL+VMGaRanfqOUBAAAAAP3///8CAC0xAQAAAAAiACCbIr/ERcf+VPQJ8UIUziMYfBmVztgfUNEAQBZkUoZJuWAOuQoAAAAAIgAg7W+u7ggmD+PZ5aoGC+rL2hgS+avWVlwSl5bIb6GlBqIAAAAAAAAAAAA=

In the decryption is the inputs and outputs Sections of the PSBT are empty. Why is this? Bitcoin Core should know everything necessary to complete these sections. Why not?

bitcoin-cli -regtest decode 
{'inputs': ({}, {}),
 'outputs': ({}, {}),
 'tx': {'hash': 'fd88b50ec52948dcf04b0d802000b325f960f3333cff8bf7a274273c9d7e2ed7',
        'locktime': 0,
        'size': 178,
        'txid': 'fd88b50ec52948dcf04b0d802000b325f960f3333cff8bf7a274273c9d7e2ed7',
        'version': 2,
        'vin': ({'scriptSig': {'asm': '', 'hex': ''},
                 'sequence': 4294967293,
                 'txid': '1d76879500aecafde541770b5d44ccec5955b4c1a455fae446bf1df7b5ea43e9',
                 'vout': 0},
                {'scriptSig': {'asm': '', 'hex': ''},
                 'sequence': 4294967293,
                 'txid': 'e5a8dfa9459ac154fe62652e1d43049dae13f11815da36cc32881e27917a0dff',
                 'vout': 1}),
        'vout': ({'n': 0,
                  'scriptPubKey': {'addresses': ('bcrt1qnv3tl3z9cll9faqf79ppfn3rrp7pn9wwmq04p5gqgqtxg55xfxuslkyk94'),
                                   'asm': '0 '
                                          '9b22bfc445c7fe54f409f14214ce23187c1995ced81f50d100401664528649b9',
                                   'hex': '00209b22bfc445c7fe54f409f14214ce23187c1995ced81f50d100401664528649b9',
                                   'reqSigs': 1,
                                   'type': 'witness_v0_scripthash'},
                  'value': Decimal('0.20000000')},
                 {'n': 1,
                  'scriptPubKey': {'addresses': ('bcrt1qa4h6amsgyc878k094grqh6ktmgvp97dt6et9cy5hjmyxlgd9q63q3p6hch'),
                                   'asm': '0 '
                                          'ed6faeee08260fe3d9e5aa060beacbda1812f9abd6565c129796c86fa1a506a2',
                                   'hex': '0020ed6faeee08260fe3d9e5aa060beacbda1812f9abd6565c129796c86fa1a506a2',
                                   'reqSigs': 1,
                                   'type': 'witness_v0_scripthash'},
                  'value': Decimal('1.79900000')}),
        'vsize': 178,
        'weight': 712},
 'unknown': {}}

windows – Why does the RPC API call "uptime" fail when Bitcoin Core is running but not completely synced?

The node does not need to be fully synchronized for RPC to respond to queries.

What happens is that Bitcoin Core starts up in "warm-up" mode. During warm-up, RPC is not available because the system is being set up. This is when wallets, the network take place your local UTXO information, setting the block index and checking your local blocks. (I suspect you may have confused the message "Check blocks …" with sync.) In warm-up mode, RPC port 8333 is open, but returns a JSON error for each query. The open port signals incoming peers that there is a node there, but is not yet able to respond to requests.

After this warm-up routine is complete (takes a few minutes), the node is active and synchronizes over the network. During synchronization, the RPC server is up and running, even if it takes weeks. Obviously, it is not possible to respond to requests for blocks that have not yet been retrieved and verified.

Is this a known problem / mistake? Will it be fixed soon?

No mistake. This is part of how Bitcoin Core starts.

Should I use another API call to check if Bitcoin Core is running and "can talk to me"?

Try the help command. When it is returned, it means the RPC server is up and running.

Is there a separate API call that lets me know if Bitcoin Core is "ready to use" (fully synchronized)?

To attempt getrpcinfo,

bitcoind – Bitcoin JSON RPC does not work with Remote IP

I can not get it to work First, I could use Bitcoind in my VPS (local), but when I added Rpcbind and permission to my Bitcoin.conf, I can not even use Bitcoin-Cli. That gives me this error:
Error: Authorization failed: Wrong rpcuser or rpcpassword
I use exactly the user pass as in my config

curl gives me a blank answer to port "8333" and the connection to port 8332 was rejected

here is my bitcoin.conf (ip and user / pass removed)

(I used this before when it worked locally.)

listen=1
server=1
rpcport=8332
prune=600
maxconnections=12
maxuploadtarget=20
rpcuser=XXXXX
rpcpassword=XXXXX
daemon=1
keypool=10000

Now if I try to get it running on my remote server with this configuration

# Generated by https://jlopp.github.io/bitcoin-core-config-generator/

# This config should be placed in following path:
# ~/.bitcoin/bitcoin.conf
server=1
# (core)
# Maintain a full transaction index, used by the getrawtransaction rpc call.
# Run in the background as a daemon and accept commands.
daemon=1
# Reduce storage requirements by only storing most recent N MiB of block. This mode is incompatible with -txindex and -rescan. WARNING: Reverting this setting requires re-downloading the entire blockchain. (default: 0 = disable pruning blocks, 1 = allow manual pruning via RPC, greater than 550 = automatically prune blocks to stay under target size in MiB).
prune=600

# (rpc)
# Accept public REST requests.
rest=1
# Bind to given address to listen for JSON-RPC connections. This option is ignored unless -rpcallowip is also passed. Port is optional and overrides -rpcport. Use (host):port notation for IPv6. This option can be specified multiple times. (default: 127.0.0.1 and ::1 i.e., localhost, or if -rpcallowip has been specified, 0.0.0.0 and :: i.e., all addresses)
rpcbind=~MY REMOTE VPS PUBLIC IP~
# Username and hashed password for JSON-RPC connections. The field  comes in the format: :$. RPC clients connect using rpcuser=/rpcpassword= arguments. You can generate this value with the ./share/rpcauth/rpcauth.py script in the Bitcoin Core repository. This option can be specified multiple times.
rpcuser=XXXXXXX
rpcpassword=XXXXXXXX
# Allow JSON-RPC connections from specified source. Valid for  are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). This option can be specified multiple times.
rpcallowip=~MY HOST IP~
# Number of seconds after which an uncompleted RPC call will time out
rpcservertimeout=60

# (wallet)
# Legacy
addresstype=legacy
# Legacy
changetype=legacy
# Set key pool size to . Recommended to use a large number for high volume non-HD wallets.
keypool=10000
# If paytxfee is not set, include enough fee so that transactions should confirm within  blocks
txconfirmtarget=3
# Broadcast transactions created by the wallet.
walletbroadcast=0
# Run a thread to flush wallet periodically.
flushwallet=0


# (Sections)
# Most options automatically apply to mainnet, testnet, and regtest networks.
# If you want to confine an option to just one network, you should add it in the relevant section.
# EXCEPTIONS: The options addnode, connect, port, bind, rpcport, rpcbind and wallet
# only apply to mainnet unless they appear in the appropriate section below.

maxconnections=12
maxuploadtarget=20

# Options only for mainnet
(main)

# Options only for testnet
(test)

# Options only for regtest
(regtest)

json rpc – rpc API can not be called from another computer on the same local network

rpc api can not be called from another machine on the same local network

There is a test node on my local network that I can call rpc api Only from the node's machine, not from my local machine.

I know rpcallowip is changed in the current version https://bitcoin.org/en/release/v0.18.0#configuration-option-changes

http clinet httpie

IP of my local machine: 192.168.1.155

IP of the BTC node: 192.168.1.132

the harbor 8332 it is open.

$ bitcoind -version                 
# Bitcoin Core Daemon version v0.18.0.0-g2472733a24a9364e4c6233ccd04166a26a68cc65

I start testing and my IP is 192.168.1.155

bitcoind -regtest -deprecatedrpc=generate -printtoconsole -rpcuser=user -rpcpassword=password -rpcallowip=0.0.0.0/24 -rpcbind=127.0.0.1  -server -rpcport=8332

customer request

# request from btc node's machine
http POST http://user:password@127.0.0.1:8332 jsonrpc="2.0" method="getblockchaininfo" id=1
# successed

# request from my local machine 192.168.1.155
http POST http://user:password@192.168.1.132:8332 jsonrpc="2.0" method="getblockchaininfo" id=1
# http: error: ConnectionError: HTTPConnectionPool(host='192.168.1.132', port=8332): Max retries exceeded with url: / (Caused by NewConnectionError(': Failed to establish a new connection: (Errno 111) Connection refused',)) while doing POST request to URL: http://user:password@192.168.1.132:8332/

bitcoind – TimeoutError: [WinError 10060] If you try to connect to bitcoin rpc from a PC on the same local network

I have a laptop with Win10 installed. A full Bitcoin knot is now running perfectly. I am already able to use Python RPC requests from the laptop to get valid answers. The laptop is connected to the Internet via a LAN port on a router with wireless LAN option. The question now is: is it possible to issue Bitcoin RPC requests from another PC connected to the same router but over Wi-Fi? When I try, I get a timeout error that I can not recognize. I tried to insert a line into mine bitcoin.conf to possibly increase the timeout parameter like rpcclienttimeout=200 but it does not seem to work. The entire content of my configuration file looks like this:

server=1
daemon=1
txindex=1
rpcuser=***
rpcpassword=******
rpcallowip=192.168.1.0/24
rpcclienttimeout=200
#rpcallowip=127.0.0.1
#rpcconnect=127.0.0.1

Do I miss something? The IP of PC # 1 running the Bitcoin node is 192.168.1.104 and the IP of PC # 2, which is to get the access to the PC 192.168.1.102,

When I start the following Python code from PC 1, I get my alleged answers flawlessly. However, when I start the second Python script from PC 2, a timeout error occurs.

The code is executed by PC 1:

from time import time_ns as time
import csv
import numpy as np
import matplotlib.pyplot as plt
from rpcreq import *
import json
import os

def avg(L):
    return sum(L, 0.0) / len(L)

rpcPort     = "8332"
rpcHost     = "127.0.0.1"
rpcUser     = "******"
rpcPassword = "******"

serverURL = ("http://{user}:{password}@{host}:{port}").format(
        user=rpcUser,
        password=rpcPassword,
        host=rpcHost,
        port=rpcPort
    )

method = 'getblockcount'
params = ()
resp   = rpcreq(method, params, serverURL)
nBlock = resp('result')
iters  = nBlock
iters  = 100
print(nBlock)

BlockHash = (0)*(iters)
method1   = 'getblockhash'


start = time()
for pj in range(0, iters):
    params          = (pj)
    resp            = rpcreq(method1, params, serverURL)  
    BlockHash(pj)  = (resp('result'))
    print(pj)

end = time()
endtns = (end-start)/(iters+1)
endts = endtns / 1000000000
print('Each Reading Will Take: ', endts, 'Seconds.')
print('Reading All Block Hashes Will Take: ', endts*nBlock/3600, 'hours.')

x      = np.arange(0.0, iters, 1)
y      = BlockHash

x = (*x)
List = (
            ('Height')            + x,
            ('BlockHash')         + y,
        )

with open("BlockHashFirst{}.csv".format(iters), 'w', newline='') as rF:
    wr = csv.writer(rF, dialect='excel')
    for i in range(len(x)+1):
        wr.writerow((r(i) for r in List))

The code is executed by PC 2:

from time import time_ns as time
import csv
import numpy as np
import matplotlib.pyplot as plt
from rpcreq import *
import json
import os

def avg(L):
    return sum(L, 0.0) / len(L)

rpcPort     = "8332"
rpcHost     = "192.168.1.104"
rpcUser     = "******"
rpcPassword = "******"

serverURL = ("http://{user}:{password}@{host}:{port}").format(
        user=rpcUser,
        password=rpcPassword,
        host=rpcHost,
        port=rpcPort
    )

method = 'getblockcount'
params = ()
resp   = rpcreq(method, params, serverURL)
nBlock = resp('result')
iters  = nBlock
iters  = 100
print(nBlock)

BlockHash = (0)*(iters)
method1   = 'getblockhash'


start = time()
for pj in range(0, iters):
    params          = (pj)
    resp            = rpcreq(method1, params, serverURL)  
    BlockHash(pj)  = (resp('result'))
    print(pj)

end = time()
endtns = (end-start)/(iters+1)
endts = endtns / 1000000000
print('Each Reading Will Take: ', endts, 'Seconds.')
print('Reading All Block Hashes Will Take: ', endts*nBlock/3600, 'hours.')

x      = np.arange(0.0, iters, 1)
y      = BlockHash

x = (*x)
List = (
            ('Height')            + x,
            ('BlockHash')         + y,
        )

with open("BlockHashFirst{}.csv".format(iters), 'w', newline='') as rF:
    wr = csv.writer(rF, dialect='excel')
    for i in range(len(x)+1):
        wr.writerow((r(i) for r in List))

The second code is different only for the parameter rpcHost,
When I run the second code I get a complete error message as:

TimeoutError: (WinError 10060) A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond

Any tips where I confuse the concept?

bitcoin core – How do you derive the vout address for the P2PK transaction on Python RPC calls?

How is the Vout address derived for a P2PK transaction? I use the Python API that comes with the Bitcoin source code in the directory bitcoin/test/functional, I use regtest,

I wrote a unit test. It creates a transaction, writes the CTransaction object to the log file, then appends a CTxOut object to the vout array and re-writes the CTransaction object to the log. The second log entry shows that the element in the vout array contains an address field that contains a single value. 'muXtVbAXxTdAdaS9HQLnexRvsfgVteZcv8', How was this value derived?

Here is the relevant code snippet:

    addr1 = w0_rpc.getnewaddress()
    self.log.info(f"n    DEBUG addr1={addr1}")
    a1 = w0_rpc.getaddressinfo(addr1)
    pubkey1 = hex_str_to_bytes(a1('pubkey'))
    self.log.info(f"n    DEBUG pubkey1={pubkey1}")
    p2pk1 = CScript((pubkey1, OP_CHECKSIG))
    self.log.info(f"n    DEBUG bytes_to_hex_str(p2pk1)={bytes_to_hex_str(p2pk1)}")
    tx1 = CTransaction()
    tx1.vin.append(CTxIn(COutPoint(int(txid0, 16), v), b""))
    s = pprint.pformat(w0_rpc.decoderawtransaction(ToHex(tx1)))
    self.log.info(f"n    DEBUG tx={s}")
    tx1.vout.append(CTxOut(int(9 * COIN), p2pk1))
    s = pprint.pformat(w0_rpc.decoderawtransaction(ToHex(tx1)))
    self.log.info(f"n    DEBUG tx={s}")

Below is the log output of this code. You can see in the end that the Vout array contains an element that contains an array of addresses that contain a single value. 'muXtVbAXxTdAdaS9HQLnexRvsfgVteZcv8', I have not explicitly stated this value, at least not knowingly. It seems to me that the value was derived somewhere under the hood. Where did that happen? How was the value calculated?

    DEBUG addr1=2NGYQt1CxwSCdGbj8mpxMtLaTZtxHsmbqWM
2019-10-10T12:13:06.176000Z TestFramework (INFO): 
    DEBUG pubkey1=b'x02#x9cxabCVRLxc1xd1o8}x0ex85Z myQ-&x06xb2xc2xea xfaxf0(xd3ex98'
2019-10-10T12:13:06.176000Z TestFramework (INFO): 
    DEBUG bytes_to_hex_str(p2pk1)=2102239cab4356524cc1d16f387d0e855a206d79512d2606b2c2ea20faf028d36598ac
2019-10-10T12:13:06.177000Z TestFramework (INFO): 
    DEBUG tx={'hash': '0abb1fa572d89323429fc231fcede74af58f77469a3b383ee856db60ecee41a4',
 'locktime': 0,
 'size': 51,
 'txid': '0abb1fa572d89323429fc231fcede74af58f77469a3b383ee856db60ecee41a4',
 'version': 1,
 'vin': ({'scriptSig': {'asm': '', 'hex': ''},
          'sequence': 0,
          'txid': '9d177bb43b76dcbbf52fad079c4fd98986b32034d91ea12bcb4e67d32dc20f9b',
          'vout': 0}),
 'vout': (),
 'vsize': 51,
 'weight': 204}
2019-10-10T12:13:06.179000Z TestFramework (INFO): 
    DEBUG tx={'hash': 'd86153fc539e699289dc8f7f4e20d10f6378fa4f10dad131f5c8b2d4bc7e5c76',
 'locktime': 0,
 'size': 95,
 'txid': 'd86153fc539e699289dc8f7f4e20d10f6378fa4f10dad131f5c8b2d4bc7e5c76',
 'version': 1,
 'vin': ({'scriptSig': {'asm': '', 'hex': ''},
          'sequence': 0,
          'txid': '9d177bb43b76dcbbf52fad079c4fd98986b32034d91ea12bcb4e67d32dc20f9b',
          'vout': 0}),
 'vout': ({'n': 0,
           'scriptPubKey': {'addresses': ('muXtVbAXxTdAdaS9HQLnexRvsfgVteZcv8'),
                            'asm': '02239cab4356524cc1d16f387d0e855a206d79512d2606b2c2ea20faf028d36598 '
                                   'OP_CHECKSIG',
                            'hex': '2102239cab4356524cc1d16f387d0e855a206d79512d2606b2c2ea20faf028d36598ac',
                            'reqSigs': 1,
                            'type': 'pubkey'},
           'value': Decimal('9.00000000')}),
 'vsize': 95,
 'weight': 380}

json rpc – simulates electrum client

A similar question has already been asked here, but there is no answer yet.

To sync a number of addresses (to maintain balance), how do you simulate an Electrum client to connect to electrumx?

Unfortunately I'm not that familiar with Python and could not extract this code from the Electrum source code.

If someone can help or refer to such code written in any programming language, I would be very grateful

json rpc – No addresses returned from the RPC call to getnodeaddresses

The matter

I try to use that getnodeaddresses RPC call to return all addresses known to a node in a Docker network. I use the regtest Surroundings. The RPC call returns an empty array even though nodes were added using the key on the referenced node add RPC call.

Expected behavior

The getnodeaddresses The RPC call should return nodes that have been added through the add RPC call.

Actual behavior

No addresses are returned, d. H. An empty array is returned:

bitcoin-cli -regtest --datadir=/root/.bitcoin/ getnodeaddresses 5
(
)

reproduction

Set up a test network with 11 nodes. No mining was carried out, and the ~/.bitcoin Folder only contains bitcoin.conf with the following content:

(regtest)
regtest=1
server=1
rpcport=8332
port=8333

Connect to the reference node and execute the command:
bitcoin-cli -regtest --datadir=/root/.bitcoin/ addnode "$p:8333" add Where p is the address of the other node for each node that the reference node wants to add.

Execute the commands on the reference node:

bibitcoin-cli -regtest --datadir=/root/.bitcoin/ getconnectioncount
10

bibitcoin-cli -regtest --datadir=/root/.bitcoin/ getpeerinfo       

(
  {
    "id": 2,
    "addr": "10.0.0.3:53378",
     # Cut out part of response
{
    "id": 11,
    "addr": "10.0.0.4:36236",
    "addrbind": "10.0.0.2:8333",
    "services": "000000000000040d",
    "relaytxes": true,
    "lastsend": 1569835448,
    "lastrecv": 1569835448,
    "bytessent": 464,
    "bytesrecv": 488,
    "conntime": 1569835207,
    "timeoffset": 0,
    "pingtime": 0.001063,
    "minping": 0.000456,
    "version": 70015,
    "subver": "/Satoshi:0.18.0/",
    "inbound": true,
    "addnode": false,
    "startingheight": 303,
    "banscore": 0,
    "synced_headers": -1,
    "synced_blocks": -1,
    "inflight": (
    ),
    "whitelisted": false,
    "minfeefilter": 0.00001000,
    "bytessent_per_msg": {
      "feefilter": 32,
      "ping": 96,
      "pong": 96,
      "sendcmpct": 66,
      "sendheaders": 24,
      "verack": 24,
      "version": 126
    },
    "bytesrecv_per_msg": {
      "feefilter": 32,
      "getaddr": 24,
      "ping": 96,
      "pong": 96,
      "sendcmpct": 66,
      "sendheaders": 24,
      "verack": 24,
      "version": 126
    }
  }
)

bitcoin-cli -regtest --datadir=/root/.bitcoin getnodeaddresses 5
(
)

Bitcoin core version

bitcoin-cli -version
Bitcoin Core RPC client version v0.18.0.0-g2472733a24a9364e4c6233ccd04166a26a68cc65
bitcoind -version 
Bitcoin Core Daemon version v0.18.0.0-g2472733a24a9364e4c6233ccd04166a26a68cc65

Is installed via the repository ppa:bitcoin/bitcoin

OS

About the Docker container:

lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 18.04.3 LTS
Release:    18.04
Codename:   bionic

Host info:

lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 18.04.3 LTS
Release:    18.04
Codename:   bionic

cat /proc/cpuinfo  | grep 'name'| uniq
model name  : Intel(R) Core(TM) i7-4600M CPU @ 2.90GHz

1 TB SSD disk