Merge 143ace6 into merged_master (Bitcoin PR bitcoin/bitcoin#28890)

delta1 · delta1 · commit a264d5785d2d · 2025-11-17T21:42:59.000+02:00
diff --git a/src/core_io.h b/src/core_io.h
@@ -53,10 +53,10 @@ bool ParseHashStr(const std::string& strHex, uint256& result);
 // core_write.cpp
 UniValue ValueFromAmount(const CAmount amount);
 std::string FormatScript(const CScript& script);
-std::string EncodeHexTx(const CTransaction& tx, const bool without_witness = false);
+std::string EncodeHexTx(const CTransaction& tx);
 UniValue EncodeHexScriptWitness(const CScriptWitness& witness);
 std::string SighashToStr(unsigned char sighash_type);
 void ScriptToUniv(const CScript& script, UniValue& out, bool include_hex = true, bool include_address = false, const SigningProvider* provider = nullptr);
-void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry, bool include_hex = true, bool without_witness = false, const CTxUndo* txundo = nullptr, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS);
+void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry, bool include_hex = true, const CTxUndo* txundo = nullptr, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS);
 
 #endif // BITCOIN_CORE_IO_H
diff --git a/src/core_write.cpp b/src/core_write.cpp
@@ -169,14 +169,10 @@ std::string ScriptToAsmStr(const CScript& script, const bool fAttemptSighashDeco
     return str;
 }
 
-std::string EncodeHexTx(const CTransaction& tx, const bool without_witness)
+std::string EncodeHexTx(const CTransaction& tx)
 {
     DataStream ssTx;
-    if (without_witness) {
-        ssTx << TX_NO_WITNESS(tx);
-    } else {
-        ssTx << TX_WITH_WITNESS(tx);
-    }
+    ssTx << TX_WITH_WITNESS(tx);
     return HexStr(ssTx);
 }
 
@@ -228,7 +224,7 @@ void ScriptToUniv(const CScript& script, UniValue& out, bool include_hex, bool i
     }
 }
 
-void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry, bool include_hex, bool without_witness, const CTxUndo* txundo, TxVerbosity verbosity)
+void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry, bool include_hex, const CTxUndo* txundo, TxVerbosity verbosity)
 {
     CHECK_NONFATAL(verbosity >= TxVerbosity::SHOW_DETAILS);
 
@@ -426,6 +422,6 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
     }
 
     if (include_hex) {
-        entry.pushKV("hex", EncodeHexTx(tx, without_witness)); // The hex-encoded transaction. Used the name "hex" to be consistent with the verbose output of "getrawtransaction".
+        entry.pushKV("hex", EncodeHexTx(tx)); // The hex-encoded transaction. Used the name "hex" to be consistent with the verbose output of "getrawtransaction".
     }
 }
