23 std::map<std::string, opcodetype> mapOpNames;
28 for (
unsigned int op = 0; op <=
MAX_OPCODE; ++op) {
35 if (strName ==
"OP_UNKNOWN") {
38 mapOpNames[strName] =
static_cast<opcodetype>(op);
40 if (strName.compare(0, 3,
"OP_") == 0) {
41 mapOpNames[strName.substr(3)] =
static_cast<opcodetype>(op);
47 auto it = mapOpNames.find(s);
48 if (it == mapOpNames.end())
throw std::runtime_error(
"script parse error: unknown opcode");
55 static const OpCodeParser ocp;
65 std::vector<std::string> words =
SplitString(s,
" \t\n");
67 for (
const std::string& w : words) {
70 }
else if (std::all_of(w.begin(), w.end(), ::
IsDigit) ||
71 (w.front() ==
'-' && w.size() > 1 && std::all_of(w.begin() + 1, w.end(), ::
IsDigit)))
74 const auto num{ToIntegral<int64_t>(w)};
78 if (!num.has_value() || num > int64_t{0xffffffff} || num < -1 * int64_t{0xffffffff}) {
79 throw std::runtime_error(
"script parse error: decimal numeric value only allowed in the "
80 "range -0xFFFFFFFF...0xFFFFFFFF");
83 result << num.value();
84 }
else if (w.substr(0, 2) ==
"0x" && w.size() > 2 &&
IsHex(std::string(w.begin() + 2, w.end()))) {
86 std::vector<unsigned char> raw =
ParseHex(std::string(w.begin() + 2, w.end()));
87 result.
insert(result.
end(), raw.begin(), raw.end());
88 }
else if (w.size() >= 2 && w.front() ==
'\'' && w.back() ==
'\'') {
91 std::vector<unsigned char> value(w.begin() + 1, w.end() - 1);
95 result << ParseOpCode(w);
107 for (
unsigned int i = 0; i < tx.
vin.size(); i++) {
114 for (
unsigned int i = 0; i < tx.
vout.size(); i++) {
139 bool ok_extended =
false, ok_legacy =
false;
147 if (ssData.
empty()) ok_extended =
true;
148 }
catch (
const std::exception&) {
156 tx = std::move(tx_extended);
161 if (try_no_witness) {
165 if (ssData.
empty()) ok_legacy =
true;
166 }
catch (
const std::exception&) {
174 tx = std::move(tx_legacy);
180 tx = std::move(tx_extended);
186 tx = std::move(tx_legacy);
196 if (!
IsHex(hex_tx)) {
200 std::vector<unsigned char> txData(
ParseHex(hex_tx));
201 return DecodeTx(tx, txData, try_no_witness, try_witness);
206 if (!
IsHex(hex_header))
return false;
208 const std::vector<unsigned char> header_data{
ParseHex(hex_header)};
211 ser_header >> header;
212 }
catch (
const std::exception&) {
220 if (!
IsHex(strHexBlk))
223 std::vector<unsigned char> blockData(
ParseHex(strHexBlk));
228 catch (
const std::exception&) {
237 if ((strHex.size() != 64) || !
IsHex(strHex))
246 static std::map<std::string, int> map_sighash_values = {
255 const auto& it = map_sighash_values.find(sighash);
256 if (it != map_sighash_values.end()) {
Serialized script, used inside transaction inputs and outputs.
The basic transaction that is broadcasted on the network and contained in blocks.
Double ended buffer combining vector and stream-like interfaces.
void SetHex(const char *psz)
iterator insert(iterator pos, const T &value)
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
CScript ParseScript(const std::string &s)
util::Result< int > SighashFromStr(const std::string &sighash)
static bool CheckTxScriptsSanity(const CMutableTransaction &tx)
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness, bool try_witness)
bool DecodeHexBlockHeader(CBlockHeader &header, const std::string &hex_header)
bool ParseHashStr(const std::string &strHex, uint256 &result)
Parse a hex string into 256 bits.
static bool DecodeTx(CMutableTransaction &tx, const std::vector< unsigned char > &tx_data, bool try_no_witness, bool try_witness)
bool DecodeHexBlk(CBlock &block, const std::string &strHexBlk)
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
static constexpr TransactionSerParams TX_NO_WITNESS
static constexpr TransactionSerParams TX_WITH_WITNESS
std::string GetOpName(opcodetype opcode)
static const unsigned int MAX_OPCODE
static const int MAX_SCRIPT_SIZE
opcodetype
Script opcodes.
constexpr bool IsDigit(char c)
Tests if the given character is a decimal digit.
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
std::vector< std::string > SplitString(std::string_view str, char sep)
A mutable version of CTransaction.
std::vector< CTxOut > vout
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
bool IsHex(std::string_view str)