diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index 08a534cf6..28ad3e6ef 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -510,7 +510,7 @@ "FILE:@@//meta/dev/Cargo.toml 64cb62f25458026de7748e583b92319cb502a54e67aa35ba2c10c2fdd7a85b29", "FILE:@@//pkgs/params/Cargo.toml 400e5d348128dcf4cbb07a653cd803156e870cd4076902dbb720675d96ad2c13", "FILE:@@//pkgs/pow/Cargo.toml 5c09425294d7a239a2beb6b6709e92ce90c28b857d936b28f4947c4cff56d3d1", - "FILE:@@//pkgs/primitives/Cargo.toml ac212c70bd8d49239dcb23e6941daea93fe285919edbfe90aac9f6f4fd215677", + "FILE:@@//pkgs/primitives/Cargo.toml 95422a383dbeed5295cc7bf69b7940efbed197c0bf7ce2379e019f0a7b2a509f", "FILE:@@//pkgs/pkc/Cargo.toml 3c5f6c6ddc6bd91a7cc3719d98cfe9dd4fa7a5f0a34b0e96efae4c2771051e1e", "FILE:@@//pkgs/script/Cargo.toml c7238b5d56c5fd9e2640b40ee31e62c37458b2cc5bccd918fc356d735d16c63b", "FILE:@@//pkgs/p2p_core/Cargo.toml 415e43b46d1d6ab4ffcb7e544919adbb856b537487db2043495679c4aa4cb0af" diff --git a/pkgs/pkc/src/ecdsa/sig_rec_ops.rs b/pkgs/pkc/src/ecdsa/sig_rec_ops.rs index 1d56089cb..f44c1e5dd 100644 --- a/pkgs/pkc/src/ecdsa/sig_rec_ops.rs +++ b/pkgs/pkc/src/ecdsa/sig_rec_ops.rs @@ -130,6 +130,7 @@ type_cvrt!(From for EcdsaRecSignature, |rec| { #[cfg(test)] #[expect(clippy::unwrap_used, reason = "test code")] mod tests { + use crate::ecdsa::curve_consts::ORDER; use crate::ecdsa::tests::*; use crate::ecdsa::{ Compression, EcdsaPublicKey, EcdsaRecSigBytes, EcdsaRecSignature, EcdsaSecretKey, EcdsaSigBytes, EcdsaSignature, @@ -211,6 +212,44 @@ mod tests { assert_eq!(EcdsaPublicKey::recover(&MSG, &normalized).unwrap(), alice_pk); } + /// Half the curve order, rounded down, which is the largest low S. + fn half_order() -> [u8; 32] { + let mut half = [0u8; 32]; + let mut carry = 0; + for (h, o) in half.iter_mut().zip(ORDER) { + *h = (carry << 7) | (o >> 1); + carry = o & 1; + } + half + } + + /// A recoverable signature read from its 65 bytes tells a high S from its + /// low-S twin, which verification and recovery both accept. + #[rstest] + fn tells_high_s_from_its_low_s_twin(alice_pk: EcdsaPublicKey, alice_rec_sig: EcdsaRecSignature) { + let bytes = EcdsaRecSigBytes::from(alice_rec_sig).to_bytes(); + let read = |s: &[u8; 32], recovery_id: u8| { + let mut out = bytes; + out[0] = 27 + (bytes[0] - 27) / 4 * 4 + recovery_id; + out[33..].copy_from_slice(s); + EcdsaRecSignature::try_from(EcdsaRecSigBytes::from_bytes(out).unwrap()).unwrap() + }; + let id = alice_rec_sig.recovery_id(); + + let half = half_order(); + assert!(read(&half, id).signature().is_low_s()); + assert!(!read(&negate_scalar(&half), id).signature().is_low_s()); + + let low = read(&bytes[33..].try_into().unwrap(), id); + let high = read(&negate_scalar(&bytes[33..]), id ^ 1); + assert_eq!(low, alice_rec_sig); + assert!(low.signature().is_low_s()); + assert!(!high.signature().is_low_s()); + assert_eq!(high.normalize_s(), Some(low)); + assert_eq!(alice_pk.verify_digest(&MSG, high), Ok(())); + assert_eq!(EcdsaPublicKey::recover(&MSG, &high).unwrap(), alice_pk); + } + #[rstest] fn verifies_without_downcast(alice_pk: EcdsaPublicKey, alice_rec_sig: EcdsaRecSignature) { assert!(alice_pk.verify_digest(&MSG, alice_rec_sig).is_ok()); diff --git a/pkgs/primitives/Cargo.toml b/pkgs/primitives/Cargo.toml index 6817a5513..eafc740d7 100644 --- a/pkgs/primitives/Cargo.toml +++ b/pkgs/primitives/Cargo.toml @@ -1,6 +1,9 @@ [package] name = "dash-primitives" version = "0.0.0" +exclude = [ + "contrib", +] readme = "README.md" authors.workspace = true edition.workspace = true diff --git a/pkgs/primitives/contrib/sighash.py b/pkgs/primitives/contrib/sighash.py new file mode 100755 index 000000000..ece039cfb --- /dev/null +++ b/pkgs/primitives/contrib/sighash.py @@ -0,0 +1,416 @@ +#!/usr/bin/env python3 +# coding: latin-1 + +# +# Copyright (c) 2026-present, The Dash Core developers +# SPDX-License-Identifier: MIT +# See the accompanying file LICENSE or https://opensource.org/license/MIT +# + +"""Write the payload sign hash corpus. + +For each transaction in `ROWS`, the corpus holds the transaction and the keys +its signers held at the block before, read from a node of its chain. Each node +needs `-txindex`. + +Usage: + + ./pkgs/primitives/contrib/sighash.py \\ + --node 127.0.0.1:9998 ~/.dashcore/.cookie \\ + --node 127.0.0.1:19998 ~/.dashcore/testnet3/.cookie +""" + +from __future__ import annotations + +import argparse +import base64 +import hashlib +import http.client +import ipaddress +import json +import sys +from pathlib import Path +from typing import TypeVar + +T = TypeVar("T") + +# Where the corpus is written by default. +CORPUS = Path(__file__).resolve().parent.parent / "corpus" / "sighash.json5" + +# The transactions the corpus holds by chain, each with what it pins. +ROWS: dict[str, list[tuple[str, str]]] = { + "main": [ + ( + "4e84b507ff3dcd9819e9d04393c0a7b40c6267f46e531af08cbafd26720eb382", + "A version 1 registration, signed by the collateral key.", + ), + ( + "62ab2736bf85c1e1251cdfb95e8229b05d3b3fd97b39d9b9baf414c5f93474b5", + "A version 2 registration.", + ), + ( + "49a4887a2e7fc0bde104fc91478597b356520a61e6d27cd08a945edd5ceab3ca", + "A version 1 service update, signed under the legacy scheme.", + ), + ( + "764460fc0d3303f5de75ff938bc397407e46574af6f72d054a31c81d3ea26baf", + "A version 1 service update, signed under the basic scheme.", + ), + ( + "4e0d18e300d2ea0db81cb334aac6098848b7026439a43c78a90add2ca9a3eb01", + "A version 2 service update.", + ), + ( + "9663a0f0503fdc680b05ed0d1ced0131695f1732be32a45e4d4bc5085865473d", + "A version 2 service update of an Evo masternode.", + ), + ( + "6002c6e304dc609d28bdf0da5304ca47394152f21711d1ea1687c40dbec216de", + "A version 1 registrar update.", + ), + ( + "39c7568aabf91fb8d27d3146aa13e16118c0d168a903f2c116fcd02132466ce7", + "A version 2 registrar update.", + ), + ( + "1b521e8f348e2a01969e4a9aaa377c3ce350dab158a7add82eac6bba1d090594", + "A version 1 revocation, signed under the legacy scheme.", + ), + ( + "21b5994a3cd21df0568eda024e15b54f380f914a2d749be96d00b31a18073767", + "A version 2 revocation.", + ), + ( + "cb11eb2b4f2a5d2b4294e8c2965478f037dd36d90a0d4734c0e3e868a2f4d024", + "A version 2 revocation under a legacy-encoded key.", + ), + ], + "test": [ + ( + "13ccca675ed8a8a788693f46191e7237e2896701ede3058c20263e1b2343923d", + "A version 3 registration.", + ), + ( + "2770d2493755b59b3426474b2a18eb5c34df636530ae8059aa1fe4b22ce47c3c", + "A version 3 registration of an Evo masternode.", + ), + ( + "8699ef5afd141f7b02f170db4f4875468ace2f6c84c6889f3e0280633ba65f40", + "A version 3 registration with shares, signed by each share owner.", + ), + ( + "d0faa9b0748eb837f5d55f6aad7d3e83352cf69de161521e7fc37fda877ba098", + "A version 3 service update.", + ), + ( + "0b9ef4f3b1607841c5f98485ade8f1bdf4d5b8127a24343a53d501bed74b525c", + "A version 3 service update of an Evo masternode.", + ), + ( + "7209b5bdb6881a69029a89501392b0ef05ff8ca83be7df03d7a247241b7ac4e7", + "A version 3 service update under a legacy-encoded key.", + ), + ( + "4e0f211850f44c55e26e45f6bc10a59d6c08fe91be544a8fac0f7ce6cf96ad06", + "A version 3 revocation.", + ), + ( + "46a47fe65c9fd29e9379f3f74020df33dabb1d4095c8da6b1fa05e508b74a491", + "A hard fork signal.", + ), + ( + "cb39c38505c359a653eb15106c9532104f24751d53f8e9abb76e3fb810a7d5b3", + "A version 1 asset unlock.", + ), + ( + "d0b92723bd36450c2fcb51ef0886818ad40a09c07115dd55bc659a2546fa54fd", + "A dissolution, signed by each share owner.", + ), + ], +} + +# Members of `getrawtransaction` that hold the payload, by type. +PAYLOADS = { + 1: "proRegTx", + 2: "proUpServTx", + 3: "proUpRegTx", + 4: "proUpRevTx", + 7: "mnhfTx", + 9: "assetUnlockTx", + 10: "proDisTx", +} + +# The service update and the revocation, which the operator key signs. +OPERATOR_SIGNED = {2, 4} + +# The registrar update and the dissolution, which the owners of the +# masternode sign. +OWNER_SIGNED = {3, 10} + +# Network names the corpus uses, by chain. +NETWORKS = {"main": "mainnet", "test": "testnet"} + +# Quorum types that sign each payload on testnet. +QUORUM_TYPES = { + "testnet": {7: 1, 9: 6}, +} + +# Blocks after a quorum's base block that are read for its commitment, more +# than the mining window of any quorum type. +QUORUM_SCAN = 60 + +# Base58 digits. +B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" + +# Seconds to wait for a reply. +RPC_TIMEOUT = 600 + + +class RpcError(Exception): + """A failed call, or a reply without the expected members.""" + + +def is_loopback(host: str) -> bool: + """Whether *host* is `localhost` or a loopback address.""" + if host == "localhost": + return True + # An IPv6 address in a host:port pair comes in brackets. + if host.startswith("[") and host.endswith("]"): + host = host[1:-1] + try: + return ipaddress.ip_address(host).is_loopback + except ValueError: + return False + + +class Node: + """A JSON-RPC client of one node, authenticated with its cookie.""" + + def __init__(self, address: str, cookie: Path) -> None: + host, _, port = address.rpartition(":") + if not host or not port.isdigit(): + raise RpcError(f"{address!r} is not a host:port address") + if not is_loopback(host): + hint = "reach a remote node through a tunnel" + raise RpcError(f"{host} is not a loopback address; {hint}") + self.host = host + self.port = int(port) + token = base64.b64encode(cookie.read_bytes().strip()).decode() + self.headers = { + "Authorization": f"Basic {token}", + "Content-Type": "application/json", + } + + def call(self, method: str, *params: object) -> object: + """Return the result of RPC *method* with *params*.""" + body = json.dumps({"id": 0, "method": method, "params": list(params)}) + conn = http.client.HTTPConnection(self.host, self.port, timeout=RPC_TIMEOUT) + try: + conn.request("POST", "/", body, self.headers) + response = conn.getresponse() + data = response.read() + except http.client.HTTPException as err: + raise RpcError(f"{method}: {err!r}") from err + finally: + conn.close() + if response.status == http.client.UNAUTHORIZED: + raise RpcError(f"{method}: the cookie was refused") + # The node sends an error with another status and a JSON body naming it, + # so the body is decoded before the status is checked. + try: + reply = json.loads(data) + except ValueError: + reply = None + error = reply.get("error") if isinstance(reply, dict) else None + if error is not None: + raise RpcError(f"{method}: {error!r:.300}") + if response.status != http.client.OK or not isinstance(reply, dict): + raise RpcError(f"{method}: HTTP {response.status}, {data[:300]!r}") + return reply.get("result") + + +def field(obj: object, key: str, kind: type[T]) -> T: + """Return member *key* of the JSON object *obj*, checked to be a *kind*.""" + value = obj.get(key) if isinstance(obj, dict) else None + # Python reads a JSON boolean as an int, so an int member refuses one. + if not isinstance(value, kind) or (isinstance(value, bool) and kind is int): + raise RpcError(f"{key!r} is not a {kind.__name__} in {obj!r:.300}") + return value + + +def key_id(address: str) -> str: + """Return the key id of a P2PKH *address*, checksum checked.""" + n = 0 + for c in address: + n = n * 58 + B58.index(c) + raw = n.to_bytes(25, "big") + body, check = raw[:-4], raw[-4:] + if hashlib.sha256(hashlib.sha256(body).digest()).digest()[:4] != check: + raise RpcError(f"bad checksum: {address}") + return body[1:].hex() + + +def p2pkh_key_id(script: str) -> str: + """Return the key id a P2PKH *script* pays.""" + if not (script.startswith("76a914") and script.endswith("88ac")): + raise RpcError(f"not P2PKH: {script}") + return script[6:46] + + +def scheme(*, legacy: bool) -> str: + """Return the name of the BLS scheme, legacy or basic.""" + return "legacy" if legacy else "basic" + + +class Chain: + """The reads of one node that the corpus rows need.""" + + def __init__(self, node: Node) -> None: + self.node = node + deployments = field(node.call("getdeploymentinfo"), "deployments", dict) + self.v19 = field(field(deployments, "v19", dict), "height", int) + + def masternode(self, pro_tx_hash: str, height: int) -> dict: + """Return the state of masternode *pro_tx_hash* at *height*.""" + diff = self.node.call("protx", "listdiff", 1, height) + for entry in field(diff, "addedMNs", list): + if field(entry, "proTxHash", str) == pro_tx_hash: + return field(entry, "state", dict) + raise RpcError(f"no masternode {pro_tx_hash} at {height}") + + def quorums(self, quorum_hash: str) -> dict[str, str]: + """Return the public keys of the quorums at *quorum_hash* by type.""" + header = self.node.call("getblockheader", quorum_hash) + block_hash = field(header, "hash", str) + found: dict[str, str] = {} + for _ in range(QUORUM_SCAN): + block = self.node.call("getblock", block_hash, 2) + for tx in field(block, "tx", list): + if "qcTx" not in tx: + continue + commitment = field(field(tx, "qcTx", dict), "commitment", dict) + key = field(commitment, "quorumPublicKey", str) + if field(commitment, "quorumHash", str) != quorum_hash: + continue + if set(key) != {"0"}: + found[str(field(commitment, "llmqType", int))] = key + if "nextblockhash" not in block: + break + block_hash = field(block, "nextblockhash", str) + if not found: + raise RpcError(f"no commitment for quorum {quorum_hash}") + return dict(sorted(found.items())) + + def signer(self, tx: dict, height: int, network: str) -> dict: + """Return the keys the signatures of *tx* verify under.""" + ttype = field(tx, "type", int) + if ttype not in PAYLOADS: + raise RpcError(f"{tx['txid']}: type {ttype} carries no signature") + p = field(tx, PAYLOADS[ttype], dict) + if ttype == 1: + if p.get("shares"): + return {} + if set(field(p, "collateralHash", str)) == {"0"}: + raise RpcError(f"{tx['txid']}: no payload signature") + prev = self.node.call( + "getrawtransaction", field(p, "collateralHash", str), True + ) + out = field(prev, "vout", list)[field(p, "collateralIndex", int)] + script = field(field(out, "scriptPubKey", dict), "hex", str) + return {"key_ids": [p2pkh_key_id(script)]} + if ttype in OPERATOR_SIGNED: + state = self.masternode(field(p, "proTxHash", str), height - 1) + return { + "operator": field(state, "pubKeyOperator", str), + "key_scheme": scheme(legacy=field(state, "version", int) == 1), + "sig_scheme": scheme(legacy=height < self.v19), + } + if ttype in OWNER_SIGNED: + state = self.masternode(field(p, "proTxHash", str), height - 1) + shares = state.get("shares") + owners = ( + [field(s, "ownerAddress", str) for s in shares] + if shares + else [field(state, "ownerAddress", str)] + ) + return {"key_ids": [key_id(a) for a in owners]} + quorum = field(p, "signal", dict) if ttype == 7 else p + keys = self.quorums(field(quorum, "quorumHash", str)) + return {"quorum": keys[str(QUORUM_TYPES[network][ttype])]} + + def row(self, txid: str, network: str) -> dict: + """Return the corpus row of transaction *txid*.""" + tx = self.node.call("getrawtransaction", txid, True) + height = field(tx, "height", int) + return { + "source": f"{network} block {height}", + "network": network, + "raw": field(tx, "hex", str), + "signer": self.signer(tx, height, network), + } + + +def render(rows: list[tuple[str, str, dict]], version: str) -> str: + """Return the corpus text, a comment header and then *rows*.""" + lines = [ + "//", + "// Special transactions and the keys their signers held at the block", + "// before. Generated by pkgs/primitives/contrib/sighash.py with the", + f"// reference implementation (dashpay/dash {version}).", + "//", + "", + "{", + ' "sighash": {', + ] + for txid, note, row in rows: + lines += [f" // {note}", f" {json.dumps(txid)}: {json.dumps(row)},"] + lines += [" },", "}", ""] + return "\n".join(lines) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description=__doc__.splitlines()[0] if __doc__ else None + ) + parser.add_argument( + "--node", + nargs=2, + action="append", + required=True, + metavar=("HOST:PORT", "COOKIE"), + help="RPC address and cookie file of a node, once per chain", + ) + parser.add_argument( + "--output", type=Path, default=CORPUS, help="file to write" + ) + return parser.parse_args() + + +def main() -> None: + args = parse_args() + chains: dict[str, Chain] = {} + versions = set() + for address, cookie in args.node: + node = Node(address, Path(cookie).expanduser()) + chain = field(node.call("getblockchaininfo"), "chain", str) + if chain in chains: + raise RpcError(f"two nodes on chain {chain}") + chains[chain] = Chain(node) + versions.add(field(node.call("getnetworkinfo"), "buildversion", str)) + if sorted(chains) != sorted(ROWS): + raise RpcError(f"the corpus needs nodes on {' and '.join(ROWS)}") + if len(versions) != 1: + raise RpcError(f"nodes run different versions {sorted(versions)}") + rows = [ + (txid, note, chains[chain].row(txid, NETWORKS[chain])) + for chain, listed in ROWS.items() + for txid, note in listed + ] + args.output.write_text(render(rows, versions.pop()), encoding="latin-1") + + +if __name__ == "__main__": + try: + main() + except (RpcError, OSError, ValueError) as err: + sys.exit(f"sighash: {err}") diff --git a/pkgs/primitives/corpus/sighash.json5 b/pkgs/primitives/corpus/sighash.json5 new file mode 100644 index 000000000..3b6cd7251 --- /dev/null +++ b/pkgs/primitives/corpus/sighash.json5 @@ -0,0 +1,52 @@ +// +// Special transactions and the keys their signers held at the block +// before. Generated by pkgs/primitives/contrib/sighash.py with the +// reference implementation (dashpay/dash v24.0.0-rc.3). +// + +{ + "sighash": { + // A version 1 registration, signed by the collateral key. + "4e84b507ff3dcd9819e9d04393c0a7b40c6267f46e531af08cbafd26720eb382": {"source": "mainnet block 1880065", "network": "mainnet", "raw": "0300010001905fbf115847aeaf1c297824e3a8de392b6d72eec44b0d48f4492379737911b5000000006a47304402200d24e7545203276172e215c9866634fc34b10b96318e2ce1de972496a0803fc50220153098dc72c454c06548018fef6d2246b17c76415a8b3609736d9424940c481e0121023f7cb709dff357f8db3d49a370ee3995982b1968f73ac283df627fe20c67cfa4feffffff01bda20a00000000001976a9141d19c43cd1e46597d5241b452397bae3924d6a4b88ac00000000fd1201010000000000ee5b3eb2b1d06a0655cae9b5fcfc1066e3fb765f0872fa2051a4d0ad537828080100000000000000000000000000ffff12e83645270f0157ec7e3fbaa1d4abebde61cb4fabd33d1ded76833353c587b5d16d7eae1da1462d16b12ff7a10e62247894166339bd2ec924e64423bda94ef5149e166ebb820a7fafa2a777500eb7d164a844c86d2d312b467755a4642700001976a914ce8d795ad00d2462e9b08324c3a5a5215a2aa0f088ac66c7aeea1df0bc7d7615e98a6da13e9da6cb57d33505cb547d2d9f5b56021e6c4120b40ba9842011e025c7382dda049160cd198e3ae6da3231a1ac04b13cf974370e1a2675352ec9cdcc2e2a6e2e8e283acdf0a4f48ede6f15ff8d58a3fa7b6806db", "signer": {"key_ids": ["ce8d795ad00d2462e9b08324c3a5a5215a2aa0f0"]}}, + // A version 2 registration. + "62ab2736bf85c1e1251cdfb95e8229b05d3b3fd97b39d9b9baf414c5f93474b5": {"source": "mainnet block 2080170", "network": "mainnet", "raw": "0300010001479e7816c1015375f7433e12834ca000b0612f4260596d45fad4ff155c07afcd000000006a473044022030f5933c277b9b58c4fc1ca6df6b1bd13d6716e326e925f283888a6a17980d2502202bac873420a6e2ac7b32a8bf7edc3261051f7f2c517f3c193f0485c6465a2f580121035ffbab73725c430b2904c10563007c5047257aae6caefcda4b47ed70c03b2f6efeffffff01e2747800000000001976a914b734da3d63094c95589fcf9252cd8d9c46eebafa88ac00000000fd1201020000000000bcbc1d4e69e413badfd090fffefba20f8b138e14f37c4bb37e987a58e257d2260000000000000000000000000000ffff87b535e9270f2adbcda197cd8c52ca57e09f847c3f9867f1a2c3b71248c0a1911bf424d9c51a080a7e1f4bc6e58cf538ccc8a03e8f88d478d4ce680d90e2a520c7b912d38dc0be24f15c5d00e59b569216472f7a5eb252da7ec4420e8f9b00001976a914a0728b0db25128468aa51a517f997413711d482688ac0451e27061eed5a13e38ae98c0ac401a0ed6555533b91d0478f1ecfcd7bd3959412013da74538988444fc5a32d1026a3a93163fcd1161a02c4fc77576f93d0053ecb1eed952083e4f16b17aa788f467a3f67a6f399e5cd7cca6b3fb675f548e1da3f", "signer": {"key_ids": ["d6919a4ddb90ba6922d32e3d02b7dc860fabbefc"]}}, + // A version 1 service update, signed under the legacy scheme. + "49a4887a2e7fc0bde104fc91478597b356520a61e6d27cd08a945edd5ceab3ca": {"source": "mainnet block 1880022", "network": "mainnet", "raw": "0300020001fb7a3ee9b468880ee5b0625e2d8a95cd280dc4b4689fec2524933232037fd177010000006a47304402201913d2ae408c4bd0dea90cb2525f0f411f4b2fb1025b1282765092a442b6fc8a02207b385864bb3cae049758d8cc9fa4243c418cf4471ca5af649fb4cfd508a4649101210388d662058919c63c686d34ba0073e73d14f9e8440fb56aa55bbe048d4d4ab669feffffff01866f6808000000001976a914dd3f8c5d1cad61e5f97f06df78f923abfe45e60d88ac00000000b50100e9f81526f4edfcb4e326ec16336fdd104364b71695b79f594c712d02bf372c5400000000000000000000ffff8ba283c5270f00bd0fae7602e777b84d1553c049e18c9da20d4fc5929ebcb002232c29475e16d7012caf908436e6d6e38ed2ca60d16f047193f7cbe14684753a122b76526cd1b19402cc02183fbe5a3a6767247ccbdb2308e4440be2f71696d9365cd1271779d59235494a0549329c6576eecc5d05d75e308910d65c6c8652caee71b7082f5713", "signer": {"operator": "139799cff261e45118408dbd9d70b8f4c9e0944c5f954fcda731a8050546951bf7cc8dddf1375e773836e146649c2841", "key_scheme": "legacy", "sig_scheme": "legacy"}}, + // A version 1 service update, signed under the basic scheme. + "764460fc0d3303f5de75ff938bc397407e46574af6f72d054a31c81d3ea26baf": {"source": "mainnet block 2080058", "network": "mainnet", "raw": "0300020001e943c91df76f82097e2cd5bf6cb54151e14659ed58c8ab4f41902f7a54552803000000006a4730440220528816035e88c354649d224825dd71af8290c04950a83f9edede28b048aed795022074713a646bfadbf4fd907ff4df23c1d2b259f915ebaa6a404040ada4935cc9870121029e8fa911e061f390a61d7b8da4d157d043ad6654feafb5d019c6506ba62021fcfeffffff0139e2a200000000001976a9140ec44517aee1edcedee375c49a11fb316f96f35488ac00000000b50100c7a41f4bfc062f25490a9e54d01bd46bf337696d64b917f4abd3345cf1f04f1200000000000000000000ffffa5e3f07f270f00b745f9c60a20c95f649e5729549a9e94d446754eda84488e7ab8a557f097300c81bfe80eff3132aa2210d4d55066cd5f27da5c0315e9f48e40b8182a7893b0e8cfc0507d54f6a829464f8838a6f453c30c344f466c67d3535b358617ed1dcb5352850a7acecf679b2d15ef38284bdfc6929a6137a137eaa6d3a2bf1708ffcfa5", "signer": {"operator": "0bc603cc70cf7d244ee7ead632117381de28549750877e45eef3dd0ff5329f9ad5ad61553cff797dd9ca2985ec829e2a", "key_scheme": "legacy", "sig_scheme": "basic"}}, + // A version 2 service update. + "4e0d18e300d2ea0db81cb334aac6098848b7026439a43c78a90add2ca9a3eb01": {"source": "mainnet block 2080001", "network": "mainnet", "raw": "0300020001028aef772e7a0776d3a483e4791edf2e016def674387e741eaf687a70b955c5e000000006a47304402201046a941a21e90f85579ba44b5cd0acf436a8899b6bb52e9cbcef3e0e7f774c602204b0840779a1b49fd2643a06d2559af6164ed5dec2926af038cada59e565c3b23012103f0558111d9a501bc994750d365716e2dda57f6c09c09437ef129fdd8383121a6feffffff019e830100000000001976a91471eda3c45a898eccd963bd8cd41125b584aac76788ac00000000b7020000001deb35a3db9b883ae1bd04df08da5dbfb284a02c4fee0bcd027dbfc1db056f8e00000000000000000000ffff5fa9b547270f006749373e5eb0d0b15f0601e7aeaa1a95f4044ebde49dc12c95f52067ccfa52b892f90ea1ac7346afcd8c59a1ea8ac8c4a9023188edaad5b799e68b6df116249ea12c384cbcfd41168aa168ee245b994a0225afbeab1578b7ac09194c3d02589b27dcc242a4f6683d12451bdb1bff7d22357c1c22149a5225b7ee05b12b38cf79", "signer": {"operator": "806bf58ca925d9f9ad9a0291f7df2d8f19e73185c88ba5a4a39fa9fbdc7319d48147a6bb98b3114cfb60244723f3090e", "key_scheme": "basic", "sig_scheme": "basic"}}, + // A version 2 service update of an Evo masternode. + "9663a0f0503fdc680b05ed0d1ced0131695f1732be32a45e4d4bc5085865473d": {"source": "mainnet block 2083177", "network": "mainnet", "raw": "030002000162ccfa3f8044116b10b4f36bd5b2a0a9790adc6fdcbb433ba3388b3c058cb024020000006a4730440220246f18794c9154af702ac79994f1e9a61a56205da71fbe67275ce80f48123dfe0220710639b4d974040cca6695387e75a94e061b73d1edf7a4206c8b1f11e6738a39012102b16abe19fba5e255af7c7f435b76368c7360baf31019688e13ee5f9d0c989fb6feffffff0108850100000000001976a914081cfe08ce7117ca279620df4a320ba45fc7545888ac00000000cf02000100293358a5dfbb71aa343c39c02dbd2d546c104e29df02cc084ac97208bb33876900000000000000000000ffffd418634a270f00ed03fbd5faab0943029674a7ddda91f6fb1f6bead8b4df112b2243f655d6e29f766d864bb9a72a8cff207fcd28ae3dde961c16c12068bb01b2eef42c374d46851cd2edac3e36e80c10d412eb85ae902c1117b14e6e1be0a4bad84e67560625dd7d028e2c8d74c3e618983089dbc3580bff5d863235748cc81e174426cf6d52beb3e265e66aec3cafe04815c4cebe2df4e0b1a833f816d7b1", "signer": {"operator": "819a0396e0dbfcd22d5c992179965316bcf13110a1b70a084511dc38870ab73056b50d2a8f1780d61cfe28c13e013f21", "key_scheme": "basic", "sig_scheme": "basic"}}, + // A version 1 registrar update. + "6002c6e304dc609d28bdf0da5304ca47394152f21711d1ea1687c40dbec216de": {"source": "mainnet block 1880174", "network": "mainnet", "raw": "03000300016b7ea5753d0956cee15ae265d82bc5ee738778885b72725000e47e1127bc4d58000000006a473044022066a3202a36ad7603e8e9a5c2e5972b3d33920b55082ee6c0fa28bb8b60b1c1920220427bdffbd09a235f3e0163af0f51b6331aa70781bcca63dd76d6a37fcea7ef3d0121023f7cb709dff357f8db3d49a370ee3995982b1968f73ac283df627fe20c67cfa4feffffff01b8c50900000000001976a9141d19c43cd1e46597d5241b452397bae3924d6a4b88ac00000000e401003b84cfc01b9b63d3e78ee32aced6e667aa1e68a42ac39b1ac7b41cb19c7e592000008732cceba8f9e577bba1846536eca96c29ee22d901848b850e5672ca881cf3e0dc9e5f08190c345c7c2862b460dac595d3f88d7eecb1774f91ee6a3fd9f05ce998270e021976a9143305393f32f8323fa48b22f4cccb78665ecb470c88ac2e0b0df77a33e1c94b78853d23df13807d7861bf2f926a636e38c0c418a9ed42411f59364cff8474270f5f2e8f659df83ba4e2c477e52e9bf956297e04dcd25468d6635debcc742f6c78b16292d3d703f578f78fbb66af1703620d548c1bec1bbf5d", "signer": {"key_ids": ["2d6e5e8e37810cd3a229a08c229c4903786591f9"]}}, + // A version 2 registrar update. + "39c7568aabf91fb8d27d3146aa13e16118c0d168a903f2c116fcd02132466ce7": {"source": "mainnet block 2081970", "network": "mainnet", "raw": "0300030001624419d5b64fe58531862bd8a3d3e2f3192d699dc01490236a9f10091a907788000000006a473044022042c3659bdb50d47427924763797bfc252424bf0c421fba4c42d3865c4388ffb1022060ca5323f2102f5e30008101f694fdf41e985329e12d6113ca97a38088dd3b990121026cebe46a1c8efd271309d55977e3a5fec79a17810e6ff931207ecd5c93cbe8d2feffffff01e46e0000000000001976a914cbe510011edaa3aea70d306674c0fb749890b96f88ac00000000e40200534fbd0ef736db4f8f509503d23c1abbeac1a96125ccb65b731f1fd84a1d5ddb0000b911d701a1d6c11c32414c577e244ba209b1ccab558f188919d82faba5416a3770f6351eea62c78502259c599c2a224b2b6cc6d205e25cd98b2cbdef19f8ffe91ee1fba81976a91461ba0f43e13c1cdf5bc81db6bc46fdaf162f038c88ac7bc5d0a0a88d5497b6f5c7e7bdcdf0642987eb075cdac56d5d3eb140e1464b40411f1f7be5bf560298d7cfce5c3e116942508cc7280022537fa944ea0dd3519c19ad5126cb2c0090a8dd553c1ff286b03162109a043112e7001aa21fb272e64bba85", "signer": {"key_ids": ["2b6cc6d205e25cd98b2cbdef19f8ffe91ee1fba8"]}}, + // A version 1 revocation, signed under the legacy scheme. + "1b521e8f348e2a01969e4a9aaa377c3ce350dab158a7add82eac6bba1d090594": {"source": "mainnet block 1880534", "network": "mainnet", "raw": "0300040001802393b1d129be9b4748b46ac458afdd6b2eb37e88aceefdf14bf45ca6076f4a000000006a47304402206910148b5d3133a77a8107e3b899348a762d2bcd0fd1cc07769b212ebe669cf202202d43344f76cf7d74748ec81567360eabaab98624777f60dc6b2e09ce1e1fca610121035ffbab73725c430b2904c10563007c5047257aae6caefcda4b47ed70c03b2f6efeffffff0143747c00000000001976a914b734da3d63094c95589fcf9252cd8d9c46eebafa88ac00000000a40100b0d2548649d63e46da5bf131b5eb44f8af2b24a43bddc6affccd530ceed098a301001be75a5838e01f91665d0b57ff42d658f5ddfed304afbb82792e0319f809e5f983e0e7ce5da66d088e853e5833302b6822016d539cbb2df1b549fcf2fa0b419f7dc9c7ba326e00ffc426078dbacff3fd0268e967d67a704f22256b36fc936ba9c2ed03690074db10c204ef0f2400a27a0f783fd383b75e8e9dbb9358bcf9c716", "signer": {"operator": "86ef5b591905e1c2437ba419f3f921b0b7ae71941cde7b423dd00099866fae178a90cb93d8b6dc0054b5e0706ee7150a", "key_scheme": "legacy", "sig_scheme": "legacy"}}, + // A version 2 revocation. + "21b5994a3cd21df0568eda024e15b54f380f914a2d749be96d00b31a18073767": {"source": "mainnet block 2090384", "network": "mainnet", "raw": "030004000175e45d7da799975fe9ad401c20701c74b896f6046a4ad24f1e9cc85d8be7e808000000006a47304402204a772b26eee37cdca94022774748f55e92e039985249754bdf52be3febf378b00220446b8d74a1f5049ee1f0ed2ad67a6b1265179846b82c36ec2898bb123f33718d012103e10e8542bc703af92dc7c66a4a471f8101472b1a37b83a01309227ad2f7ebf14feffffff017e0f0900000000001976a91493b17c6f50f75069b93864675c7cb1e9b9dbf3cf88ac00000000a40200690af108df755347ddc67974b907bd98aac3875c8b581b658db3c86009e9a7d7030047cde74d5d1c72713134ceecf0565e02e2a06656490cc2afe4c5fcbb031d1a448ec841e9658f4b0cd3c90f00e1b60c2f1d0c876a7f7f9829b25b7f0da9f75d729ecef0456b92533d7b45466b4be78b8110e336bd135143fb1cfd8046e04cca7d3c04d6c158b815da0252dfe7cd79ccfbef418a436999eb1a0aa6b66ef7b4e4a3", "signer": {"operator": "b4f41d890d91e04e306df78d54add58f5a45f826454b38de2550aad0d9797e18e246164b0592cf48f6ba5b6c1a37346d", "key_scheme": "basic", "sig_scheme": "basic"}}, + // A version 2 revocation under a legacy-encoded key. + "cb11eb2b4f2a5d2b4294e8c2965478f037dd36d90a0d4734c0e3e868a2f4d024": {"source": "mainnet block 2089774", "network": "mainnet", "raw": "03000400011c4e77c7d41e350daba2a52fac9b427a81ee87e37b0b0930ece0ff5a9c73276e000000006a47304402204d5b26794718096426cf162b4ea0ddfe71a1f18c6fbb604e027e43b18b41e7ff022076d3db0920a9225d77e445eb330dbb2cb6615c3a6293d5969b433be0c2af65ad0121035ffbab73725c430b2904c10563007c5047257aae6caefcda4b47ed70c03b2f6efeffffff01fa4f7800000000001976a914b734da3d63094c95589fcf9252cd8d9c46eebafa88ac00000000a4020014cfe539dbf5f1c2c94a239e0cbe8ed1149978dcc34e22f13f89e832cdd34a130100d5d730a4a2abc073593f02e547c56c6c860acdd063d6708f9546c3a3ee33c2a8ac4a0b47e2d8d6861c5125d17e25cf0f2ac28069a80c5221f50f282aa207e78d2fa93424702e090a174f5892336c1247181944296d737b7c7b41b19a81c02e34eb511d9189cd68d3158000912317344513291a5a6f00dc0642186b10cd87bb2a", "signer": {"operator": "082ee6bf5a47cc14ab839b81e3dad4ba8bd0ac74f68514536108bacb16d3d49181c9086c2da6ea3dd52ae5d1871121c2", "key_scheme": "legacy", "sig_scheme": "basic"}}, + // A version 3 registration. + "13ccca675ed8a8a788693f46191e7237e2896701ede3058c20263e1b2343923d": {"source": "testnet block 1578185", "network": "testnet", "raw": "03000100013c7ce42cb2e41faa5980ae306563df345ceb182a4b4726349bb5553749d27027000000006a47304402204f239b22bb793a2ad1f0da13269484b1f7644e8ac39dc8a71043e990215517f802202686ddde448a508ca41a032de1f05974b27440a2712a6039173c4d76422cffda01210368037eedf9974ae19dbf7afad02f781ebf59b6e1ab07e9d27375604e0ae55e70feffffff0192ed0d00000000001976a9140f85adbdfdf6f484f433e3c756430b85297a97ab88ac00000000fd1d01030000000000f02bdee9b0c994f184b1e83a731b1c0b0afcecf3aa1dd5376be21ce535292199000000000101000101010455d1f32a4e1f50c455d6408cbe0ff9223ea627d7c1330587ec1e9321b7d8d72b12d10b413673a65b81d375bd0cc1b7f05f027d974d30209452167e577eddad6a76ac737d1563c659d1e1804d680fe032b74dd93132e8ffcfc10dcea976b00000011976a914482551fcc51ba10000202e7d6a7938cba1cd28ef88ac1027000000000000000000000000000e306067b2a7ea73fd4fa6cf4263241d7d7e2eec1f9a3f74f6584b057eac8078411f760624efb2010edff7624e8e13ad95ab27d77e9b28cfd3a7e024cc6cfc6cf95b093c2aa7a91b2678cd7013028c434bd42efe0caf45bdd01c156b385501deea1e", "signer": {"key_ids": ["311f538ddddabc9c8240cf94448ebf9d4983d908"]}}, + // A version 3 registration of an Evo masternode. + "2770d2493755b59b3426474b2a18eb5c34df636530ae8059aa1fe4b22ce47c3c": {"source": "testnet block 1578168", "network": "testnet", "raw": "030001000106ad96cfe67c0fac8f4a54be91fe086c9da510bcf6456ee2554cf45018210f4e000000006a4730440220445ce1f55571ce9b924cb68f7857464bbc918c000c425de9f1ac49c43c470162022056c5481adf9282d90ff01398ffa7d0990e4f21b536195c538651c13fe8fa5a9a01210368037eedf9974ae19dbf7afad02f781ebf59b6e1ab07e9d27375604e0ae55e70feffffff017fef0d00000000001976a9140f85adbdfdf6f484f433e3c756430b85297a97ab88ac00000000fd4701030001000000372ae26ee512d5fafde50b8411ca21080a868d55640cd4d1e5e1d5280f63593f010000000103000101010455d1f30a4e1f010101010455d1f30a8f30020101010455d1f30a05a32351d825841fe0b86f5d5e9b4de6e50dfe831f9ab03a69e21639859a0448d9ad97ee33d9c7807adc1aba1791c759b87aa81b99d79c19ba8778cdda6533ce9f0534a8392f0c51904ec5f4eeeb8d54b4f7b43c67a9d7a202ff0000011976a914482551fcc51ba10000202e7d6a7938cba1cd28ef88ac10270000000000000000000000000029b0ac1ebdd8472b5d4dc4f628e4cb3e70167440e098871bec569eed8658abee0f4f47471c554804e4ab6ec7bf6fd289c438c6e3411f95a5abeadb2a012c78337172a41c8315b5e9a9e38e458338689ce4edc4a6a12a79330d2ee5298a899a80d4ecf42e3501229a81e7f04592f43bccd8ce11b52fde", "signer": {"key_ids": ["cd6bf562acba01f16fd0bd5ace0730faf18ac05a"]}}, + // A version 3 registration with shares, signed by each share owner. + "8699ef5afd141f7b02f170db4f4875468ace2f6c84c6889f3e0280633ba65f40": {"source": "testnet block 1583312", "network": "testnet", "raw": "03000100030e0caf8673c3e49b6d68085e300c4ad3ec5862772a2e3de20b1cc6d979282dbe010000006a473044022010975c2d0dfec5dd7b1c9ebcf4e19be30352c448bcdcfb24e70f8a2e5745d2890220406fd55e15b39e8b8dad2e5a3bdbe56461c1a8a6f907b94b396e32e62b8548e4012102d3cc14fbf267f63cbdd37e3d7c84f1dab6d6a798c5eceb76937f565570f585acffffffffa56857866c0cee555fdee0506e8552ea3d3e4ad117641bab2c1212f2beecb387010000006a473044022060b0594b98454a7458db667126a87f84f0f4288286a1fc71a91e7433734b126002203df71baf97923c050a8ca490912ea77fe12f51b0eb7d4a172cd913a643d0fd5c012102a664bd6871aa3371abfc32249f12816a44eb98c8ec668d7dcb47eec9627adb0dffffffff0e0caf8673c3e49b6d68085e300c4ad3ec5862772a2e3de20b1cc6d979282dbe000000006a47304402200165f5a76ae3c0cbc95a85119ba9d21d1d8c9f6d627e8d74df6c52c67a40e3500220720916c462279af79c56a474f37ad1bd183c734c037774a8785b2c5483622fcd012103a35be6563f7004612c609478bc4be06b6d861893345b8fa1e2ed0942e3c39ca4ffffffff03ff68f902000000001976a9142c876aed13e14bc54b3e83eae7d9847c5c04070f88ac80f0fa02000000001976a9147acd5755371a014306bb5772ba738a56268782b788ac00e8764817000000070444534843755100000000fda50103000000000000000000000000000000000000000000000000000000000000000000000000000200000001000000000000000000000000000000000000000000940c2f91e087567fa1ca3eb22a52ac374a0fc32f103e4bb31a8b1aaf3daf60085968adb4e0cf64033a8d0645393c97cc8217be2c828470a8d4d5ebbb7435a8f47c16106f90010002005847f80d0000001976a914370f5835c82007e82339b42ccfd7767ae6220ad288ac005c122f49bca30a387c8b851642482eb247ddca3700902f50090000001976a9149b46ddc488343060485292c1ef17c92fbe0462c188ac005043a17f22496a934848fe6d93c679c3c85fc0dc20507720e8779ca1044e4df6c1b9f532ab9610c6fdb179d37fd42bd7ad36a9981e0f5c13cdcc739ef9bbe27d9e02b8d0e544240fbc89db2f33caba4dcbf1b86dd61f4ca65370c8ca51b8312582b3250bc65f501c3562d23702dd744f4eaa173ccb661a1572c7b0e157640dd5b351acbaeda417f1b9e12c79db56f3c2230d5169d18b50cd00000065cd1d000000008bb69fc51d1e6a923f701a10138e433109071435c9923695a5611cd141326a9300", "signer": {}}, + // A version 3 service update. + "d0faa9b0748eb837f5d55f6aad7d3e83352cf69de161521e7fc37fda877ba098": {"source": "testnet block 1579049", "network": "testnet", "raw": "03000200018e8b4dea67509df4c39c4697f6bfb8e68bbb460d3d8b32c9cab16543a82fd720000000006a4730440220349f96398d556fbaec3ed9e0b37eb0a6a202bcbf012354034062b11d503bca7402205e6ff7820151321953ceffb95256cd4086b75328e5b5c190f3fd42683de5d13f012102325e83cb1285c92eee0ab95a95e51ec81431bf8311384fbbb3bc2fd5ff63424afeffffff014aa10e00000000001976a914dbe0812a19d7e3e8e168fd060e8680fc6a05d2f288ac00000000b203000000b27541f9766ea980fa9df7c3b41808530509cdba5f2d52238628df32b8ad56a3010100010101044e1146af4dbb0098b86264de16a59ad62d848a7e953c5a6a68a523e4d1eadbd68a42745ab60dcfa0e0459b98edb459d9431da6e8f84b7eefa4ee6736d97f2ff0708f3d0800b036ad27cdab33bb031762a9fb09a433d68b13d713d8f0e0f0a046bdeba3831c8228c549614374d5bc78ffd74973b923e3848883a5feee3f4ced04d60471ea207b7f", "signer": {"operator": "adad41e17d64581f58fcbc8dff2845a9a10c2e57db782dc5fd41a175729e59048dc3fb82d9f0620eeaac3eacadced01a", "key_scheme": "basic", "sig_scheme": "basic"}}, + // A version 3 service update of an Evo masternode. + "0b9ef4f3b1607841c5f98485ade8f1bdf4d5b8127a24343a53d501bed74b525c": {"source": "testnet block 1578496", "network": "testnet", "raw": "0300020001164941f480ccf7c14794cd957f724ceae4ef7f0fb0b18a7fb9814abf6285e3c6000000006a47304402205e379d12945f77970d713bf7169fa1527216f0982ad4c0a05fea1e9a012b7b5502204dd4971f7ffe6e5c3d3ba95c63c24e00b090237f17f5988cc1b2a1d3585d54eb01210216a3c19bb2333bc4c3addaa1f1118c42fd060d3e47fe6fd4932b437363f54f2cfeffffff015eea0e00000000001976a914000888b285fe4aba88b8bed38e9ce5a4a856ad2488ac00000000dc03000100800b5c82dde5ef1694b17d0a93dfd03ca8a49c1c31512457e78396f79fa23c7601030001010104a223f3554e1d0101010104a223f3558f300201010104a223f35505a300e1e72e7b664391a00b68f6dfc6a9e20ee49cdb3f353c360e94027e74c21e25dfc92e0ebc2cf6df05de73b3a9821e9c590420d033997ab3a46cdcaf52d48e9eb601e05430f11f678d04678dc0790fdb8702d7ddf8834c786178264e6e90d07df8e3bbddc31212a0eb020103e35c60edce0aeeb8bb214a05fad022df5dd267d280043a8ef02810d0a9267a95aae2df21a3a754b056", "signer": {"operator": "ad99da4a07542b221fa6f2335ab2a1071cad6f2dbae230fe82a619b07d039b6270632272ea7269dc5c8241eef139f57c", "key_scheme": "basic", "sig_scheme": "basic"}}, + // A version 3 service update under a legacy-encoded key. + "7209b5bdb6881a69029a89501392b0ef05ff8ca83be7df03d7a247241b7ac4e7": {"source": "testnet block 1579842", "network": "testnet", "raw": "03000200014082f48d8a79cfed537e8197ca7626952ef4b8511566f32cbdad5137625dcd63000000006a473044022038fd8df3cdf796d56be80a6e22d21863ed149cb7744c925e23efdf05f9e379fb022062dbb75f1f790455ca52e85a707a447508c18a7ee15de0bc341294d61c164e9001210255f0bac6c049644609d2a65e6f2264ba03807d340fcd9733ca4904e968cc4ce9feffffff013091f505000000001976a914456ce31778e3778c88a87ac36a1a8bd4aa5bdbe988ac00000000b20300000002769272e89a947728aebb2b1ce38a35e47ea334ee53fe29e8a6734cf439ee0c0101000101010444437a354e1f00b57ce722255916018aba734881eb2b9391a5393af6a573c09b3fe377e50634d2b9614c90e25ef6af5881393901827a2162a4abb0a5b42967505320e93270b0c181ec8ff253a24ca5291d04c497e102d60c1b8b83d5a49ba2ed0b50ec7ff455f62992cf425b5ff90e98d9a832a1f12d8abfc15bdce4bee96d9f0b94523cf324c1", "signer": {"operator": "880f24b5e040dcbf86c3f468dd28bf45d9e41fbcd127fad56669d9afe358dcdc26e42f0f8b19997b1741dbb99c553aa6", "key_scheme": "legacy", "sig_scheme": "basic"}}, + // A version 3 revocation. + "4e0f211850f44c55e26e45f6bc10a59d6c08fe91be544a8fac0f7ce6cf96ad06": {"source": "testnet block 1578068", "network": "testnet", "raw": "03000400015e1fc0bfae7beed6df5a36b7c21d8984202ecd22763a9e475c14e4c3aa204d04000000006a47304402203c0e4d07c274180ed64b71ff03ca7ee465d55fcc5bec2cd063554c1b76bdcbee02205097f29c81a4dc764bd003c3fab56911f4feb2fc5a6cd496b16e04f18dd8107a01210368037eedf9974ae19dbf7afad02f781ebf59b6e1ab07e9d27375604e0ae55e70feffffff0195f10d00000000001976a9140f85adbdfdf6f484f433e3c756430b85297a97ab88ac00000000a403005e1fc0bfae7beed6df5a36b7c21d8984202ecd22763a9e475c14e4c3aa204d04010036f1ba69a89f35bdec658106cd8d11e58ae48c2d1274f2c6ba14a343ddf828a7978ee11937eb3534414217b54301ac823fda0964f8ba67ab1c3a7171271c184226673a8cadef01ee7dc1bad302d5008c0a771abe16417a6077d0615118f4e4471ada150fe4fd4cc464cbf7c3f58b13b06a921e1199cbbe61adfe097f1c8447be", "signer": {"operator": "b03a69e21639859a0448d9ad97ee33d9c7807adc1aba1791c759b87aa81b99d79c19ba8778cdda6533ce9f0534a8392f", "key_scheme": "basic", "sig_scheme": "basic"}}, + // A hard fork signal. + "46a47fe65c9fd29e9379f3f74020df33dabb1d4095c8da6b1fa05e508b74a491": {"source": "testnet block 1565132", "network": "testnet", "raw": "0300070000000000000082010dfab03beecae3ec79691a966f8a37a836dab21a409f1ee39bfe98a26f03000000a3520c90ae1a3aa2b750be245cb9eaa1c4be78f0ee43f46b56a0d319cae9e76a87c5ce23d93e24b7484b93288bdbc7e70610d04c7d9ba4f30dc3b71b58baf6436752ffbace4c79da3e4d6de87646610a8cff9001b51d768c4b6d8a4ddda6f01c", "signer": {"quorum": "a1620ca2f42b36c8ef6c248f22153b0a68589c969841971f2e46208c562b8d9c1882efecac7ca6848ee2810497ee9732"}}, + // A version 1 asset unlock. + "cb39c38505c359a653eb15106c9532104f24751d53f8e9abb76e3fb810a7d5b3": {"source": "testnet block 1578005", "network": "testnet", "raw": "03000900000102f35e01000000001976a9147ff380fad990f373ed92c41433395006c1fe12b688ac0000000091016408000000000000be00000014141800863d622fc805c73f1dc89a18ab30ed04f736f4cd4b2328e460bd2ed70501000084651a73098bbb4c45e978a284819bbe447d2cbd91780641017170216c7fa722467c29b14c0393e48f3e3010d2ca0a9402b7a9bb736f4c399194e627687ff62c582769ae50076fde741c194932ff8f68d30621a42db5f8bd2ee8182f68786357", "signer": {"quorum": "899ff54c65ec9d3f169462b9fcf85bdcafbda360941c1138d480dc449ebf3f4e6280fa6392f54645bed36b3416572f92"}}, + // A dissolution, signed by each share owner. + "d0b92723bd36450c2fcb51ef0886818ad40a09c07115dd55bc659a2546fa54fd": {"source": "testnet block 1583318", "network": "testnet", "raw": "03000a0001405fa63b6380023e9f88c6846c2fce8a4675484fdb70f1027b1f14fd5aef99860200000000ffffffff0200902f50090000001976a9149b46ddc488343060485292c1ef17c92fbe0462c188ac60d145f80d0000001976a914370f5835c82007e82339b42ccfd7767ae6220ad288ac00000000a70100405fa63b6380023e9f88c6846c2fce8a4675484fdb70f1027b1f14fd5aef9986000002207468f204e6e698fca4766f4229e595b979c5ac866c7fb772c8cd6c554289fea420ed8884f4258faa78e83ada5d031d764b1c1827b28389b54feedc1f13f982f21faadc59d99905d22389096db2a12ec24e75148383f004a86350c7553b1c0edb115a3912a51f6ad8ac23202b585d9ddb65653022c0e4a5cc1a00e4d719f78e5bba", "signer": {"key_ids": ["5c122f49bca30a387c8b851642482eb247ddca37", "5043a17f22496a934848fe6d93c679c3c85fc0dc"]}}, + }, +} diff --git a/pkgs/primitives/src/lib.rs b/pkgs/primitives/src/lib.rs index 551020430..3caf04150 100644 --- a/pkgs/primitives/src/lib.rs +++ b/pkgs/primitives/src/lib.rs @@ -41,7 +41,7 @@ pub use codec::MAX_SPTX_PAYLOAD_SIZE; pub use gov::*; pub use payload::*; pub use provider::*; -pub use sign::MESSAGE_MAGIC; +pub use sign::{llmq_sig_hash, MESSAGE_MAGIC}; pub use sptx::*; pub use support::{DynBitset, DynBitsetError, DynBitsetIterator, RevocationReason}; pub use transaction::{ diff --git a/pkgs/primitives/src/payload/assetunlock.rs b/pkgs/primitives/src/payload/assetunlock.rs index fbaf5baf8..093b25dd0 100644 --- a/pkgs/primitives/src/payload/assetunlock.rs +++ b/pkgs/primitives/src/payload/assetunlock.rs @@ -7,8 +7,12 @@ //! AssetUnlock (type 9): Platform to L1. use crate::codec::codec_payload; +use crate::sign::{llmq_sig_hash, request_id, tx_hash_with}; use crate::sptx::QuorumHash; +use crate::Transaction; +use dash_num::Hash256; +use dash_params::LlmqType; use dash_pkc::bls::BlsSigBytes; use dash_types::type_id::{TypeId, Unencodable}; use dash_types::Checkable; @@ -16,6 +20,9 @@ use getset::CopyGetters; use core::fmt; +/// Prefix of the request id of an asset unlock. +const REQUEST_ID_PREFIX: &str = "plwdtx"; + codec_payload! { /// AssetUnlock: Platform-to-L1 (type 9). #[derive(Clone, CopyGetters, Debug, Eq, Hash, PartialEq, TypeId)] @@ -72,6 +79,28 @@ impl Checkable for AssetUnlock { } } +impl AssetUnlock { + /// The id of the signing request, from the withdrawal index. + pub fn request_id(&self) -> Hash256 { + request_id(REQUEST_ID_PREFIX, &self.index) + } + + /// The message hash the quorum signs for this payload carried by `tx`. + pub fn msg_hash(&self, tx: &Transaction) -> Hash256 { + let unsigned = Self { + quorum_sig: BlsSigBytes::default(), + ..self.clone() + }; + tx_hash_with(tx, &unsigned) + } + + /// The digest the signing quorum of `llmq_type` signs for this payload + /// carried by `tx`. + pub fn sig_hash(&self, tx: &Transaction, llmq_type: LlmqType) -> Hash256 { + llmq_sig_hash(llmq_type, &self.quorum_hash, &self.request_id(), &self.msg_hash(tx)) + } +} + impl fmt::Display for AssetUnlock { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "AssetUnlock {{ v{}, index: {} }}", self.version, self.index,) diff --git a/pkgs/primitives/src/payload/mnhftx.rs b/pkgs/primitives/src/payload/mnhftx.rs index 425c6ae86..f79da7003 100644 --- a/pkgs/primitives/src/payload/mnhftx.rs +++ b/pkgs/primitives/src/payload/mnhftx.rs @@ -7,8 +7,12 @@ //! MnHardFork hard-fork signal (type 7). use crate::codec::codec_payload; +use crate::sign::{llmq_sig_hash, request_id, tx_hash_with}; use crate::sptx::QuorumHash; +use crate::Transaction; +use dash_num::Hash256; +use dash_params::LlmqType; use dash_pkc::bls::BlsSigBytes; use dash_types::type_id::{TypeId, Unencodable}; use dash_types::Checkable; @@ -19,6 +23,9 @@ use core::fmt; /// Number of version bits available for signalling. pub const VERSIONBITS_NUM_BITS: u8 = 29; +/// Prefix of the request id of a signal. +const REQUEST_ID_PREFIX: &str = "mnhf"; + codec_payload! { /// MnHardFork -- hard-fork signal (type 7). #[derive(Clone, CopyGetters, Debug, Eq, Hash, PartialEq, TypeId)] @@ -67,6 +74,28 @@ impl Checkable for MnHardFork { } } +impl MnHardFork { + /// The id of the signing request, from the version bit. + pub fn request_id(&self) -> Hash256 { + request_id(REQUEST_ID_PREFIX, &i64::from(self.version_bit)) + } + + /// The message hash the quorum signs for this payload carried by `tx`. + pub fn msg_hash(&self, tx: &Transaction) -> Hash256 { + let unsigned = Self { + sig: BlsSigBytes::default(), + ..self.clone() + }; + tx_hash_with(tx, &unsigned) + } + + /// The digest the signing quorum of `llmq_type` signs for this payload + /// carried by `tx`. + pub fn sig_hash(&self, tx: &Transaction, llmq_type: LlmqType) -> Hash256 { + llmq_sig_hash(llmq_type, &self.quorum_hash, &self.request_id(), &self.msg_hash(tx)) + } +} + impl fmt::Display for MnHardFork { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "MnHardFork {{ v{}, bit: {} }}", self.version, self.version_bit,) diff --git a/pkgs/primitives/src/provider/prodistx.rs b/pkgs/primitives/src/provider/prodistx.rs index 7dd379402..cc3c83967 100644 --- a/pkgs/primitives/src/provider/prodistx.rs +++ b/pkgs/primitives/src/provider/prodistx.rs @@ -7,19 +7,25 @@ //! ProDisTx shared masternode dissolution payload (type 10). use super::share::MAX_SHARES; -use super::DissolveSig; +use super::{DissolveSig, EcdsaRecSigArray}; use crate::codec::{decode_list, encode_list, impl_payload}; use crate::prelude::*; +use crate::sign::{sha256d, verify_compact_canonical, write_tx_header}; use crate::sptx::ProTxInvalid; -use crate::{hash_impl, TxHash}; +use crate::{hash_impl, Transaction, TxHash}; +use dash_pkc::ecdsa::{EcdsaError, ECDSA_REC_SIG_LEN}; +use dash_script::PubKeyHash; use dash_types::codec::{BaseCodec, DecodeError, EncodeBuf}; use dash_types::type_id::TypeId; -use dash_types::{impl_new, Checkable}; +use dash_types::{impl_new, Checkable, Signable}; use getset::{CopyGetters, Getters}; use core::fmt; +/// Prefix of the digest a `DissolveSig` signs. +const PREFIX_STR: &str = "DashSharedMNDissolve"; + impl_new! { /// ProDisTx: dissolve a shared masternode (type 10). #[derive(Clone, CopyGetters, Debug, Eq, Getters, Hash, PartialEq, TypeId)] @@ -62,6 +68,48 @@ impl BaseCodec for ProDisTx { } } +/// The signature of a share owner dissolving a shared masternode. +impl Signable for DissolveSig { + type Key = PubKeyHash; + type Context = (Transaction, ProDisTx); + type Error = EcdsaError; + + fn payload(&self, (tx, ptx): &(Transaction, ProDisTx)) -> Vec { + let mut buf = Vec::new(); + String::from(PREFIX_STR).encode(&mut buf); + ptx.version.encode(&mut buf); + write_tx_header(tx, &mut buf); + for input in tx.inputs() { + input.prevout().encode(&mut buf); + } + for input in tx.inputs() { + input.sequence().encode(&mut buf); + } + for output in tx.outputs() { + output.encode(&mut buf); + } + ptx.pro_tx_hash.encode(&mut buf); + ptx.actor_index.encode(&mut buf); + (ptx.sigs.len() as u8).encode(&mut buf); + sha256d(&buf).to_vec() + } + + fn set_signature(&mut self, sig: &[u8], key: &PubKeyHash, ctx: &Self::Context) -> Result<(), EcdsaError> { + let sig = <[u8; ECDSA_REC_SIG_LEN]>::try_from(sig).map_err(|_| EcdsaError::InvalidSignature)?; + verify_compact_canonical(&self.payload(ctx), &sig, key)?; + *self = EcdsaRecSigArray::from_bytes(sig).into(); + Ok(()) + } + + fn reset_signature(&mut self) { + *self = Self::default(); + } + + fn verify(&self, key: &PubKeyHash, ctx: &Self::Context) -> Option { + verify_compact_canonical(&self.payload(ctx), self.as_bytes(), key).err() + } +} + impl Checkable for ProDisTx { type Error = ProTxInvalid; @@ -93,7 +141,7 @@ impl fmt::Display for ProDisTx { #[expect(clippy::unwrap_used, reason = "test code")] mod tests { use super::*; - use crate::Transaction; + use crate::sign::tests::consent_signs_the_payload; use dash_dev::{assert_json_rt, check_sptx_raw, vec_from_hex}; use rstest::rstest; @@ -132,6 +180,13 @@ mod tests { assert_eq!(Transaction::decode(&mut &raw[..]).unwrap().check(), None, "{txid}"); } + #[rstest] + fn dissolve_sig_signs_the_payload() { + let (txid, raw) = REGTEST[0]; + let tx = Transaction::decode(&mut &vec_from_hex(raw)[..]).unwrap(); + consent_signs_the_payload::(&(tx, regtest(txid))); + } + /// The fields that `decoderawtransaction` of the reference implementation at /// v24.0.0-rc.5 reports for each regtest transaction. Each assertion names /// the RPC field it checks. diff --git a/pkgs/primitives/src/provider/proregtx.rs b/pkgs/primitives/src/provider/proregtx.rs index af146968f..4a6c8f78f 100644 --- a/pkgs/primitives/src/provider/proregtx.rs +++ b/pkgs/primitives/src/provider/proregtx.rs @@ -7,14 +7,16 @@ //! ProRegTx registration payload (type 1). use super::share::{check_payout_version, check_payouts, check_shares, EVO_COLLATERAL, MAX_REWARD, REGULAR_COLLATERAL}; -use super::{CollateralShare, CollateralSig, JoinSig, OperatorKey, PayoutShare, ProTxVersion}; +use super::{CollateralShare, CollateralSig, EcdsaRecSigArray, JoinSig, OperatorKey, PayoutShare, ProTxVersion}; use crate::codec::{decode_items, decode_list, encode_items, encode_list, impl_payload}; use crate::prelude::*; use crate::provider::PlatformNodeId; -use crate::sign::{message_digest, unsigned_digest, verify_compact}; +use crate::sign::{ + message_digest, sha256d, unsigned_digest, verify_compact, verify_compact_canonical, write_tx_header, +}; use crate::sptx::{check_sptx_netinfo, InputsHash, MnType, ProTxInvalid, MAX_OPERATOR_REWARD}; use crate::types::{NITrait, NetInfo, NetInfoV1, NetInfoV2}; -use crate::{hash_impl, TxHash}; +use crate::{hash_impl, Transaction, TxHash}; use bitcoin_primitives::script::ScriptPubKeyBuf; use dash_num::Hash256; @@ -29,6 +31,9 @@ use hex_conservative::DisplayHex; use core::fmt; +/// Prefix of the digest a `JoinSig` signs. +const PREFIX_STR: &str = "DashSharedMNReg"; + /// ProRegTx -- register a new masternode (type 1). #[derive(Clone, CopyGetters, Debug, Eq, Getters, Hash, PartialEq, TypeId)] #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] @@ -213,15 +218,7 @@ impl BaseCodec for ProRegTx { self.mode.encode(buf); self.collateral_hash.encode(buf); self.collateral_index.encode(buf); - // Branch on version to match the decode path. Validation - // guarantees the variant matches the version. - if self.version >= ProTxVersion::CoreV24 { - if let NetInfo::Extended(ext) = &self.net_info { - ext.encode(buf); - } - } else if let NetInfo::Legacy(svc) = &self.net_info { - svc.encode(buf); - } + self.encode_net_info(buf); self.key_id_owner.encode(buf); self.pub_key_operator.encode(buf); self.key_id_voting.encode(buf); @@ -292,6 +289,62 @@ impl Signable for ProRegTx { } } +/// The consent of a share owner to a shared registration. +impl Signable for JoinSig { + type Key = PubKeyHash; + type Context = (Transaction, ProRegTx); + type Error = EcdsaError; + + fn payload(&self, (tx, ptx): &(Transaction, ProRegTx)) -> Vec { + let mut prevouts = Vec::new(); + let mut outputs = Vec::new(); + for input in tx.inputs() { + input.prevout().encode(&mut prevouts); + } + for output in tx.outputs() { + output.encode(&mut outputs); + } + + let mut buf = Vec::new(); + String::from(PREFIX_STR).encode(&mut buf); + ptx.version.encode(&mut buf); + write_tx_header(tx, &mut buf); + sha256d(&prevouts).encode(&mut buf); + for input in tx.inputs() { + input.sequence().encode(&mut buf); + } + sha256d(&outputs).encode(&mut buf); + ptx.mn_type.to_base().encode(&mut buf); + ptx.mode.encode(&mut buf); + ptx.encode_net_info(&mut buf); + if ptx.mn_type == MnType::Evo { + ptx.platform_node_id.unwrap_or_default().encode(&mut buf); + } + ptx.key_id_voting.encode(&mut buf); + ptx.pub_key_operator.encode(&mut buf); + ptx.operator_reward.encode(&mut buf); + encode_list(&ptx.shares, &mut buf); + ptx.early_period_blocks.encode(&mut buf); + ptx.early_penalty.encode(&mut buf); + sha256d(&buf).to_vec() + } + + fn set_signature(&mut self, sig: &[u8], key: &PubKeyHash, ctx: &Self::Context) -> Result<(), EcdsaError> { + let sig = <[u8; ECDSA_REC_SIG_LEN]>::try_from(sig).map_err(|_| EcdsaError::InvalidSignature)?; + verify_compact_canonical(&self.payload(ctx), &sig, key)?; + *self = EcdsaRecSigArray::from_bytes(sig).into(); + Ok(()) + } + + fn reset_signature(&mut self) { + *self = Self::default(); + } + + fn verify(&self, key: &PubKeyHash, ctx: &Self::Context) -> Option { + verify_compact_canonical(&self.payload(ctx), self.as_bytes(), key).err() + } +} + impl Checkable for ProRegTx { type Error = ProTxInvalid; @@ -439,6 +492,19 @@ impl ProRegTx { } } + /// Writes the network info in the layout `version` selects. + fn encode_net_info(&self, buf: &mut impl EncodeBuf) { + // Branch on version to match the decode path. Validation + // guarantees the variant matches the version. + if self.version >= ProTxVersion::CoreV24 { + if let NetInfo::Extended(ext) = &self.net_info { + ext.encode(buf); + } + } else if let NetInfo::Legacy(svc) = &self.net_info { + svc.encode(buf); + } + } + /// Checks the collateral shares, or the owner payouts when unshared. fn check_owner_rewards(&self) -> Option { if !self.shares.is_empty() { @@ -478,6 +544,7 @@ impl fmt::Display for ProRegTx { mod tests { use super::*; use crate::provider::share::tests::script; + use crate::sign::tests::consent_signs_the_payload; use crate::types::{AddrV2, NIEntry, NIError, NIPurpose, ServiceV2}; use dash_dev::{ @@ -671,6 +738,13 @@ mod tests { ptx } + #[rstest] + fn join_sig_signs_the_consent() { + let (_, raw) = REGTEST[2]; + let tx = Transaction::decode(&mut &vec_from_hex(raw)[..]).unwrap(); + consent_signs_the_payload::(&(tx, shared())); + } + /// `share` with its refund script paying `key`. fn refund_to(share: &CollateralShare, key: PubKeyHash) -> CollateralShare { CollateralShare::new( diff --git a/pkgs/primitives/src/provider/proupsharedregtx.rs b/pkgs/primitives/src/provider/proupsharedregtx.rs index 98493dbcc..075fbf5b5 100644 --- a/pkgs/primitives/src/provider/proupsharedregtx.rs +++ b/pkgs/primitives/src/provider/proupsharedregtx.rs @@ -7,17 +7,19 @@ //! ProUpSharedRegTx shared registrar update payload (type 12). use super::share::MAX_SHARES; -use super::{OperatorKey, SharedRegistrarSig}; +use super::{EcdsaRecSigArray, OperatorKey, SharedRegistrarSig}; use crate::codec::{decode_list, encode_list, impl_payload}; use crate::prelude::*; +use crate::sign::{sha256d, verify_compact_canonical}; use crate::sptx::{InputsHash, ProTxInvalid}; use crate::{hash_impl, TxHash}; use dash_pkc::bls::BlsScIetf; +use dash_pkc::ecdsa::{EcdsaError, ECDSA_REC_SIG_LEN}; use dash_script::PubKeyHash; use dash_types::codec::{BaseCodec, DecodeError, EncodeBuf}; use dash_types::type_id::TypeId; -use dash_types::{impl_new, Checkable}; +use dash_types::{impl_new, Checkable, Signable}; use getset::{CopyGetters, Getters}; use core::fmt; @@ -64,15 +66,39 @@ impl BaseCodec for ProUpSharedRegTx { } fn encode(&self, buf: &mut impl EncodeBuf) { - self.version.encode(buf); - self.pro_tx_hash.encode(buf); - self.pub_key_operator.encode(buf); - self.key_id_voting.encode(buf); - self.inputs_hash.encode(buf); + self.encode_unsigned(buf); encode_list(&self.sigs, buf); } } +/// The signature of a share owner replacing the keys of a shared masternode. +impl Signable for SharedRegistrarSig { + type Key = PubKeyHash; + type Context = ProUpSharedRegTx; + type Error = EcdsaError; + + fn payload(&self, ptx: &ProUpSharedRegTx) -> Vec { + let mut buf = Vec::new(); + ptx.encode_unsigned(&mut buf); + sha256d(&buf).to_vec() + } + + fn set_signature(&mut self, sig: &[u8], key: &PubKeyHash, ptx: &ProUpSharedRegTx) -> Result<(), EcdsaError> { + let sig = <[u8; ECDSA_REC_SIG_LEN]>::try_from(sig).map_err(|_| EcdsaError::InvalidSignature)?; + verify_compact_canonical(&self.payload(ptx), &sig, key)?; + *self = EcdsaRecSigArray::from_bytes(sig).into(); + Ok(()) + } + + fn reset_signature(&mut self) { + *self = Self::default(); + } + + fn verify(&self, key: &PubKeyHash, ptx: &ProUpSharedRegTx) -> Option { + verify_compact_canonical(&self.payload(ptx), self.as_bytes(), key).err() + } +} + impl Checkable for ProUpSharedRegTx { type Error = ProTxInvalid; @@ -95,6 +121,15 @@ hash_impl!(ProUpSharedRegTx); impl ProUpSharedRegTx { /// The payload version `check` accepts. const CURRENT_VERSION: u16 = 1; + + /// Writes every field but the signatures. + fn encode_unsigned(&self, buf: &mut impl EncodeBuf) { + self.version.encode(buf); + self.pro_tx_hash.encode(buf); + self.pub_key_operator.encode(buf); + self.key_id_voting.encode(buf); + self.inputs_hash.encode(buf); + } } impl fmt::Display for ProUpSharedRegTx { @@ -107,6 +142,7 @@ impl fmt::Display for ProUpSharedRegTx { #[expect(clippy::unwrap_used, reason = "test code")] mod tests { use super::*; + use crate::sign::tests::consent_signs_the_payload; use crate::Transaction; use dash_dev::{assert_json_rt, check_sptx_raw, vec_from_hex}; @@ -142,6 +178,11 @@ mod tests { assert_eq!(Transaction::decode(&mut &raw[..]).unwrap().check(), None, "{txid}"); } + #[rstest] + fn shared_registrar_sig_signs_the_payload() { + consent_signs_the_payload::(®test(REGTEST[0].0)); + } + /// The fields that `decoderawtransaction` of the reference implementation at /// v24.0.0-rc.5 reports for each regtest transaction. Each assertion names /// the RPC field it checks. diff --git a/pkgs/primitives/src/provider/proupsharetx.rs b/pkgs/primitives/src/provider/proupsharetx.rs index 50e70cd92..7cd7fd76e 100644 --- a/pkgs/primitives/src/provider/proupsharetx.rs +++ b/pkgs/primitives/src/provider/proupsharetx.rs @@ -9,13 +9,15 @@ use super::share::payee; use crate::codec::codec_payload; use crate::prelude::*; +use crate::sign::{unsigned_digest, verify_compact_canonical}; use crate::sptx::{InputsHash, ProTxInvalid}; use crate::TxHash; use bitcoin_primitives::script::ScriptPubKeyBuf; -use dash_pkc::ecdsa::ECDSA_REC_SIG_LEN; +use dash_pkc::ecdsa::{EcdsaError, ECDSA_REC_SIG_LEN}; +use dash_script::PubKeyHash; use dash_types::type_id::TypeId; -use dash_types::Checkable; +use dash_types::{Checkable, Signable}; use getset::{CopyGetters, Getters}; use core::fmt; @@ -48,6 +50,34 @@ pub struct ProUpShareTx { } } +impl Signable for ProUpShareTx { + type Key = PubKeyHash; + type Context = (); + type Error = EcdsaError; + + fn payload(&self, _ctx: &()) -> Vec { + unsigned_digest(self, &self.sig).to_vec() + } + + fn set_signature(&mut self, sig: &[u8], key: &PubKeyHash, _ctx: &()) -> Result<(), EcdsaError> { + let sig = <[u8; ECDSA_REC_SIG_LEN]>::try_from(sig).map_err(|_| EcdsaError::InvalidSignature)?; + verify_compact_canonical(&self.payload(&()), &sig, key)?; + self.sig = sig.to_vec(); + Ok(()) + } + + fn reset_signature(&mut self) { + self.sig = Vec::new(); + } + + fn verify(&self, key: &PubKeyHash, _ctx: &()) -> Option { + let Ok(sig) = <&[u8; ECDSA_REC_SIG_LEN]>::try_from(self.sig.as_slice()) else { + return Some(EcdsaError::InvalidSignature); + }; + verify_compact_canonical(&self.payload(&()), sig, key).err() + } +} + impl Checkable for ProUpShareTx { type Error = ProTxInvalid; @@ -81,6 +111,7 @@ impl fmt::Display for ProUpShareTx { mod tests { use super::*; use crate::provider::share::tests::script; + use crate::sign::tests::ecdsa_sign; use crate::Transaction; use dash_dev::{assert_json_rt, check_sptx_raw, vec_from_hex}; @@ -142,6 +173,24 @@ mod tests { assert_eq!(ptx.inputs_hash.to_string(), inputs_hash, "inputsHash"); } + /// The share owner's signature leaves the digest it signs unchanged and is + /// stored only under the owner's key. + #[rstest] + fn owner_signs_the_payload() { + let mut ptx = regtest("5b99ff072732404b4cb5efe2531da72fbcc40bb21cdf417897caddcebc0f3f18"); + let digest = <[u8; 32]>::try_from(ptx.payload(&())).unwrap(); + let (key, sig) = ecdsa_sign(1, &digest); + let (other, _) = ecdsa_sign(2, &digest); + + assert_eq!(ptx.set_signature(&sig, &other, &()), Err(EcdsaError::VerifyFailed)); + assert_eq!(ptx.set_signature(&sig, &key, &()), Ok(())); + assert_eq!(ptx.verify(&key, &()), None); + assert_eq!(ptx.payload(&()), digest); + + ptx.reset_signature(); + assert_eq!(ptx.verify(&key, &()), Some(EcdsaError::InvalidSignature)); + } + #[rstest] #[case::p2sh_reward( |ptx: &mut ProUpShareTx| ptx.script_reward = script(Recipient::ScriptHash(ScriptHash::from([7; 20]))), diff --git a/pkgs/primitives/src/provider/sig.rs b/pkgs/primitives/src/provider/sig.rs index 82edd27fd..1fdea6625 100644 --- a/pkgs/primitives/src/provider/sig.rs +++ b/pkgs/primitives/src/provider/sig.rs @@ -21,7 +21,7 @@ use dash_types::codec::{BaseCodec, DecodeError, EncodeBuf}; #[cfg(feature = "serde")] use dash_types::serialize::hex as serde_hex; use dash_types::type_id::TypeId; -use dash_types::{dlgt_codec, make_bytes, type_cvrt, CompactSize, Hashable, Numeric}; +use dash_types::{dlgt_codec, make_bytes, type_cvrt, Hashable, Numeric}; #[cfg(feature = "serde")] use serde::de::Error as _; #[cfg(feature = "serde")] @@ -36,28 +36,16 @@ make_bytes! { hash_impl!(EcdsaRecSigArray); -/// Decodes a compact signature of 0 or 65 bytes. -fn decode_compact(data: &mut &[u8]) -> Result, DecodeError> { - match CompactSize::decode(data)?.into_len(ECDSA_REC_SIG_LEN)? { - 0 => Ok(None), - ECDSA_REC_SIG_LEN => EcdsaRecSigArray::decode(data).map(Some), - actual => Err(DecodeError::BadLen { - expected: vec![0, ECDSA_REC_SIG_LEN], - actual, - }), - } -} - -/// The signature bytes, empty when unsigned. -fn compact_image(sig: Option<&impl AsRef<[u8]>>) -> Vec { - sig.map(|s| s.as_ref().to_vec()).unwrap_or_default() -} - /// Hex form of a compact signature, empty when unsigned. #[cfg(feature = "serde")] pub(crate) mod compact_hex { use super::*; + /// The signature bytes, empty when unsigned. + fn compact_image(sig: Option<&impl AsRef<[u8]>>) -> Vec { + sig.map(|s| s.as_ref().to_vec()).unwrap_or_default() + } + pub(crate) fn serialize>(sig: &Option, serializer: S) -> Result { serde_hex::serialize(&compact_image(sig.as_ref()), serializer) } @@ -82,15 +70,15 @@ pub(crate) mod compact_hex { derive(::serde::Serialize, ::serde::Deserialize), serde(transparent) )] -pub struct CollateralSig(#[cfg_attr(feature = "serde", serde(with = "compact_hex"))] Option); +pub struct CollateralSig(#[cfg_attr(feature = "serde", serde(with = "serde_hex"))] Vec); impl BaseCodec for CollateralSig { fn decode(data: &mut &[u8]) -> Result { - decode_compact(data).map(Self) + Vec::decode(data).map(Self) } fn encode(&self, buf: &mut impl EncodeBuf) { - compact_image(self.0.as_ref()).encode(buf); + self.0.encode(buf); } } @@ -98,18 +86,23 @@ impl Hashable for CollateralSig { type Hash = Hash256; fn hash(&self) -> Self::Hash { - Hash256::from_lendian(sha256d::Hash::hash(&compact_image(self.0.as_ref())).to_byte_array()) + Hash256::from_lendian(sha256d::Hash::hash(&self.0).to_byte_array()) } } impl CollateralSig { pub(crate) fn new(sig: [u8; ECDSA_REC_SIG_LEN]) -> Self { - Self(Some(EcdsaRecSigArray::from_bytes(sig))) + Self(sig.to_vec()) } - /// Borrows the signature, `None` when unsigned. + /// Borrows the signature, `None` when unsigned or not 65 bytes. pub fn as_bytes(&self) -> Option<&[u8; ECDSA_REC_SIG_LEN]> { - self.0.as_ref().map(EcdsaRecSigArray::as_bytes) + self.0.as_slice().try_into().ok() + } + + /// Borrows the bytes as read, empty when unsigned. + pub fn as_slice(&self) -> &[u8] { + &self.0 } } @@ -120,15 +113,15 @@ impl CollateralSig { derive(::serde::Serialize, ::serde::Deserialize), serde(transparent) )] -pub struct OwnerSig(#[cfg_attr(feature = "serde", serde(with = "compact_hex"))] Option); +pub struct OwnerSig(#[cfg_attr(feature = "serde", serde(with = "serde_hex"))] Vec); impl BaseCodec for OwnerSig { fn decode(data: &mut &[u8]) -> Result { - decode_compact(data).map(Self) + Vec::decode(data).map(Self) } fn encode(&self, buf: &mut impl EncodeBuf) { - compact_image(self.0.as_ref()).encode(buf); + self.0.encode(buf); } } @@ -136,18 +129,23 @@ impl Hashable for OwnerSig { type Hash = Hash256; fn hash(&self) -> Self::Hash { - Hash256::from_lendian(sha256d::Hash::hash(&compact_image(self.0.as_ref())).to_byte_array()) + Hash256::from_lendian(sha256d::Hash::hash(&self.0).to_byte_array()) } } impl OwnerSig { pub(crate) fn new(sig: [u8; ECDSA_REC_SIG_LEN]) -> Self { - Self(Some(EcdsaRecSigArray::from_bytes(sig))) + Self(sig.to_vec()) } - /// Borrows the signature, `None` when unsigned. + /// Borrows the signature, `None` when unsigned or not 65 bytes. pub fn as_bytes(&self) -> Option<&[u8; ECDSA_REC_SIG_LEN]> { - self.0.as_ref().map(EcdsaRecSigArray::as_bytes) + self.0.as_slice().try_into().ok() + } + + /// Borrows the bytes as read, empty when unsigned. + pub fn as_slice(&self) -> &[u8] { + &self.0 } } @@ -316,6 +314,48 @@ mod tests { assert_eq!(buf, wire); } + /// A signature of any length decodes and encodes back unchanged, through + /// the codec and through JSON; only 65 bytes give a compact signature. + #[rstest] + #[case::empty(0)] + #[case::one(1)] + #[case::short(64)] + #[case::compact(ECDSA_REC_SIG_LEN)] + #[case::long(66)] + #[case::wide_size(300)] + fn any_length_round_trips(#[case] len: usize) { + let mut wire = Vec::new(); + vec![7_u8; len].encode(&mut wire); + let owner = OwnerSig::decode(&mut wire.as_slice()).unwrap(); + let collateral = CollateralSig::decode(&mut wire.as_slice()).unwrap(); + for (bytes, compact) in [ + (owner.as_slice(), owner.as_bytes().is_some()), + (collateral.as_slice(), collateral.as_bytes().is_some()), + ] { + assert_eq!(bytes.len(), len); + assert_eq!(compact, len == ECDSA_REC_SIG_LEN); + } + let mut buf = Vec::new(); + owner.encode(&mut buf); + collateral.encode(&mut buf); + assert_eq!(buf, [wire.clone(), wire].concat()); + #[cfg(feature = "serde")] + { + dash_dev::assert_json_rt(&owner); + dash_dev::assert_json_rt(&collateral); + } + } + + /// A signature hashes the bytes it holds without their size, as a + /// fixed-size compact signature of the same bytes hashes. + #[rstest] + fn hash_covers_the_bytes_held() { + let bytes = [9_u8; ECDSA_REC_SIG_LEN]; + let fixed = EcdsaRecSigArray::from_bytes(bytes).hash(); + assert_eq!(OwnerSig::new(bytes).hash(), fixed); + assert_eq!(CollateralSig::new(bytes).hash(), fixed); + } + #[rstest] #[case::legacy_bls(ProTxVersion::LegacyBls, true)] #[case::basic_bls(ProTxVersion::BasicBls, false)] diff --git a/pkgs/primitives/src/sign.rs b/pkgs/primitives/src/sign.rs index 03e97ad35..f659098e5 100644 --- a/pkgs/primitives/src/sign.rs +++ b/pkgs/primitives/src/sign.rs @@ -7,13 +7,16 @@ //! Signature checks shared by the signed payloads. use crate::prelude::*; +use crate::{QuorumHash, Transaction}; use bitcoin_hashes::sha256d; +use dash_num::Hash256; +use dash_params::LlmqType; use dash_pkc::bls::{BlsError, BlsPkBytes, BlsScheme, BlsSigBytes}; use dash_pkc::ecdsa::{EcdsaError, EcdsaPublicKey, EcdsaRecSigBytes, EcdsaRecSignature, ECDSA_REC_SIG_LEN}; use dash_script::PubKeyHash; -use dash_types::codec::BaseCodec; -use dash_types::Hashable; +use dash_types::codec::{BaseCodec, EncodeBuf}; +use dash_types::{Hashable, Numeric}; /// Prefix hashed ahead of a signed message. pub const MESSAGE_MAGIC: &str = "DarkCoin Signed Message:\n"; @@ -33,6 +36,47 @@ pub(crate) fn unsigned_digest(payload: &impl BaseCodec, sig: &impl BaseCodec) -> sha256d(&image) } +/// Writes the version, type and lock time of `tx`. +pub(crate) fn write_tx_header(tx: &Transaction, buf: &mut impl EncodeBuf) { + tx.version().encode(buf); + tx.tx_type().to_base().encode(buf); + tx.lock_time().encode(buf); +} + +/// The hash of `tx` with its extra payload replaced by `payload`. +pub(crate) fn tx_hash_with(tx: &Transaction, payload: &impl BaseCodec) -> Hash256 { + let mut extra = Vec::new(); + payload.encode(&mut extra); + let tx = Transaction::new( + tx.version(), + tx.tx_type(), + tx.inputs().clone(), + tx.outputs().clone(), + tx.lock_time(), + extra, + ); + Hash256::from_lendian(tx.instance_hash().to_lendian()) +} + +/// The id of a quorum signing request, the hash of `prefix` and `n`. +pub(crate) fn request_id(prefix: &str, n: &impl BaseCodec) -> Hash256 { + let mut buf = Vec::new(); + String::from(prefix).encode(&mut buf); + n.encode(&mut buf); + Hash256::from_lendian(sha256d(&buf)) +} + +/// The digest a quorum of `llmq_type` signs for request `id` over the +/// message hash `msg_hash`. +pub fn llmq_sig_hash(llmq_type: LlmqType, quorum_hash: &QuorumHash, id: &Hash256, msg_hash: &Hash256) -> Hash256 { + let mut buf = Vec::new(); + llmq_type.encode(&mut buf); + quorum_hash.encode(&mut buf); + id.encode(&mut buf); + msg_hash.encode(&mut buf); + Hash256::from_lendian(sha256d(&buf)) +} + /// Digest signed for the message `msg`. pub(crate) fn message_digest(msg: &[u8]) -> [u8; 32] { let mut buf = Vec::new(); @@ -60,6 +104,24 @@ pub(crate) fn verify_compact(digest: &[u8], sig: &[u8; ECDSA_REC_SIG_LEN], key: } } +/// [`verify_compact`], refusing a header that is not canonical or a high S. +/// +/// # Errors +/// +/// Returns `InvalidSignature` for a non-canonical header or high S, and +/// otherwise the errors from [`verify_compact`]. +pub(crate) fn verify_compact_canonical( + digest: &[u8], + sig: &[u8; ECDSA_REC_SIG_LEN], + key: &PubKeyHash, +) -> Result<(), EcdsaError> { + let bytes = EcdsaRecSigBytes::from_bytes(*sig).ok_or(EcdsaError::InvalidSignature)?; + if !EcdsaRecSignature::try_from(bytes)?.signature().is_low_s() { + return Err(EcdsaError::InvalidSignature); + } + verify_compact(digest, sig, key) +} + /// Checks a BLS signature over `digest` under scheme `S`. /// /// # Errors @@ -77,8 +139,10 @@ pub(crate) fn verify_bls(digest: &[u8], sig: &BlsSigBytes, key: &B pub(crate) mod tests { use super::*; + use dash_dev::arr_from_hex; use dash_pkc::bls::BlsSecretKey; use dash_pkc::ecdsa::{Compression, EcdsaSecretKey}; + use dash_types::Signable; use rstest::rstest; /// Signs `digest` itself, returning the key id and the compact signature. @@ -90,6 +154,51 @@ pub(crate) mod tests { ) } + /// A consent signature of type `T` over `ctx` is stored only when it + /// verifies under the signer's key, leaves the digest unchanged and is + /// removed by a reset. + pub(crate) fn consent_signs_the_payload(ctx: &T::Context) + where + T: Default + Signable, + { + let mut consent = T::default(); + let digest = <[u8; 32]>::try_from(consent.payload(ctx)).unwrap(); + let (key, sig) = ecdsa_sign(1, &digest); + let (other, _) = ecdsa_sign(2, &digest); + + assert_eq!(consent.verify(&key, ctx), Some(EcdsaError::InvalidSignature)); + assert_eq!(consent.set_signature(&sig, &other, ctx), Err(EcdsaError::VerifyFailed)); + assert_eq!( + consent.set_signature(&sig[1..], &key, ctx), + Err(EcdsaError::InvalidSignature) + ); + assert_eq!(consent.set_signature(&sig, &key, ctx), Ok(())); + assert_eq!(consent.verify(&key, ctx), None); + assert_eq!(consent.verify(&other, ctx), Some(EcdsaError::VerifyFailed)); + assert_eq!(consent.payload(ctx), digest); + + consent.reset_signature(); + assert_eq!(consent.verify(&key, ctx), Some(EcdsaError::InvalidSignature)); + } + + /// The high-S twin of a compact signature recovers the same key, so the + /// plain check takes it and the canonical check refuses it. + #[rstest] + fn canonical_refuses_the_high_s_twin() { + let digest = [7_u8; 32]; + let (key, low) = ecdsa_sign(1, &digest); + let high = arr_from_hex( + "20001af75f8a0ececcc4af0ccdbcccc1a81656eca444e3484151212ad1823ae1\ + 22833f8b7a45a58860e0edf76f6f1b4feb88812c0bca608b262d11ac9ec06549f4", + ); + assert_eq!(verify_compact(&digest, &high, &key), Ok(())); + assert_eq!(verify_compact_canonical(&digest, &low, &key), Ok(())); + assert_eq!( + verify_compact_canonical(&digest, &high, &key), + Err(EcdsaError::InvalidSignature) + ); + } + /// Signs `digest` under scheme `S`, returning the public key and signature. pub(crate) fn bls_sign(seed: u8, digest: &[u8; 32]) -> (BlsPkBytes, [u8; 96]) { let sk = BlsSecretKey::::from_ikm(&[seed; 32]).unwrap(); diff --git a/pkgs/primitives/tests/payload_sighash.rs b/pkgs/primitives/tests/payload_sighash.rs new file mode 100644 index 000000000..a36ec5a51 --- /dev/null +++ b/pkgs/primitives/tests/payload_sighash.rs @@ -0,0 +1,263 @@ +// +// Copyright (c) 2026-present, The Dash Core developers +// SPDX-License-Identifier: MIT +// See the accompanying file LICENSE or https://opensource.org/license/MIT +// + +//! Signatures of the reference implementation over the payload sign hashes. + +#![expect(clippy::panic, clippy::unwrap_used, reason = "test code")] + +use dash_dev::{arr_from_hex, vec_from_hex, Corpus}; +use dash_params::Network; +use dash_pkc::bls::{BlsPkBytes, BlsPublicKey, BlsScChia, BlsScIetf, BlsScheme, BlsSigBytes, BlsSignature}; +use dash_primitives::{CollateralShare, ProTxVersion, SpecialPayload, Transaction}; +use dash_script::PubKeyHash; +use dash_types::codec::BaseCodec; +use dash_types::{Numeric, Signable}; + +use std::collections::{BTreeMap, BTreeSet}; + +/// A special transaction and the keys its signers held. +#[derive(Clone, Debug, Eq, Hash, PartialEq, ::serde::Deserialize)] +struct Entry { + /// Chain and block the transaction was read from. + source: String, + /// Network of the chain. + network: String, + /// The serialized transaction. + raw: String, + /// The keys the signatures verify under. + signer: Signer, +} + +/// A BLS scheme. +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, ::serde::Deserialize)] +#[serde(rename_all = "lowercase")] +enum Scheme { + Legacy, + Basic, +} + +impl Scheme { + /// The scheme a payload of `version` writes its operator signature under. + fn of(version: ProTxVersion) -> Self { + if version == ProTxVersion::LegacyBls { + Self::Legacy + } else { + Self::Basic + } + } +} + +/// The keys the signatures of an entry verify under. +#[derive(Clone, Debug, Default, Eq, Hash, PartialEq, ::serde::Deserialize)] +#[serde(default)] +struct Signer { + /// Key ids that own the collateral, the masternode or its shares, in + /// share order. + key_ids: Vec, + /// Operator BLS key of the masternode. + operator: Option, + /// Scheme the operator key is written under. + key_scheme: Option, + /// Scheme the operator signed under. + sig_scheme: Option, + /// Public key of the quorum that signed the payload. + quorum: Option, +} + +impl Signer { + fn key_ids(&self) -> Vec { + self + .key_ids + .iter() + .map(|id| PubKeyHash::from_lendian(arr_from_hex(id))) + .collect() + } + + /// The only key id. + fn key_id(&self) -> PubKeyHash { + let [key] = self.key_ids()[..] else { + panic!("{} key ids", self.key_ids.len()); + }; + key + } + + /// The key id of share `index`. + fn share_key(&self, index: u16) -> PubKeyHash { + self.key_ids()[usize::from(index)] + } + + /// The key of the quorum that signed the payload. + fn quorum(&self) -> BlsPkBytes { + BlsPkBytes::from_bytes(arr_from_hex(self.quorum.as_deref().unwrap())) + } + + /// Whether the operator's `sig`, given with the scheme it is written + /// under, verifies over `digest` under the operator key in the scheme the + /// operator signed under. + fn operator_signed(&self, sig: &(BlsSigBytes, Scheme), digest: &[u8]) -> bool { + let key = BlsPkBytes::from_bytes(arr_from_hex(self.operator.as_deref().unwrap())); + let key = (key, self.key_scheme.unwrap()); + match self.sig_scheme.unwrap() { + Scheme::Legacy => bls_verifies::(&key, sig, digest), + Scheme::Basic => bls_verifies::(&key, sig, digest), + } + } +} + +fn corpus() -> BTreeMap { + Corpus::open(env!("CARGO_MANIFEST_DIR"), "sighash").value("sighash") +} + +// TODO(pasta): replace these with testnet rows once there are some +/// Regtest transactions of the kinds that no testnet block from 1565132 to +/// 1591381 holds, from functional tests of the reference implementation at +/// v24.0.0-rc.3, with the keys their signers held at the block before. +fn regtest() -> BTreeMap { + let owners = |ids: &[&str]| Signer { + key_ids: ids.iter().map(ToString::to_string).collect(), + ..Signer::default() + }; + let quorum = |key: &str| Signer { + quorum: Some(key.to_string()), + ..Signer::default() + }; + [ + // A version 3 registrar update. + ("11394a49704f57a63ba119742074ce43e4fcb13d97eece242de7be94c263aad5", "feature_protx_version block 384", "03000300010bb3bcc0293303a7c33471fa9081b0f9ad87a5bfb1769f7059b1cfca08ef3ba3010000006a473044022055815478b33579ae4573755ee425f49bd09f9e9cfb07f17821810dc950597863022063e3a1b3082fd81ac040ce40058f6d56e0947f6113cab321c0bb292a4e9a1416012103090f1455503bddf1bdb7b6ae6dffafb7a66248551bfb592900ed7e8efd21d486feffffff014fdff505000000001976a9146ce2ac804158e51299b5bc017cedd10064231f8f88ac00000000e703000b641b8f63f4b8619cac88d532533ca7a64461a32e8669d90fdd4aaf0e92704f000091bea3a77f336a4c5df0c5fdbb1c5f6d33c04e2ed251d99359f0d5a80e46c4f7aa9077755d2cdae9ab5248f0c70d8f14a6ea9fa81746664db9fb2dd4996ee31622e61b15011976a9148a20a1b135db76136993a65494336ce82df8b6a988ac1027bef1be7238c10c0dfc48647a05acfe779b1323ffdd7c57641405f4a806c30c124120c13fec728c8b52c481a2d0b7e8b9556933206c7429818a4c072ced05ea1aadce365c9da7b6006a9c9278bf1da1416eb380eec900ff6e61775a162047d8193af9", owners(&["3adab6dfd8ba2e8f0023248f5b46278da6f4faef"])), + // A version 2 asset unlock. + ("ed6d78c04f2e9ba2f1c81536cde6885725448ae7083b7580b21031cf565590b8", "feature_asset_locks block 969", "03000900000190cff4050000000023210208757bbcd988510d37a86a8c703f9b57543fa343bcf5bd583d444f213b08df03ac000000009102210300000000000070110100c80300005eefda1aa736089dea8f24bc123625405d35aac52a27d4806aff193cf881055895c2eb3e11355fcbd86e5494ceb2d207e5e47d95a9da9b2d3d968c321935993773cd9cea6c831b43f2a09f92944fc62f11d29adb607774915e7dd26c01ecf912e9cd0e793ab66b5fb61145cd80e9830822d904d375562a705f35e65d9ceed33d", quorum("928543a0364f3192a47407923e7ed2b19eb743af5c3f94b9bda198ec73fa316092482a8d3280a7ce58ac0748d86d1404")), + // An Evo masternode's registration with shares. + ("aecdb16d0f30d6c62b1a7d6508a7718093d4b69f51d222335e4a6be439a6e71e", "feature_masternode_shares block 2023", "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", Signer::default()), + // A share update. + ("7c71f29451b4a09756b8664eb59592514bbd43395b43b4fe6878a762ada093c7", "feature_masternode_shares block 276", "03000b0001acebb7cbf7176bdf33fae143c11f82cb97659477e73dff20ba414ea2ec011970000000006a47304402202a35e0e5a5e2239346b7a2f211f3bc2063048c4a644a650821baa181c4bb79a3022001933d1764fcf337d44f38322a2866e541f6638dcf4e57d3e6cda8895f26f3e2012102fd12b3ea269e7ffa97c6d30ac236ea269819dad98216c4ad33b3f9aabfa025cdfeffffff0196dff505000000001976a91491e4b0a9c865845fc4ab401e475059af9cd0a5db88ac00000000a00100e49e985715484b5d76b8d96b710282712a73e744683f4987bd8e2bd10743574500001976a9143e7caaa99621cd878ed371726f4e459104e23dbc88aca3b3f94d0cd5851f4e7503297ca5212488f14ab89181a1a90fd59fed9df0afb541203a324a03e47ed3cda35b2e605dacfe87fcc7121e0657ff29785dd053addf72d04e38d407bb3869f9fe1dd8cd3e12b39cce7d12f69cb2e0c3c937fb2662349bd4", owners(&["5a71973a879b5cd702e4ebad0eb96244e84e0627", "c374c77db723510a2717e27c91033e1c9431342a"])), + // A shared registrar update. + ("0175bb1b4df1560403ec27341eb80543c1db6a2682eab1f0e3fb576680d460c7", "feature_masternode_shares block 279", "03000c0001719a49038ccfc9a23fe2f9e66b89f8b5b0d644d5d91dd6810c6d2c3112560b9e010000006a4730440220269c10d1fd32d4fa7994c7fbb4cc6886ee1e021442584a03c0cb6db65e7c6d9c02206ea2a34de3a581b7e643ae1800b920065c1b5cbe1417bb01af0a8bbdd8c1f9ed012102fd12b3ea269e7ffa97c6d30ac236ea269819dad98216c4ad33b3f9aabfa025cdfeffffff012bdff505000000001976a91491e4b0a9c865845fc4ab401e475059af9cd0a5db88ac00000000fd09010100e49e985715484b5d76b8d96b710282712a73e744683f4987bd8e2bd10743574583d7356ed2c7bf71cdb1175e8760c2b4f1290a09757a392082185389b1ad1a875c80b62993979a9180ccf8eb4377d4e660cec402e24d9e54669a074034532f734531e201af7cfe60eee6fa746a4c0d3c130ce763f697539609afbb133421161aad6c5337021f6b11d8e5a47d662b47de9822a6fbfead736d95f30ba6fc2a7bb890c365fcc34d057dee4d1fb662cee0432f857c7cdf8a8a4b9979087b8019c250025d3c54238f20a5fa6d84ca799f76d6dcbaa80432224da803683f09bba0f3fce0d5f6b2bb2b56156c9e40f4695f96371a7252edac23f60991eb03b63c89dbc9af6fd053d84d83", owners(&["5a71973a879b5cd702e4ebad0eb96244e84e0627", "c374c77db723510a2717e27c91033e1c9431342a"])), + ] + .into_iter() + .map(|(txid, source, raw, signer)| { + let entry = Entry { + source: format!("regtest {source}"), + network: "regtest".to_string(), + raw: raw.to_string(), + signer, + }; + (txid.to_string(), entry) + }) + .collect() +} + +/// The key `bytes` hold, read under the legacy or the basic scheme and +/// carried over to scheme `V`. +fn bls_key(bytes: &BlsPkBytes, scheme: Scheme) -> Option> { + match scheme { + Scheme::Legacy => bytes.to::().ok()?.to_scheme().ok(), + Scheme::Basic => bytes.to::().ok()?.to_scheme().ok(), + } +} + +/// The signature `bytes` hold, read as [`bls_key`] reads a key. +fn bls_sig(bytes: &BlsSigBytes, scheme: Scheme) -> Option> { + match scheme { + Scheme::Legacy => bytes.to::().ok()?.to_scheme().ok(), + Scheme::Basic => bytes.to::().ok()?.to_scheme().ok(), + } +} + +/// Whether `sig` verifies over `digest` under `key` with scheme `V`. +fn bls_verifies(key: &(BlsPkBytes, Scheme), sig: &(BlsSigBytes, Scheme), digest: &[u8]) -> bool { + let digest = <&[u8; 32]>::try_from(digest).unwrap(); + match (bls_key::(&key.0, key.1), bls_sig::(&sig.0, sig.1)) { + (Some(key), Some(sig)) => key.verify_digest(digest, &sig).is_ok(), + _ => false, + } +} + +/// Whether `sigs` holds one signature per key in `keys`, each verifying under +/// its key. +fn consents_signed>(sigs: &[T], keys: &[PubKeyHash], ctx: &T::Context) -> bool { + sigs.len() == keys.len() && sigs.iter().zip(keys).all(|(sig, key)| sig.verify(key, ctx).is_none()) +} + +/// Checks the signatures of one entry over its payload's sign hash, and +/// returns its type and payload version, or `None` for a payload this test +/// does not cover. +fn check_signed(txid: &str, entry: &Entry) -> Option<(u16, u16)> { + let tx = Transaction::decode(&mut vec_from_hex(&entry.raw).as_slice()).unwrap(); + let payload = tx.decode_payload().unwrap().unwrap(); + let signer = &entry.signer; + let network = match entry.network.as_str() { + "mainnet" => Network::Main, + "testnet" => Network::Testnet3, + "regtest" => Network::Regtest, + other => panic!("{txid}: unknown network {other}"), + }; + + let (version, signed) = match &payload { + SpecialPayload::ProviderRegister(p) if !p.shares().is_empty() => { + let owners: Vec<_> = p.shares().iter().map(CollateralShare::key_id_owner).collect(); + ( + p.version().to_base(), + consents_signed(p.join_sigs(), &owners, &(tx.clone(), p.clone())), + ) + } + SpecialPayload::ProviderRegister(p) => ( + p.version().to_base(), + p.verify(&signer.key_id(), network.addr()).is_none(), + ), + SpecialPayload::ProviderUpdateService(p) => { + let sig = (*p.sig().as_bytes(), Scheme::of(p.version())); + (p.version().to_base(), signer.operator_signed(&sig, &p.payload(&()))) + } + SpecialPayload::ProviderUpdateRegistrar(p) => (p.version().to_base(), p.verify(&signer.key_id(), &()).is_none()), + SpecialPayload::ProviderUpdateRevoke(p) => { + let sig = (*p.sig().as_bytes(), Scheme::of(p.version())); + (p.version().to_base(), signer.operator_signed(&sig, &p.payload(&()))) + } + SpecialPayload::ProviderDissolve(p) => ( + p.version(), + consents_signed(p.sigs(), &signer.key_ids(), &(tx.clone(), p.clone())), + ), + SpecialPayload::ProviderUpdateShare(p) => { + (p.version(), p.verify(&signer.share_key(p.share_index()), &()).is_none()) + } + SpecialPayload::ProviderUpdateSharedRegistrar(p) => (p.version(), consents_signed(p.sigs(), &signer.key_ids(), p)), + SpecialPayload::MnhfSignal(p) => { + let llmq_type = network.consensus().llmq_type_mnhf; + let digest = p.sig_hash(&tx, llmq_type).to_lendian(); + let signed = bls_verifies::(&(signer.quorum(), Scheme::Basic), &(p.sig(), Scheme::Basic), &digest); + (p.version().into(), signed) + } + SpecialPayload::AssetUnlock(p) => { + let llmq_type = network.consensus().llmq_type_platform; + let digest = p.sig_hash(&tx, llmq_type).to_lendian(); + let signed = bls_verifies::( + &(signer.quorum(), Scheme::Basic), + &(p.quorum_sig(), Scheme::Basic), + &digest, + ); + (p.version().into(), signed) + } + _ => return None, + }; + assert!(signed, "{txid} ({}): the signature does not verify", entry.source); + Some((tx.tx_type().to_base(), version)) +} + +/// The signatures verify over the sign hash of every payload type that has +/// one, at every version. +#[test] +fn signatures_verify_over_sighash() { + let shapes: BTreeSet<_> = corpus() + .into_iter() + .chain(regtest()) + .filter_map(|(txid, entry)| check_signed(&txid, &entry)) + .collect(); + let mut expected = BTreeSet::<(u16, u16)>::new(); + expected.extend((1..=4).flat_map(|t| (1..=3).map(move |v| (t, v)))); + expected.extend([(10, 1), (11, 1), (12, 1)]); + expected.extend([(7, 1), (9, 1), (9, 2)]); + assert_eq!(shapes, expected); +}