diff --git a/src/init.cpp b/src/init.cpp
@@ -669,7 +669,6 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-rpccookiefile=<loc>", "Location of the auth cookie. Relative paths will be prefixed by a net-specific datadir location. (default: data dir)", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
     argsman.AddArg("-rpcport=<port>", strprintf("Listen for JSON-RPC connections on <port> (default: %u, testnet: %u, signet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), signetBaseParams->RPCPort(), regtestBaseParams->RPCPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::RPC);
-    argsman.AddArg("-rpcserialversion", strprintf("Sets the serialization of raw transaction or block hex returned in non-verbose mode, non-segwit(0) (DEPRECATED) or segwit(1) (default: %d)", DEFAULT_RPC_SERIALIZE_VERSION), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
     argsman.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
@@ -1092,16 +1091,7 @@ bool AppInitParameterInteraction(const ArgsManager& args)
     if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))
         nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
 
-    if (args.GetIntArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) < 0)
-        return InitError(Untranslated("rpcserialversion must be non-negative."));
-
-    if (args.GetIntArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) > 1)
-        return InitError(Untranslated("Unknown rpcserialversion requested."));
-
-    if (args.GetIntArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) == 0 && !IsDeprecatedRPCEnabled("serialversion")) {
-        return InitError(Untranslated("-rpcserialversion=0 is deprecated and will be removed in the future. Specify -deprecatedrpc=serialversion to allow anyway."));
-    }
-
+    // ELEMENTS
     try {
         const std::string default_asset_name = gArgs.GetArg("-defaultpeggedassetname", "bitcoin");
         InitGlobalAssetDir(gArgs.GetArgs("-assetdir"), default_asset_name);
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
@@ -337,9 +337,6 @@ class Chain
     //! Run function after given number of seconds. Cancel any previous calls with same name.
     virtual void rpcRunLater(const std::string& name, std::function<void()> fn, int64_t seconds) = 0;
 
-    //! Current RPC serialization flags.
-    virtual bool rpcSerializationWithoutWitness() = 0;
-
     //! Get settings value.
     virtual common::SettingsValue getSetting(const std::string& arg) = 0;
 
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
@@ -779,7 +779,6 @@ class ChainImpl : public Chain
     {
         RPCRunLater(name, std::move(fn), seconds);
     }
-    bool rpcSerializationWithoutWitness() override { return RPCSerializationWithoutWitness(); }
     common::SettingsValue getSetting(const std::string& name) override
     {
         return args().GetSetting(name);
diff --git a/src/rest.cpp b/src/rest.cpp
@@ -322,7 +322,7 @@ static bool rest_block(const std::any& context,
     switch (rf) {
     case RESTResponseFormat::BINARY: {
         DataStream ssBlock;
-        ssBlock << RPCTxSerParams(block);
+        ssBlock << TX_WITH_WITNESS(block);
         std::string binaryBlock = ssBlock.str();
         req->WriteHeader("Content-Type", "application/octet-stream");
         req->WriteReply(HTTP_OK, binaryBlock);
@@ -331,7 +331,7 @@ static bool rest_block(const std::any& context,
 
     case RESTResponseFormat::HEX: {
         DataStream ssBlock;
-        ssBlock << RPCTxSerParams(block);
+        ssBlock << TX_WITH_WITNESS(block);
         std::string strHex = HexStr(ssBlock) + "\n";
         req->WriteHeader("Content-Type", "text/plain");
         req->WriteReply(HTTP_OK, strHex);
@@ -728,7 +728,7 @@ static bool rest_tx(const std::any& context, HTTPRequest* req, const std::string
     switch (rf) {
     case RESTResponseFormat::BINARY: {
         DataStream ssTx;
-        ssTx << RPCTxSerParams(tx);
+        ssTx << TX_WITH_WITNESS(tx);
 
         std::string binaryTx = ssTx.str();
         req->WriteHeader("Content-Type", "application/octet-stream");
@@ -738,7 +738,7 @@ static bool rest_tx(const std::any& context, HTTPRequest* req, const std::string
 
     case RESTResponseFormat::HEX: {
         DataStream ssTx;
-        ssTx << RPCTxSerParams(tx);
+        ssTx << TX_WITH_WITNESS(tx);
 
         std::string strHex = HexStr(ssTx) + "\n";
         req->WriteHeader("Content-Type", "text/plain");
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
@@ -273,7 +273,7 @@ UniValue blockToJSON(BlockManager& blockman, const CBlock& block, const CBlockIn
                 // coinbase transaction (i.e. i == 0) doesn't have undo data
                 const CTxUndo* txundo = (have_undo && i > 0) ? &blockUndo.vtxundo.at(i - 1) : nullptr;
                 UniValue objTx(UniValue::VOBJ);
-                TxToUniv(*tx, /*block_hash=*/uint256(), /*entry=*/objTx, /*include_hex=*/true, /*without_witness=*/RPCSerializationWithoutWitness(), txundo, verbosity);
+                TxToUniv(*tx, /*block_hash=*/uint256(), /*entry=*/objTx, /*include_hex=*/true, txundo, verbosity);
                 txs.push_back(std::move(objTx));
             }
             break;
@@ -868,10 +868,9 @@ static RPCHelpMan getblock()
 
     const CBlock block{GetBlockChecked(chainman.m_blockman, *pblockindex)};
 
-    if (verbosity <= 0)
-    {
+    if (verbosity <= 0) {
         DataStream ssBlock;
-        ssBlock << RPCTxSerParams(block);
+        ssBlock << TX_WITH_WITNESS(block);
         std::string strHex = HexStr(ssBlock);
         return strHex;
     }
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
@@ -419,7 +419,7 @@ static RPCHelpMan generateblock()
     obj.pushKV("hash", block_out->GetHash().GetHex());
     if (!process_new_block) {
         DataStream block_ser;
-        block_ser << RPCTxSerParams(*block_out);
+        block_ser << TX_WITH_WITNESS(*block_out);
         obj.pushKV("hex", HexStr(block_ser));
     }
     return obj;
@@ -1329,7 +1329,7 @@ static RPCHelpMan combineblocksigs()
     }
 
     DataStream ssBlock;
-    ssBlock << RPCTxSerParams(block);
+    ssBlock << TX_WITH_WITNESS(block);
     UniValue result(UniValue::VOBJ);
     result.pushKV("hex", HexStr(ssBlock));
     result.pushKV("complete", CheckProof(block, params));
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
@@ -74,7 +74,7 @@ static void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue&
     // Blockchain contextual information (confirmations and blocktime) is not
     // available to code in bitcoin-common, so we query them here and push the
     // data into the returned UniValue.
-    TxToUniv(tx, /*block_hash=*/uint256(), entry, /*include_hex=*/true, RPCSerializationWithoutWitness(), txundo, verbosity);
+    TxToUniv(tx, /*block_hash=*/uint256(), entry, /*include_hex=*/true, txundo, verbosity);
 
     if (!hashBlock.IsNull()) {
         LOCK(cs_main);
@@ -450,7 +450,7 @@ static RPCHelpMan getrawtransaction()
     }
 
     if (verbosity <= 0) {
-        return EncodeHexTx(CTransaction(*tx), /*without_witness=*/RPCSerializationWithoutWitness());
+        return EncodeHexTx(CTransaction(*tx));
     }
 
     UniValue result(UniValue::VOBJ);
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
@@ -597,9 +597,4 @@ void RPCRunLater(const std::string& name, std::function<void()> func, int64_t nS
     deadlineTimers.emplace(name, std::unique_ptr<RPCTimerBase>(timerInterface->NewTimer(func, nSeconds*1000)));
 }
 
-bool RPCSerializationWithoutWitness()
-{
-    return (gArgs.GetIntArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) == 0);
-}
-
 CRPCTable tableRPC;
diff --git a/src/rpc/server.h b/src/rpc/server.h
@@ -16,8 +16,6 @@
 
 #include <univalue.h>
 
-static const unsigned int DEFAULT_RPC_SERIALIZE_VERSION = 1;
-
 class CRPCCommand;
 
 namespace RPCServer
@@ -183,14 +181,4 @@ void InterruptRPC();
 void StopRPC();
 std::string JSONRPCExecBatch(const JSONRPCRequest& jreq, const UniValue& vReq);
 
-// Drop witness when serializing for RPC?
-bool RPCSerializationWithoutWitness();
-
-template<typename T>
-auto RPCTxSerParams(T&& t)
-{
-    if (RPCSerializationWithoutWitness()) return TX_NO_WITNESS(t);
-    return TX_WITH_WITNESS(t);
-}
-
 #endif // BITCOIN_RPC_SERVER_H
diff --git a/src/wallet/rpc/elements.cpp b/src/wallet/rpc/elements.cpp
@@ -873,7 +873,7 @@ static UniValue createrawpegin(const JSONRPCRequest& request, T_tx_ref& txBTCRef
     UniValue ret(UniValue::VOBJ);
 
     // Return hex
-    std::string strHex = EncodeHexTx(CTransaction(mtx), /*without_witness=*/RPCSerializationWithoutWitness());
+    std::string strHex = EncodeHexTx(CTransaction(mtx));
     ret.pushKV("hex", strHex);
 
     // Additional block lee-way to avoid bitcoin block races
diff --git a/src/wallet/rpc/transactions.cpp b/src/wallet/rpc/transactions.cpp
@@ -845,8 +845,7 @@ RPCHelpMan gettransaction()
     ListTransactions(*pwallet, wtx, 0, false, details, filter, /*filter_label=*/std::nullopt);
     entry.pushKV("details", details);
 
-    std::string strHex = EncodeHexTx(*wtx.tx, pwallet->chain().rpcSerializationWithoutWitness());
-    entry.pushKV("hex", strHex);
+    entry.pushKV("hex", EncodeHexTx(*wtx.tx));
 
     if (verbose) {
         UniValue decoded(UniValue::VOBJ);
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
@@ -250,7 +250,7 @@ bool CZMQPublishRawBlockNotifier::NotifyBlock(const CBlockIndex *pindex)
         return false;
     }
 
-    ss << RPCTxSerParams(block);
+    ss << TX_WITH_WITNESS(block);
 
     return SendZmqMessage(MSG_RAWBLOCK, &(*ss.begin()), ss.size());
 }
@@ -260,7 +260,7 @@ bool CZMQPublishRawTransactionNotifier::NotifyTransaction(const CTransaction &tr
     uint256 hash = transaction.GetHash();
     LogPrint(BCLog::ZMQ, "Publish rawtx %s to %s\n", hash.GetHex(), this->address);
     DataStream ss;
-    ss << RPCTxSerParams(transaction);
+    ss << TX_WITH_WITNESS(transaction);
     return SendZmqMessage(MSG_RAWTX, &(*ss.begin()), ss.size());
 }
 
diff --git a/test/functional/feature_segwit.py b/test/functional/feature_segwit.py
@@ -89,14 +89,11 @@ def set_test_params(self):
         self.extra_args = [
             [
                 "-acceptnonstdtxn=1",
-                "-rpcserialversion=0",
-                "-deprecatedrpc=serialversion",
                 "-testactivationheight=segwit@165",
                 "-addresstype=legacy",
             ],
             [
                 "-acceptnonstdtxn=1",
-                "-rpcserialversion=1",
                 "-testactivationheight=segwit@165",
                 "-addresstype=legacy",
             ],
@@ -225,18 +222,6 @@ def run_test(self):
         self.fail_accept(self.nodes[0], "mandatory-script-verify-flag-failed (Witness program hash mismatch)", p2sh_ids[NODE_0][P2WPKH][0], sign=False, redeem_script=witness_script(False, self.pubkey[0]))
         self.fail_accept(self.nodes[0], "mandatory-script-verify-flag-failed (Witness program was passed an empty witness)", p2sh_ids[NODE_0][P2WSH][0], sign=False, redeem_script=witness_script(True, self.pubkey[0]))
 
-        self.log.info("Verify block and transaction serialization rpcs return differing serializations depending on rpc serialization flag")
-        assert self.nodes[2].getblock(blockhash, False) != self.nodes[0].getblock(blockhash, False)
-        assert self.nodes[1].getblock(blockhash, False) == self.nodes[2].getblock(blockhash, False)
-
-        for tx_id in segwit_tx_list:
-            tx = tx_from_hex(self.nodes[2].gettransaction(tx_id)["hex"])
-            assert self.nodes[2].getrawtransaction(tx_id, False, blockhash) != self.nodes[0].getrawtransaction(tx_id, False, blockhash)
-            assert self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].getrawtransaction(tx_id, False, blockhash)
-            assert self.nodes[0].getrawtransaction(tx_id, False, blockhash) != self.nodes[2].gettransaction(tx_id)["hex"]
-            assert self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].gettransaction(tx_id)["hex"]
-            assert self.nodes[0].getrawtransaction(tx_id, False, blockhash) == tx.serialize_without_witness().hex()
-
         # Coinbase contains the witness commitment nonce, check that RPC shows us
         coinbase_txid = self.nodes[2].getblock(blockhash)['tx'][0]
         coinbase_tx = self.nodes[2].gettransaction(txid=coinbase_txid, verbose=True)
@@ -277,9 +262,6 @@ def run_test(self):
         #                      tx3 (non-segwit input, paying to a non-segwit output).
         # tx1 is allowed to appear in the block, but no others.
         txid1 = send_to_witness(1, self.nodes[0], find_spendable_utxo(self.nodes[0], 50), self.pubkey[0], False, Decimal("49.996"))
-        hex_tx = self.nodes[0].gettransaction(txid)['hex']
-        tx = tx_from_hex(hex_tx)
-        assert tx.wit.is_null()  # This should not be a segwit input
         assert txid1 in self.nodes[0].getrawmempool()
 
         tx1_hex = self.nodes[0].gettransaction(txid1)['hex']
@@ -620,11 +602,6 @@ def run_test(self):
                 assert_equal(self.nodes[1].gettransaction(txid, True)["txid"], txid)
                 assert_equal(self.nodes[1].listtransactions("*", 1, 0, True)[0]["txid"], txid)
 
-        self.log.info('Test negative and unknown rpcserialversion throw an init error')
-        self.stop_node(0)
-        self.nodes[0].assert_start_raises_init_error(["-rpcserialversion=-1"], "Error: rpcserialversion must be non-negative.")
-        self.nodes[0].assert_start_raises_init_error(["-rpcserialversion=100"], "Error: Unknown rpcserialversion requested.")
-
     def mine_and_test_listunspent(self, script_list, ismine):
         utxo = find_spendable_utxo(self.nodes[0], 50)
         tx = CTransaction()

Original file line number	Diff line number	Diff line change
`@@ -169,14 +169,10 @@ std::string ScriptToAsmStr(const CScript& script, const bool fAttemptSighashDeco`
`169`	`169`	`return str;`
`170`	`170`	`}`
`171`	`171`
`172`		`-std::string EncodeHexTx(const CTransaction& tx, const bool without_witness)`
	`172`	`+std::string EncodeHexTx(const CTransaction& tx)`
`173`	`173`	`{`
`174`	`174`	`DataStream ssTx;`
`175`		`- if (without_witness) {`
`176`		`- ssTx << TX_NO_WITNESS(tx);`
`177`		`- } else {`
`178`		`- ssTx << TX_WITH_WITNESS(tx);`
`179`		`- }`
	`175`	`+ ssTx << TX_WITH_WITNESS(tx);`
`180`	`176`	`return HexStr(ssTx);`
`181`	`177`	`}`
`182`	`178`
`@@ -228,7 +224,7 @@ void ScriptToUniv(const CScript& script, UniValue& out, bool include_hex, bool i`
`228`	`224`	`}`
`229`	`225`	`}`
`230`	`226`
`231`		`-void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry, bool include_hex, bool without_witness, const CTxUndo* txundo, TxVerbosity verbosity)`
	`227`	`+void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry, bool include_hex, const CTxUndo* txundo, TxVerbosity verbosity)`
`232`	`228`	`{`
`233`	`229`	`CHECK_NONFATAL(verbosity >= TxVerbosity::SHOW_DETAILS);`
`234`	`230`
`@@ -426,6 +422,6 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry`
`426`	`422`	`}`
`427`	`423`
`428`	`424`	`if (include_hex) {`
`429`		`- entry.pushKV("hex", EncodeHexTx(tx, without_witness)); // The hex-encoded transaction. Used the name "hex" to be consistent with the verbose output of "getrawtransaction".`
	`425`	`+ entry.pushKV("hex", EncodeHexTx(tx)); // The hex-encoded transaction. Used the name "hex" to be consistent with the verbose output of "getrawtransaction".`
`430`	`426`	`}`
`431`	`427`	`}`
Original file line number	Diff line number	Diff line change
`@@ -779,7 +779,6 @@ class ChainImpl : public Chain`
`779`	`779`	`{`
`780`	`780`	`RPCRunLater(name, std::move(fn), seconds);`
`781`	`781`	`}`
`782`		`- bool rpcSerializationWithoutWitness() override { return RPCSerializationWithoutWitness(); }`
`783`	`782`	`common::SettingsValue getSetting(const std::string& name) override`
`784`	`783`	`{`
`785`	`784`	`return args().GetSetting(name);`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ static void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue&`
`74`	`74`	`// Blockchain contextual information (confirmations and blocktime) is not`
`75`	`75`	`// available to code in bitcoin-common, so we query them here and push the`
`76`	`76`	`// data into the returned UniValue.`
`77`		`- TxToUniv(tx, /block_hash=/uint256(), entry, /include_hex=/true, RPCSerializationWithoutWitness(), txundo, verbosity);`
	`77`	`+ TxToUniv(tx, /block_hash=/uint256(), entry, /include_hex=/true, txundo, verbosity);`
`78`	`78`
`79`	`79`	`if (!hashBlock.IsNull()) {`
`80`	`80`	`LOCK(cs_main);`
`@@ -450,7 +450,7 @@ static RPCHelpMan getrawtransaction()`
`450`	`450`	`}`
`451`	`451`
`452`	`452`	`if (verbosity <= 0) {`
`453`		`- return EncodeHexTx(CTransaction(tx), /without_witness=*/RPCSerializationWithoutWitness());`
	`453`	`+ return EncodeHexTx(CTransaction(*tx));`
`454`	`454`	`}`
`455`	`455`
`456`	`456`	`UniValue result(UniValue::VOBJ);`
Original file line number	Diff line number	Diff line change
`@@ -597,9 +597,4 @@ void RPCRunLater(const std::string& name, std::function<void()> func, int64_t nS`
`597`	`597`	`deadlineTimers.emplace(name, std::unique_ptr<RPCTimerBase>(timerInterface->NewTimer(func, nSeconds*1000)));`
`598`	`598`	`}`
`599`	`599`
`600`		`-bool RPCSerializationWithoutWitness()`
`601`		`-{`
`602`		`- return (gArgs.GetIntArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) == 0);`
`603`		`-}`
`604`		`-`
`605`	`600`	`CRPCTable tableRPC;`