Inside Bitcoin

251
252        # Check block hex format
253        response_hex = self.test_rest_request(f"/block/{bb_hash}", req_type=ReqType.HEX, ret_type=RetType.OBJ)
254        assert_greater_than(int(response_hex.getheader('content-length')), BLOCK_HEADER_SIZE*2)
255        response_hex_bytes = response_hex.read().strip(b'\n')
256        assert_equal(response_bytes.hex().encode(), response_hex_bytes)
257
258        # Compare with hex block header
259        response_header_hex = self.test_rest_request(f"/headers/{bb_hash}", req_type=ReqType.HEX, ret_type=RetType.OBJ, query_params={"count": 1})
260        assert_greater_than(int(response_header_hex.getheader('content-length')), BLOCK_HEADER_SIZE*2)
261        response_header_hex_bytes = response_header_hex.read(BLOCK_HEADER_SIZE*2)
262        assert_equal(response_bytes[:BLOCK_HEADER_SIZE].hex().encode(), response_header_hex_bytes)
263
264        # Check json format
265        block_json_obj = self.test_rest_request(f"/block/{bb_hash}")
266        assert_equal(block_json_obj['hash'], bb_hash)
267        assert_equal(self.test_rest_request(f"/blockhashbyheight/{block_json_obj['height']}")['blockhash'], bb_hash)
268
269        # Check hex/bin format
270        resp_hex = self.test_rest_request(f"/blockhashbyheight/{block_json_obj['height']}", req_type=ReqType.HEX, ret_type=RetType.OBJ)
271        assert_equal(resp_hex.read().decode('utf-8').rstrip(), bb_hash)
272        resp_bytes = self.test_rest_request(f"/blockhashbyheight/{block_json_obj['height']}", req_type=ReqType.BIN, ret_type=RetType.BYTES)
273        blockhash = resp_bytes[::-1].hex()
274        assert_equal(blockhash, bb_hash)
275
276        # Check invalid blockhashbyheight requests
277        resp = self.test_rest_request(f"/blockhashbyheight/{INVALID_PARAM}", ret_type=RetType.OBJ, status=400)
278        assert_equal(resp.read().decode('utf-8').rstrip(), f"Invalid height: {INVALID_PARAM}")
279        resp = self.test_rest_request("/blockhashbyheight/+1", ret_type=RetType.OBJ, status=400)
280        assert_equal(resp.read().decode('utf-8').rstrip(), "Invalid height: +1")
281        resp = self.test_rest_request("/blockhashbyheight/1000000", ret_type=RetType.OBJ, status=404)
282        assert_equal(resp.read().decode('utf-8').rstrip(), "Block height out of range")
283        resp = self.test_rest_request("/blockhashbyheight/-1", ret_type=RetType.OBJ, status=400)
284        assert_equal(resp.read().decode('utf-8').rstrip(), "Invalid height: -1")
285        self.test_rest_request("/blockhashbyheight/", ret_type=RetType.OBJ, status=400)
286
287        # Compare with json block header
288        json_obj = self.test_rest_request(f"/headers/{bb_hash}", query_params={"count": 1})
289        assert_equal(len(json_obj), 1)  # ensure that there is one header in the json response
290        assert_equal(json_obj[0]['hash'], bb_hash)  # request/response hash should be the same
291
292        # Check tolerance for invalid URI (% symbol at the end of the request)
293        for invalid_uri in [f"/headers/{bb_hash}%", f"/blockfilterheaders/basic/{bb_hash}%"]:
294            resp = self.test_rest_request(invalid_uri, ret_type=RetType.OBJ, status=400)
295            assert_equal(resp.read().decode('utf-8').rstrip(), f"Invalid hash: {bb_hash}%")
296        resp = self.test_rest_request("/mempool/contents.json?%", ret_type=RetType.OBJ, status=200)
297        assert_equal(resp.read().decode('utf-8').rstrip(), "{}")
298
299        # Compare with normal RPC block response
300        rpc_block_json = self.nodes[0].getblock(bb_hash)
301        for key in ['hash', 'confirmations', 'height', 'version', 'merkleroot', 'time', 'nonce', 'bits', 'target', 'difficulty', 'chainwork', 'previousblockhash']:
302            assert_equal(json_obj[0][key], rpc_block_json[key])
303
304        # See if we can get 5 headers in one response
305        self.generate(self.nodes[1], 5)
306        expected_filter = {
307            'basic block filter index': {'synced': True, 'best_block_height': 208},
308        }
309        self.wait_until(lambda: self.nodes[0].getindexinfo("basic block filter index") == expected_filter)
310        json_obj = self.test_rest_request(f"/headers/{bb_hash}", query_params={"count": 5})
311        assert_equal(len(json_obj), 5)  # now we should have 5 header objects
312        json_obj = self.test_rest_request(f"/blockfilterheaders/basic/{bb_hash}", query_params={"count": 5})
313        first_filter_header = json_obj[0]
314        assert_equal(len(json_obj), 5)  # now we should have 5 filter header objects
315        json_obj = self.test_rest_request(f"/blockfilter/basic/{bb_hash}")
316
317        # Compare with normal RPC blockfilter response
318        rpc_blockfilter = self.nodes[0].getblockfilter(bb_hash)
319        assert_equal(first_filter_header, rpc_blockfilter['header'])
320        assert_equal(json_obj['filter'], rpc_blockfilter['filter'])
321
322        # Test blockfilterheaders with an invalid hash and filtertype
323        resp = self.test_rest_request(f"/blockfilterheaders/{INVALID_PARAM}/{bb_hash}", ret_type=RetType.OBJ, status=400)
324        assert_equal(resp.read().decode('utf-8').rstrip(), f"Unknown filtertype {INVALID_PARAM}")
325        resp = self.test_rest_request(f"/blockfilterheaders/basic/{INVALID_PARAM}", ret_type=RetType.OBJ, status=400)
326        assert_equal(resp.read().decode('utf-8').rstrip(), f"Invalid hash: {INVALID_PARAM}")
327
328        # Test number parsing
329        for num in ['5a', '-5', '0', '2001', '99999999999999999999999999999999999']:
330            assert_equal(
331                bytes(f'Header count is invalid or out of acceptable range (1-2000): {num}\r\n', 'ascii'),
332                self.test_rest_request(f"/headers/{bb_hash}", ret_type=RetType.BYTES, status=400, query_params={"count": num}),
333            )
334
335        self.log.info("Test tx inclusion in the /mempool and /block URIs")
336
337        # Make 3 chained txs and mine them on node 1
338        txs = []
339        input_txid = txid
340        for _ in range(3):
341            utxo_to_spend = self.wallet.get_utxo(txid=input_txid)
342            txs.append(self.wallet.send_self_transfer(from_node=self.nodes[0], utxo_to_spend=utxo_to_spend)['txid'])
343            input_txid = txs[-1]
344        self.sync_all()
345
346        # Check that there are exactly 3 transactions in the TX memory pool before generating the block
347        json_obj = self.test_rest_request("/mempool/info")
348        assert_equal(json_obj['size'], 3)
349        # the size of the memory pool should be greater than 3x ~100 bytes
350        assert_greater_than(json_obj['bytes'], 300)
351
352        mempool_info = self.nodes[0].getmempoolinfo()
353        # pop unstable unbroadcastcount before check
354        for obj in [json_obj, mempool_info]:
355            obj.pop("unbroadcastcount")
356        assert_equal(json_obj, mempool_info)
357
358        # Check that there are our submitted transactions in the TX memory pool
359        json_obj = self.test_rest_request("/mempool/contents")
360        raw_mempool_verbose = self.nodes[0].getrawmempool(verbose=True)
361
362        assert_equal(json_obj, raw_mempool_verbose)
363
364        for i, tx in enumerate(txs):
365            assert tx in json_obj
366            assert_equal(json_obj[tx]['spentby'], txs[i + 1:i + 2])
367            assert_equal(json_obj[tx]['depends'], txs[i - 1:i])
368
369        # Check the mempool response for explicit parameters
370        json_obj = self.test_rest_request("/mempool/contents", query_params={"verbose": "true", "mempool_sequence": "false"})
371        assert_equal(json_obj, raw_mempool_verbose)
372
373        # Check the mempool response for not verbose
374        json_obj = self.test_rest_request("/mempool/contents", query_params={"verbose": "false"})
375        raw_mempool = self.nodes[0].getrawmempool(verbose=False)
376
377        assert_equal(json_obj, raw_mempool)
378
379        # Check the mempool response for sequence
380        json_obj = self.test_rest_request("/mempool/contents", query_params={"verbose": "false", "mempool_sequence": "true"})
381        raw_mempool = self.nodes[0].getrawmempool(verbose=False, mempool_sequence=True)
382
383        assert_equal(json_obj, raw_mempool)
384
385        # Check for error response if verbose=true and mempool_sequence=true
386        resp = self.test_rest_request("/mempool/contents", ret_type=RetType.OBJ, status=400, query_params={"verbose": "true", "mempool_sequence": "true"})
387        assert_equal(resp.read().decode('utf-8').strip(), 'Verbose results cannot contain mempool sequence values. (hint: set "verbose=false")')
388
389        # Check for error response if verbose is not "true" or "false"
390        resp = self.test_rest_request("/mempool/contents", ret_type=RetType.OBJ, status=400, query_params={"verbose": "TRUE"})
391        assert_equal(resp.read().decode('utf-8').strip(), 'The "verbose" query parameter must be either "true" or "false".')
392
393        # Check for error response if mempool_sequence is not "true" or "false"
394        resp = self.test_rest_request("/mempool/contents", ret_type=RetType.OBJ, status=400, query_params={"verbose": "false", "mempool_sequence": "TRUE"})
395        assert_equal(resp.read().decode('utf-8').strip(), 'The "mempool_sequence" query parameter must be either "true" or "false".')
396
397        # Now mine the transactions
398        newblockhash = self.generate(self.nodes[1], 1)
399
400        # Check if the 3 tx show up in the new block
401        json_obj = self.test_rest_request(f"/block/{newblockhash[0]}")
402        non_coinbase_txs = {tx['txid'] for tx in json_obj['tx']
403                            if 'coinbase' not in tx['vin'][0]}
404        assert_equal(non_coinbase_txs, set(txs))
405
406        # Verify that the non-coinbase tx has "prevout" key set
407        for tx_obj in json_obj["tx"]:
408            for vin in tx_obj["vin"]:
409                if "coinbase" not in vin:
410                    assert "prevout" in vin
411                    assert_equal(vin["prevout"]["generated"], False)
412                else:
413                    assert "prevout" not in vin
414
415        # Check the same but without tx details
416        json_obj = self.test_rest_request(f"/block/notxdetails/{newblockhash[0]}")
417        for tx in txs:
418            assert tx in json_obj['tx']
419
420        self.log.info("Test the /chaininfo URI")
421
422        bb_hash = self.nodes[0].getbestblockhash()
423
424        json_obj = self.test_rest_request("/chaininfo")
425        assert_equal(json_obj['bestblockhash'], bb_hash)
426
427        # Compare with normal RPC getblockchaininfo response
428        blockchain_info = self.nodes[0].getblockchaininfo()
429        assert_equal(blockchain_info, json_obj)
430
431        # Test compatibility of deprecated and newer endpoints
432        self.log.info("Test compatibility of deprecated and newer endpoints")
433        assert_equal(self.test_rest_request(f"/headers/{bb_hash}", query_params={"count": 1}), self.test_rest_request(f"/headers/1/{bb_hash}"))
434        assert_equal(self.test_rest_request(f"/blockfilterheaders/basic/{bb_hash}", query_params={"count": 1}), self.test_rest_request(f"/blockfilterheaders/basic/5/{bb_hash}"))
435
436        self.log.info("Test the /spenttxouts URI")
437
438        block_count = self.nodes[0].getblockcount()
439        for height in range(0, block_count + 1):
440            blockhash = self.nodes[0].getblockhash(height)
441            spent_bin = self.test_rest_request(f"/spenttxouts/{blockhash}", req_type=ReqType.BIN, ret_type=RetType.BYTES)
442            spent_hex = self.test_rest_request(f"/spenttxouts/{blockhash}", req_type=ReqType.HEX, ret_type=RetType.BYTES)
443            spent_json = self.test_rest_request(f"/spenttxouts/{blockhash}", req_type=ReqType.JSON, ret_type=RetType.JSON)
444
445            assert_equal(bytes.fromhex(spent_hex.decode()), spent_bin)
446
447            spent = deser_block_spent_outputs(BytesIO(spent_bin))
448            block = self.nodes[0].getblock(blockhash, 3)  # return prevout for each input
449            assert_equal(len(spent), len(block["tx"]))
450            assert_equal(len(spent_json), len(block["tx"]))
451
452            for i, tx in enumerate(block["tx"]):
453                prevouts = [txin["prevout"] for txin in tx["vin"] if "coinbase" not in txin]
454                # compare with `getblock` JSON output (coinbase tx has no prevouts)
455                actual = [(txout.scriptPubKey.hex(), Decimal(txout.nValue) / COIN) for txout in spent[i]]
456                expected = [(p["scriptPubKey"]["hex"], p["value"]) for p in prevouts]
457                assert_equal(expected, actual)
458                # also compare JSON format
459                actual = [(prevout["scriptPubKey"], prevout["value"]) for prevout in spent_json[i]]
460                expected = [(p["scriptPubKey"], p["value"]) for p in prevouts]
461                assert_equal(expected, actual)
462
463        self.log.info("Test the /blockpart URI")
464
465        blockhash = self.nodes[0].getbestblockhash()
466        block_bin = self.test_rest_request(f"/block/{blockhash}", req_type=ReqType.BIN, ret_type=RetType.BYTES)
467        for req_type in (ReqType.BIN, ReqType.HEX):
468            def get_block_part(status: int = 200, **kwargs):
469                resp = self.test_rest_request(f"/blockpart/{blockhash}", status=status,
470                                              req_type=req_type, ret_type=RetType.BYTES, **kwargs)
471                assert isinstance(resp, bytes)
472                if req_type is ReqType.HEX and status == 200:
473                    resp = bytes.fromhex(resp.decode().strip())
474                return resp
475
476            assert_equal(block_bin, get_block_part(query_params={"offset": 0, "size": len(block_bin)}))
477
478            assert len(block_bin) >= 500
479            assert_equal(block_bin[20:320], get_block_part(query_params={"offset": 20, "size": 300}))
480            assert_equal(block_bin[-5:], get_block_part(query_params={"offset": len(block_bin) - 5, "size": 5}))
481
482            get_block_part(status=400, query_params={"offset": 10})
483            get_block_part(status=400, query_params={"size": 100})
484            get_block_part(status=400, query_params={"offset": "x"})
485            get_block_part(status=400, query_params={"size": "y"})
486            get_block_part(status=400, query_params={"offset": "x", "size": "y"})
487            get_block_part(status=400, query_params="%XY")
488            get_block_part(status=400, query_params={"offset": 0, "size": 0})
489            get_block_part(status=400, query_params={"offset": len(block_bin), "size": 0})
490            get_block_part(status=400, query_params={"offset": len(block_bin), "size": 1})
491            get_block_part(status=400, query_params={"offset": len(block_bin) + 1, "size": 1})
492            get_block_part(status=400, query_params={"offset": 0, "size": len(block_bin) + 1})
493
494        res = self.test_rest_request(f"/blockpart/{blockhash}", status=400, req_type=ReqType.BIN, ret_type=RetType.OBJ)
495        assert res.read().decode().startswith("Block part offset missing or invalid")
496
497        res = self.test_rest_request(f"/blockpart/{blockhash}", query_params={"offset":0, "size":1}, status=400, req_type=ReqType.JSON, ret_type=RetType.OBJ)
498        assert res.read().decode().startswith("JSON output is not supported for this request type")
499
500        self.log.info("Missing block data should cause REST API to fail")