bitcoin core – What number of sigops are within the invalid block 783426?

I used to be in a position to do a partial rely, however I am having a difficult time counting it for P2SH and SegWit transactions.

Parse the block and retailer consequence:

bitcoin-cli getblock 00000000000000000002ec935e245f8ae70fc68cc828f05bf4cfa002668599e4 2 > block.json

This lists transactions like so:

    {
      "txid": "914b24cf50f4bc930c3a11123411031010f010563ed293f65f1ef8cb9bc1e950",
      ...
      "vin": [
        {
          "txid": "cf3349976fedfe34502333310f753d91c16dccb3220d37d5f4c1a11b70eceda2",
          "vout": 1,
          "scriptSig": {
            "asm": "30440220253e9a3fc9cbae7833abc38ea29ae4f7672cb33591c227446c71b26a8199760a022071042cde824b3cfddc51888d49ac8f85062921e1430ee85885252e1a6758fc17[ALL] 02b704c5bac9ed2e23193f28f0a9e1108ff6164e713552fca936c9447566df1d66",
            "hex": "..."
          },
          "series": 4294967295
        }
      ],
      "vout": [
        {
          "value": 0.00071520,
          "n": 1,
          "scriptPubKey": {
            "asm": "OP_DUP OP_HASH160 8342c5f824ae0806236e746b951e68192c1b124f OP_EQUALVERIFY OP_CHECKSIG",

            "address": "1Cy3Wd2pArq359z9d3VYMUoBQBM1kkANCn",
            "type": "pubkeyhash"
          }
        }
      ]

I will be able to use jq, grep, sed, awkandwc -l` to rely more than a few stuff.

Legacy OP_CHECKSIG:

cat block.json | jq -r '.tx[].vout[].scriptPubKey.asm' | grep OP_CHECKSIG | wc -l
830

Each and every OP_CHECKSIG used to rely as 1 sigop sooner than SegWit, and now counts as 4.

This yields 830 * 4 = 3,320 sigops

Naked multisig:

cat block.json | jq -r '.tx[].vout[].scriptPubKey.asm' | grep OP_CHECKMULTISIG | wc -l
890

Each and every OP_CHECKMULTISIG counted as 20 sigops sooner than SegWit, without reference to the collection of public keys.

This yields 890 * 20 * 4 = 71,200 sigops.

P2SH:

Now it will get just a little extra difficult. Since the P2SH script is best published while you spend it, we need to have a look at scriptSig at the inputs. In particular we are on the lookout for a scriptSig that is no longer any such:

1. A standard OP_CHECKSIG spend, which all the time begins with a DER encoded signature (^304.*[.*) and ends with a pubkey (0.*$).
2. P2SH wrapped v0 SegWit: ^0014.*

We also assume it contains at least one signature, which we recognise by the presence of a sighash marker like [ALL]. The script itself is the very last thing driven at the stack, which is what the awk command offers us. We then pipe that into decodescript.

cat block.json | jq -r '.tx[].vin[].scriptSig.asm'| grep . | grep -v "^304.*[.* 0.*$" | grep -v "^0014.*" | grep "[" | awk 'NF>1{print $NF}' | xargs -i -n 1 bitcoin-cli decodescript {} | jq '.asm'

The result is a very short list consisting of 13 2-of-3 multisig transactions and 1 OP_CHECKSIG.

So that yields (13 * 3 + 1) * 4 = 160 sigops

Pay to witness public key hash:

For this we look at the txinwitness field. Specifically we check if the last stack entry is a public key.

cat block.json | jq -r '.tx[].vin[].txinwitness[-1]' | grep . | grep -v null | grep "^0..*" | wc -l
3981

This yields 3,981 sigops.

Pay to witness script hash:

We once more have a look at the final thing at the witness stack, which we suppose to be the script. We do the other of P2WPK and drop all fits with a public key. We additionally drop (taproot) Schnorr signatures that are 64 bytes plus optionally 1 for the SIGHASH. We additionally drop entries that get started with 33 bytes (I believe those are Tapleaf script hashes).

cat block.json | jq -r '.tx[].vin[].txinwitness[-1]' | grep . | grep -v null | grep -v "^0..*" | sed -r '/^.{128,130}$/d' | sed -r '/^.{66}$/d' | xargs -i -n 1 bitcoin-cli decodescript {} | jq '.asm' | grep -o "OP_CHECKSIG" | wc -l
231

This yields 231 sigops.

We rely multisig similarly. First we kind them by way of N and no longer which N’s are used:

| jq -r '.tx[].vin[].txinwitness[-1]' | grep . | grep -v null | grep -v "^03.*" | sed -r '/^.{128,130}$/d' | sed -r '/^.{66}$/d' | xargs -i -n 1 bitcoin-cli decodescript {} | jq '.asm' | grep "OP_CHECKMULTISIG" | rev | kind | rev

Then rely the collection of occurrences:

• 2 instances m-of-7: 2 * 7 = 14 sigops
• 1 time m-of-4: 4 sigops
• 102 instances m-of-3: 306 sigops
• 385 instances m-of-2: 770 sigops
• 27 instances 1-of-1: 27 sigops

In order that yields 1,159 sigops.

General

3320 + 71200 + 160 + 3981 + 231 + 1159 = 80,051