LCOV - code coverage report
Current view: top level - src/script - miniscript.cpp (source / functions) Coverage Total Hit
Test: test_bitcoin_coverage.info Lines: 96.4 % 334 322
Test Date: 2024-11-04 04:45:35 Functions: 100.0 % 12 12
Branches: 79.5 % 580 461

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2019-2022 The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #include <string>
       6                 :             : #include <vector>
       7                 :             : #include <script/script.h>
       8                 :             : #include <script/miniscript.h>
       9                 :             : #include <serialize.h>
      10                 :             : 
      11                 :             : #include <assert.h>
      12                 :             : 
      13                 :             : namespace miniscript {
      14                 :             : namespace internal {
      15                 :             : 
      16                 :       28258 : Type SanitizeType(Type e) {
      17         [ +  + ]:       28258 :     int num_types = (e << "K"_mst) + (e << "V"_mst) + (e << "B"_mst) + (e << "W"_mst);
      18         [ +  + ]:       28258 :     if (num_types == 0) return ""_mst; // No valid type, don't care about the rest
      19         [ -  + ]:       28184 :     assert(num_types == 1); // K, V, B, W all conflict with each other
      20   [ +  +  -  + ]:       28184 :     assert(!(e << "z"_mst) || !(e << "o"_mst)); // z conflicts with o
      21   [ +  +  -  + ]:       28184 :     assert(!(e << "n"_mst) || !(e << "z"_mst)); // n conflicts with z
      22   [ +  +  -  + ]:       28184 :     assert(!(e << "n"_mst) || !(e << "W"_mst)); // n conflicts with W
      23   [ +  +  -  + ]:       28184 :     assert(!(e << "V"_mst) || !(e << "d"_mst)); // V conflicts with d
      24   [ +  +  -  + ]:       28184 :     assert(!(e << "K"_mst) ||  (e << "u"_mst)); // K implies u
      25   [ +  +  -  + ]:       28184 :     assert(!(e << "V"_mst) || !(e << "u"_mst)); // V conflicts with u
      26   [ +  +  -  + ]:       28184 :     assert(!(e << "e"_mst) || !(e << "f"_mst)); // e conflicts with f
      27   [ +  +  -  + ]:       28184 :     assert(!(e << "e"_mst) ||  (e << "d"_mst)); // e implies d
      28   [ +  +  -  + ]:       28184 :     assert(!(e << "V"_mst) || !(e << "e"_mst)); // V conflicts with e
      29   [ +  +  -  + ]:       28184 :     assert(!(e << "d"_mst) || !(e << "f"_mst)); // d conflicts with f
      30   [ +  +  -  + ]:       28184 :     assert(!(e << "V"_mst) ||  (e << "f"_mst)); // V implies f
      31   [ +  +  -  + ]:       28184 :     assert(!(e << "K"_mst) ||  (e << "s"_mst)); // K implies s
      32   [ +  +  -  + ]:       28184 :     assert(!(e << "z"_mst) ||  (e << "m"_mst)); // z implies m
      33                 :       28184 :     return e;
      34                 :             : }
      35                 :             : 
      36                 :       28258 : Type ComputeType(Fragment fragment, Type x, Type y, Type z, const std::vector<Type>& sub_types, uint32_t k,
      37                 :             :                  size_t data_size, size_t n_subs, size_t n_keys, MiniscriptContext ms_ctx) {
      38                 :             :     // Sanity check on data
      39         [ +  + ]:       28258 :     if (fragment == Fragment::SHA256 || fragment == Fragment::HASH256) {
      40         [ -  + ]:         193 :         assert(data_size == 32);
      41         [ +  + ]:       28065 :     } else if (fragment == Fragment::RIPEMD160 || fragment == Fragment::HASH160) {
      42         [ -  + ]:         120 :         assert(data_size == 20);
      43                 :             :     } else {
      44         [ -  + ]:       27945 :         assert(data_size == 0);
      45                 :             :     }
      46                 :             :     // Sanity check on k
      47         [ +  + ]:       28258 :     if (fragment == Fragment::OLDER || fragment == Fragment::AFTER) {
      48         [ -  + ]:        7907 :         assert(k >= 1 && k < 0x80000000UL);
      49         [ +  + ]:       20351 :     } else if (fragment == Fragment::MULTI || fragment == Fragment::MULTI_A) {
      50   [ +  -  -  + ]:         136 :         assert(k >= 1 && k <= n_keys);
      51         [ +  + ]:       20215 :     } else if (fragment == Fragment::THRESH) {
      52   [ +  -  -  + ]:         169 :         assert(k >= 1 && k <= n_subs);
      53                 :             :     } else {
      54         [ -  + ]:       20046 :         assert(k == 0);
      55                 :             :     }
      56                 :             :     // Sanity check on subs
      57                 :       28258 :     if (fragment == Fragment::AND_V || fragment == Fragment::AND_B || fragment == Fragment::OR_B ||
      58   [ +  +  +  + ]:       28258 :         fragment == Fragment::OR_C || fragment == Fragment::OR_I || fragment == Fragment::OR_D) {
      59         [ -  + ]:        7595 :         assert(n_subs == 2);
      60         [ +  + ]:       20663 :     } else if (fragment == Fragment::ANDOR) {
      61         [ -  + ]:         155 :         assert(n_subs == 3);
      62                 :       20508 :     } else if (fragment == Fragment::WRAP_A || fragment == Fragment::WRAP_S || fragment == Fragment::WRAP_C ||
      63         [ +  + ]:       20508 :                fragment == Fragment::WRAP_D || fragment == Fragment::WRAP_V || fragment == Fragment::WRAP_J ||
      64                 :             :                fragment == Fragment::WRAP_N) {
      65         [ -  + ]:        9694 :         assert(n_subs == 1);
      66         [ +  + ]:       10814 :     } else if (fragment != Fragment::THRESH) {
      67         [ -  + ]:       10645 :         assert(n_subs == 0);
      68                 :             :     }
      69                 :             :     // Sanity check on keys
      70         [ +  + ]:       28089 :     if (fragment == Fragment::PK_K || fragment == Fragment::PK_H) {
      71         [ -  + ]:        1769 :         assert(n_keys == 1);
      72         [ +  + ]:       26489 :     } else if (fragment == Fragment::MULTI) {
      73         [ -  + ]:         119 :         assert(n_keys >= 1 && n_keys <= MAX_PUBKEYS_PER_MULTISIG);
      74         [ -  + ]:         119 :         assert(!IsTapscript(ms_ctx));
      75         [ +  + ]:       26370 :     } else if (fragment == Fragment::MULTI_A) {
      76         [ -  + ]:          17 :         assert(n_keys >= 1 && n_keys <= MAX_PUBKEYS_PER_MULTI_A);
      77         [ -  + ]:          17 :         assert(IsTapscript(ms_ctx));
      78                 :             :     } else {
      79         [ -  + ]:       26353 :         assert(n_keys == 0);
      80                 :             :     }
      81                 :             : 
      82                 :             :     // Below is the per-fragment logic for computing the expression types.
      83                 :             :     // It heavily relies on Type's << operator (where "X << a_mst" means
      84                 :             :     // "X has all properties listed in a").
      85   [ +  +  +  +  :       28258 :     switch (fragment) {
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
             +  +  +  - ]
      86                 :        1611 :         case Fragment::PK_K: return "Konudemsxk"_mst;
      87                 :         158 :         case Fragment::PK_H: return "Knudemsxk"_mst;
      88                 :        7702 :         case Fragment::OLDER: return
      89                 :        7702 :             "g"_mst.If(k & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) |
      90         [ +  + ]:        7702 :             "h"_mst.If(!(k & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG)) |
      91         [ +  + ]:       15404 :             "Bzfmxk"_mst;
      92                 :         205 :         case Fragment::AFTER: return
      93                 :         205 :             "i"_mst.If(k >= LOCKTIME_THRESHOLD) |
      94         [ +  + ]:         205 :             "j"_mst.If(k < LOCKTIME_THRESHOLD) |
      95         [ +  + ]:         410 :             "Bzfmxk"_mst;
      96                 :          85 :         case Fragment::SHA256: return "Bonudmk"_mst;
      97                 :          68 :         case Fragment::RIPEMD160: return "Bonudmk"_mst;
      98                 :         108 :         case Fragment::HASH256: return "Bonudmk"_mst;
      99                 :          52 :         case Fragment::HASH160: return "Bonudmk"_mst;
     100                 :         232 :         case Fragment::JUST_1: return "Bzufmxk"_mst;
     101                 :         288 :         case Fragment::JUST_0: return "Bzudemsxk"_mst;
     102                 :        7050 :         case Fragment::WRAP_A: return
     103                 :        7050 :             "W"_mst.If(x << "B"_mst) | // W=B_x
     104         [ +  - ]:        7050 :             (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
     105                 :       14100 :             (x & "udfems"_mst) | // u=u_x, d=d_x, f=f_x, e=e_x, m=m_x, s=s_x
     106         [ +  - ]:       14100 :             "x"_mst; // x
     107                 :          73 :         case Fragment::WRAP_S: return
     108                 :          73 :             "W"_mst.If(x << "Bo"_mst) | // W=B_x*o_x
     109         [ +  - ]:          73 :             (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
     110         [ +  - ]:         146 :             (x & "udfemsx"_mst); // u=u_x, d=d_x, f=f_x, e=e_x, m=m_x, s=s_x, x=x_x
     111                 :        1720 :         case Fragment::WRAP_C: return
     112                 :        1720 :             "B"_mst.If(x << "K"_mst) | // B=K_x
     113         [ +  + ]:        1720 :             (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
     114                 :        3440 :             (x & "ondfem"_mst) | // o=o_x, n=n_x, d=d_x, f=f_x, e=e_x, m=m_x
     115         [ +  + ]:        3438 :             "us"_mst; // u, s
     116                 :          93 :         case Fragment::WRAP_D: return
     117                 :          93 :             "B"_mst.If(x << "Vz"_mst) | // B=V_x*z_x
     118         [ +  - ]:          93 :             "o"_mst.If(x << "z"_mst) | // o=z_x
     119         [ +  - ]:          93 :             "e"_mst.If(x << "f"_mst) | // e=f_x
     120         [ +  - ]:          93 :             (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
     121                 :         186 :             (x & "ms"_mst) | // m=m_x, s=s_x
     122                 :             :             // NOTE: 'd:' is 'u' under Tapscript but not P2WSH as MINIMALIF is only a policy rule there.
     123   [ +  +  +  - ]:         119 :             "u"_mst.If(IsTapscript(ms_ctx)) |
     124                 :         186 :             "ndx"_mst; // n, d, x
     125                 :         572 :         case Fragment::WRAP_V: return
     126         [ +  + ]:        1140 :             "V"_mst.If(x << "B"_mst) | // V=B_x
     127                 :         572 :             (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
     128                 :        1144 :             (x & "zonms"_mst) | // z=z_x, o=o_x, n=n_x, m=m_x, s=s_x
     129         [ +  + ]:        1140 :             "fx"_mst; // f, x
     130                 :          16 :         case Fragment::WRAP_J: return
     131                 :          16 :             "B"_mst.If(x << "Bn"_mst) | // B=B_x*n_x
     132         [ +  - ]:          16 :             "e"_mst.If(x << "f"_mst) | // e=f_x
     133         [ +  + ]:          16 :             (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
     134                 :          32 :             (x & "oums"_mst) | // o=o_x, u=u_x, m=m_x, s=s_x
     135         [ +  + ]:          32 :             "ndx"_mst; // n, d, x
     136                 :         170 :         case Fragment::WRAP_N: return
     137                 :         170 :             (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
     138                 :         170 :             (x & "Bzondfems"_mst) | // B=B_x, z=z_x, o=o_x, n=n_x, d=d_x, f=f_x, e=e_x, m=m_x, s=s_x
     139                 :         170 :             "ux"_mst; // u, x
     140                 :         453 :         case Fragment::AND_V: return
     141         [ +  + ]:         892 :             (y & "KVB"_mst).If(x << "V"_mst) | // B=V_x*B_y, V=V_x*V_y, K=V_x*K_y
     142         [ +  + ]:         453 :             (x & "n"_mst) | (y & "n"_mst).If(x << "z"_mst) | // n=n_x+z_x*n_y
     143         [ +  + ]:         453 :             ((x | y) & "o"_mst).If((x | y) << "z"_mst) | // o=o_x*z_y+z_x*o_y
     144         [ +  + ]:         453 :             (x & y & "dmz"_mst) | // d=d_x*d_y, m=m_x*m_y, z=z_x*z_y
     145         [ +  + ]:         453 :             ((x | y) & "s"_mst) | // s=s_x+s_y
     146         [ +  + ]:         220 :             "f"_mst.If((y << "f"_mst) || (x << "s"_mst)) | // f=f_y+s_x
     147         [ +  + ]:         453 :             (y & "ux"_mst) | // u=u_y, x=x_y
     148         [ +  + ]:         453 :             ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
     149   [ +  +  +  + ]:         453 :             "k"_mst.If(((x & y) << "k"_mst) &&
     150   [ +  +  +  -  :         886 :                 !(((x << "g"_mst) && (y << "h"_mst)) ||
             +  +  +  + ]
     151   [ +  +  +  -  :         443 :                 ((x << "h"_mst) && (y << "g"_mst)) ||
                   +  + ]
     152   [ +  +  +  - ]:         443 :                 ((x << "i"_mst) && (y << "j"_mst)) ||
     153   [ +  +  +  - ]:         896 :                 ((x << "j"_mst) && (y << "i"_mst)))); // k=k_x*k_y*!(g_x*h_y + h_x*g_y + i_x*j_y + j_x*i_y)
     154                 :        6853 :         case Fragment::AND_B: return
     155                 :        6853 :             (x & "B"_mst).If(y << "W"_mst) | // B=B_x*W_y
     156   [ +  +  +  + ]:       12870 :             ((x | y) & "o"_mst).If((x | y) << "z"_mst) | // o=o_x*z_y+z_x*o_y
     157         [ +  + ]:        6853 :             (x & "n"_mst) | (y & "n"_mst).If(x << "z"_mst) | // n=n_x+z_x*n_y
     158   [ +  +  +  + ]:        7668 :             (x & y & "e"_mst).If((x & y) << "s"_mst) | // e=e_x*e_y*s_x*s_y
     159         [ +  + ]:        6853 :             (x & y & "dzm"_mst) | // d=d_x*d_y, z=z_x*z_y, m=m_x*m_y
     160   [ +  -  +  - ]:        6826 :             "f"_mst.If(((x & y) << "f"_mst) || (x << "sf"_mst) || (y << "sf"_mst)) | // f=f_x*f_y + f_x*s_x + f_y*s_y
     161                 :       13706 :             ((x | y) & "s"_mst) | // s=s_x+s_y
     162         [ +  + ]:        6853 :             "ux"_mst | // u, x
     163         [ +  + ]:        6853 :             ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
     164   [ +  +  +  + ]:        6853 :             "k"_mst.If(((x & y) << "k"_mst) &&
     165   [ +  +  -  +  :       13696 :                 !(((x << "g"_mst) && (y << "h"_mst)) ||
             +  +  +  + ]
     166   [ +  +  +  +  :        6847 :                 ((x << "h"_mst) && (y << "g"_mst)) ||
                   -  + ]
     167   [ -  +  -  - ]:        6845 :                 ((x << "i"_mst) && (y << "j"_mst)) ||
     168   [ +  +  -  + ]:       13698 :                 ((x << "j"_mst) && (y << "i"_mst)))); // k=k_x*k_y*!(g_x*h_y + h_x*g_y + i_x*j_y + j_x*i_y)
     169                 :          33 :         case Fragment::OR_B: return
     170         [ +  + ]:          37 :             "B"_mst.If(x << "Bd"_mst && y << "Wd"_mst) | // B=B_x*d_x*W_x*d_y
     171   [ +  +  +  + ]:          45 :             ((x | y) & "o"_mst).If((x | y) << "z"_mst) | // o=o_x*z_y+z_x*o_y
     172         [ +  + ]:          25 :             (x & y & "m"_mst).If((x | y) << "s"_mst && (x & y) << "e"_mst) | // m=m_x*m_y*e_x*e_y*(s_x+s_y)
     173                 :          66 :             (x & y & "zse"_mst) | // z=z_x*z_y, s=s_x*s_y, e=e_x*e_y
     174         [ +  + ]:          33 :             "dux"_mst | // d, u, x
     175         [ +  + ]:          33 :             ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
     176         [ +  + ]:          66 :             (x & y & "k"_mst); // k=k_x*k_y
     177                 :          66 :         case Fragment::OR_D: return
     178                 :          66 :             (y & "B"_mst).If(x << "Bdu"_mst) | // B=B_y*B_x*d_x*u_x
     179   [ +  +  +  + ]:          90 :             (x & "o"_mst).If(y << "z"_mst) | // o=o_x*z_y
     180         [ +  + ]:          52 :             (x & y & "m"_mst).If(x << "e"_mst && (x | y) << "s"_mst) | // m=m_x*m_y*e_x*(s_x+s_y)
     181                 :         132 :             (x & y & "zs"_mst) | // z=z_x*z_y, s=s_x*s_y
     182                 :         132 :             (y & "ufde"_mst) | // u=u_y, f=f_y, d=d_y, e=e_y
     183         [ +  + ]:          66 :             "x"_mst | // x
     184         [ +  + ]:          66 :             ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
     185         [ +  + ]:         132 :             (x & y & "k"_mst); // k=k_x*k_y
     186                 :          20 :         case Fragment::OR_C: return
     187                 :          20 :             (y & "V"_mst).If(x << "Bdu"_mst) | // V=V_y*B_x*u_x*d_x
     188   [ +  +  +  + ]:          36 :             (x & "o"_mst).If(y << "z"_mst) | // o=o_x*z_y
     189         [ +  + ]:          16 :             (x & y & "m"_mst).If(x << "e"_mst && (x | y) << "s"_mst) | // m=m_x*m_y*e_x*(s_x+s_y)
     190                 :          40 :             (x & y & "zs"_mst) | // z=z_x*z_y, s=s_x*s_y
     191         [ +  + ]:          20 :             "fx"_mst | // f, x
     192         [ +  + ]:          20 :             ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
     193         [ +  + ]:          40 :             (x & y & "k"_mst); // k=k_x*k_y
     194                 :         170 :         case Fragment::OR_I: return
     195                 :         170 :             (x & y & "VBKufs"_mst) | // V=V_x*V_y, B=B_x*B_y, K=K_x*K_y, u=u_x*u_y, f=f_x*f_y, s=s_x*s_y
     196                 :         170 :             "o"_mst.If((x & y) << "z"_mst) | // o=z_x*z_y
     197         [ +  + ]:         170 :             ((x | y) & "e"_mst).If((x | y) << "f"_mst) | // e=e_x*f_y+f_x*e_y
     198         [ +  + ]:         170 :             (x & y & "m"_mst).If((x | y) << "s"_mst) | // m=m_x*m_y*(s_x+s_y)
     199                 :         340 :             ((x | y) & "d"_mst) | // d=d_x+d_y
     200         [ +  + ]:         170 :             "x"_mst | // x
     201         [ +  + ]:         170 :             ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
     202         [ +  + ]:         340 :             (x & y & "k"_mst); // k=k_x*k_y
     203                 :         155 :         case Fragment::ANDOR: return
     204         [ +  + ]:         302 :             (y & z & "BKV"_mst).If(x << "Bdu"_mst) | // B=B_x*d_x*u_x*B_y*B_z, K=B_x*d_x*u_x*K_y*K_z, V=B_x*d_x*u_x*V_y*V_z
     205                 :         310 :             (x & y & z & "z"_mst) | // z=z_x*z_y*z_z
     206   [ +  +  +  + ]:         267 :             ((x | (y & z)) & "o"_mst).If((x | (y & z)) << "z"_mst) | // o=o_x*z_y*z_z+z_x*o_y*o_z
     207         [ +  + ]:         155 :             (y & z & "u"_mst) | // u=u_y*u_z
     208   [ +  +  +  + ]:         155 :             (z & "f"_mst).If((x << "s"_mst) || (y << "f"_mst)) | // f=(s_x+f_y)*f_z
     209         [ +  + ]:         155 :             (z & "d"_mst) | // d=d_z
     210   [ +  +  +  + ]:         155 :             (z & "e"_mst).If(x << "s"_mst || y << "f"_mst) | // e=e_z*(s_x+f_y)
     211         [ +  + ]:         127 :             (x & y & z & "m"_mst).If(x << "e"_mst && (x | y | z) << "s"_mst) | // m=m_x*m_y*m_z*e_x*(s_x+s_y+s_z)
     212                 :         310 :             (z & (x | y) & "s"_mst) | // s=s_z*(s_x+s_y)
     213         [ +  + ]:         155 :             "x"_mst | // x
     214         [ +  + ]:         155 :             ((x | y | z) & "ghij"_mst) | // g=g_x+g_y+g_z, h=h_x+h_y+h_z, i=i_x+i_y+i_z, j=j_x+j_y_j_z
     215   [ +  +  -  + ]:         155 :             "k"_mst.If(((x & y & z) << "k"_mst) &&
     216   [ -  +  -  -  :         298 :                 !(((x << "g"_mst) && (y << "h"_mst)) ||
             -  +  +  + ]
     217   [ -  +  -  -  :         149 :                 ((x << "h"_mst) && (y << "g"_mst)) ||
                   -  + ]
     218   [ -  +  -  - ]:         149 :                 ((x << "i"_mst) && (y << "j"_mst)) ||
     219   [ +  +  +  - ]:         304 :                 ((x << "j"_mst) && (y << "i"_mst)))); // k=k_x*k_y*k_z* !(g_x*h_y + h_x*g_y + i_x*j_y + j_x*i_y)
     220                 :         119 :         case Fragment::MULTI: {
     221                 :         119 :             return "Bnudemsk"_mst;
     222                 :             :         }
     223                 :          17 :         case Fragment::MULTI_A: {
     224                 :          17 :             return "Budemsk"_mst;
     225                 :             :         }
     226                 :         169 :         case Fragment::THRESH: {
     227                 :         169 :             bool all_e = true;
     228                 :         169 :             bool all_m = true;
     229                 :         169 :             uint32_t args = 0;
     230                 :         169 :             uint32_t num_s = 0;
     231                 :         169 :             Type acc_tl = "k"_mst;
     232         [ +  + ]:         555 :             for (size_t i = 0; i < sub_types.size(); ++i) {
     233         [ +  + ]:         388 :                 Type t = sub_types[i];
     234                 :         388 :                 static constexpr auto WDU{"Wdu"_mst}, BDU{"Bdu"_mst};
     235   [ +  +  +  + ]:         388 :                 if (!(t << (i ? WDU : BDU))) return ""_mst; // Require Bdu, Wdu, Wdu, ...
     236         [ +  + ]:         386 :                 if (!(t << "e"_mst)) all_e = false;
     237         [ -  + ]:         386 :                 if (!(t << "m"_mst)) all_m = false;
     238         [ +  + ]:         386 :                 if (t << "s"_mst) num_s += 1;
     239   [ +  -  +  + ]:         386 :                 args += (t << "z"_mst) ? 0 : (t << "o"_mst) ? 1 : 2;
     240                 :         386 :                 acc_tl = ((acc_tl | t) & "ghij"_mst) |
     241                 :             :                     // Thresh contains a combination of timelocks if it has threshold > 1 and
     242                 :             :                     // it contains two different children that have different types of timelocks
     243                 :             :                     // Note how if any of the children don't have "k", the parent also does not have "k"
     244   [ +  +  +  + ]:         386 :                     "k"_mst.If(((acc_tl & t) << "k"_mst) && ((k <= 1) ||
     245   [ -  +  -  -  :         476 :                         ((k > 1) && !(((acc_tl << "g"_mst) && (t << "h"_mst)) ||
             +  +  +  + ]
     246   [ +  +  +  -  :         242 :                         ((acc_tl << "h"_mst) && (t << "g"_mst)) ||
                   +  + ]
     247   [ +  +  -  + ]:         242 :                         ((acc_tl << "i"_mst) && (t << "j"_mst)) ||
     248   [ +  +  +  - ]:         446 :                         ((acc_tl << "j"_mst) && (t << "i"_mst))))));
     249                 :             :             }
     250                 :         334 :             return "Bdu"_mst |
     251                 :         167 :                    "z"_mst.If(args == 0) | // z=all z
     252   [ -  +  -  + ]:         167 :                    "o"_mst.If(args == 1) | // o=all z except one o
     253   [ +  +  +  +  :         167 :                    "e"_mst.If(all_e && num_s == n_subs) | // e=all e and all s
                   -  + ]
     254   [ +  +  +  + ]:         167 :                    "m"_mst.If(all_e && all_m && num_s >= n_subs - k) | // m=all e, >=(n-k) s
     255   [ +  +  +  + ]:         314 :                    "s"_mst.If(num_s >= n_subs - k + 1) |  // s= >=(n-k+1) s
     256                 :         167 :                    acc_tl; // timelock info
     257                 :             :             }
     258                 :             :     }
     259                 :           0 :     assert(false);
     260                 :             : }
     261                 :             : 
     262                 :       28258 : size_t ComputeScriptLen(Fragment fragment, Type sub0typ, size_t subsize, uint32_t k, size_t n_subs,
     263                 :             :                         size_t n_keys, MiniscriptContext ms_ctx) {
     264   [ +  +  +  +  :       28258 :     switch (fragment) {
          +  +  +  +  +  
          +  +  +  +  +  
                   -  + ]
     265                 :             :         case Fragment::JUST_1:
     266                 :             :         case Fragment::JUST_0: return 1;
     267         [ +  + ]:        1611 :         case Fragment::PK_K: return IsTapscript(ms_ctx) ? 33 : 34;
     268                 :         158 :         case Fragment::PK_H: return 3 + 21;
     269                 :        7907 :         case Fragment::OLDER:
     270         [ -  + ]:        7907 :         case Fragment::AFTER: return 1 + BuildScript(k).size();
     271                 :         193 :         case Fragment::HASH256:
     272                 :         193 :         case Fragment::SHA256: return 4 + 2 + 33;
     273                 :         120 :         case Fragment::HASH160:
     274                 :         120 :         case Fragment::RIPEMD160: return 4 + 2 + 21;
     275   [ -  +  +  - ]:         238 :         case Fragment::MULTI: return 1 + BuildScript(n_keys).size() + BuildScript(k).size() + 34 * n_keys;
     276         [ -  + ]:          17 :         case Fragment::MULTI_A: return (1 + 32 + 1) * n_keys + BuildScript(k).size() + 1;
     277                 :         453 :         case Fragment::AND_V: return subsize;
     278                 :         572 :         case Fragment::WRAP_V: return subsize + (sub0typ << "x"_mst);
     279                 :        8849 :         case Fragment::WRAP_S:
     280                 :        8849 :         case Fragment::WRAP_C:
     281                 :        8849 :         case Fragment::WRAP_N:
     282                 :        8849 :         case Fragment::AND_B:
     283                 :        8849 :         case Fragment::OR_B: return subsize + 1;
     284                 :        7070 :         case Fragment::WRAP_A:
     285                 :        7070 :         case Fragment::OR_C: return subsize + 2;
     286                 :         484 :         case Fragment::WRAP_D:
     287                 :         484 :         case Fragment::OR_D:
     288                 :         484 :         case Fragment::OR_I:
     289                 :         484 :         case Fragment::ANDOR: return subsize + 3;
     290                 :          16 :         case Fragment::WRAP_J: return subsize + 4;
     291         [ -  + ]:         169 :         case Fragment::THRESH: return subsize + n_subs + BuildScript(k).size();
     292                 :             :     }
     293                 :           0 :     assert(false);
     294                 :             : }
     295                 :             : 
     296                 :     1446614 : InputStack& InputStack::SetAvailable(Availability avail) {
     297                 :     1446614 :     available = avail;
     298         [ +  + ]:     1446614 :     if (avail == Availability::NO) {
     299                 :     1256286 :         stack.clear();
     300                 :     1256286 :         size = std::numeric_limits<size_t>::max();
     301                 :     1256286 :         has_sig = false;
     302                 :     1256286 :         malleable = false;
     303                 :     1256286 :         non_canon = false;
     304                 :             :     }
     305                 :     1446614 :     return *this;
     306                 :             : }
     307                 :             : 
     308                 :      379266 : InputStack& InputStack::SetWithSig() {
     309                 :      379266 :     has_sig = true;
     310                 :      379266 :     return *this;
     311                 :             : }
     312                 :             : 
     313                 :      818292 : InputStack& InputStack::SetNonCanon() {
     314                 :      818292 :     non_canon = true;
     315                 :      818292 :     return *this;
     316                 :             : }
     317                 :             : 
     318                 :      817206 : InputStack& InputStack::SetMalleable(bool x) {
     319                 :      817206 :     malleable = x;
     320                 :      817206 :     return *this;
     321                 :             : }
     322                 :             : 
     323                 :     1713258 : InputStack operator+(InputStack a, InputStack b) {
     324         [ +  - ]:     1713258 :     a.stack = Cat(std::move(a.stack), std::move(b.stack));
     325   [ +  +  +  + ]:     1713258 :     if (a.available != Availability::NO && b.available != Availability::NO) a.size += b.size;
     326                 :     1713258 :     a.has_sig |= b.has_sig;
     327                 :     1713258 :     a.malleable |= b.malleable;
     328                 :     1713258 :     a.non_canon |= b.non_canon;
     329   [ +  +  +  + ]:     1713258 :     if (a.available == Availability::NO || b.available == Availability::NO) {
     330                 :     1065236 :         a.SetAvailable(Availability::NO);
     331   [ +  -  -  + ]:      648022 :     } else if (a.available == Availability::MAYBE || b.available == Availability::MAYBE) {
     332                 :           0 :         a.SetAvailable(Availability::MAYBE);
     333                 :             :     }
     334                 :     1713258 :     return a;
     335                 :             : }
     336                 :             : 
     337                 :      851124 : InputStack operator|(InputStack a, InputStack b) {
     338                 :             :     // If only one is invalid, pick the other one. If both are invalid, pick an arbitrary one.
     339         [ +  + ]:      851124 :     if (a.available == Availability::NO) return b;
     340         [ +  + ]:      760322 :     if (b.available == Availability::NO) return a;
     341                 :             :     // If only one of the solutions has a signature, we must pick the other one.
     342   [ +  +  +  + ]:      208842 :     if (!a.has_sig && b.has_sig) return a;
     343   [ +  +  +  + ]:       10804 :     if (!b.has_sig && a.has_sig) return b;
     344   [ +  +  +  - ]:       10620 :     if (!a.has_sig && !b.has_sig) {
     345                 :             :         // If neither solution requires a signature, the result is inevitably malleable.
     346                 :        1048 :         a.malleable = true;
     347                 :        1048 :         b.malleable = true;
     348                 :             :     } else {
     349                 :             :         // If both options require a signature, prefer the non-malleable one.
     350   [ +  +  +  - ]:        9572 :         if (b.malleable && !a.malleable) return a;
     351   [ -  +  -  - ]:        9542 :         if (a.malleable && !b.malleable) return b;
     352                 :             :     }
     353                 :             :     // Between two malleable or two non-malleable solutions, pick the smaller one between
     354                 :             :     // YESes, and the bigger ones between MAYBEs. Prefer YES over MAYBE.
     355   [ +  -  +  - ]:       10590 :     if (a.available == Availability::YES && b.available == Availability::YES) {
     356         [ +  + ]:       11330 :         return std::move(a.size <= b.size ? a : b);
     357   [ #  #  #  # ]:           0 :     } else if (a.available == Availability::MAYBE && b.available == Availability::MAYBE) {
     358         [ #  # ]:           0 :         return std::move(a.size >= b.size ? a : b);
     359         [ #  # ]:           0 :     } else if (a.available == Availability::YES) {
     360                 :           0 :         return a;
     361                 :             :     } else {
     362                 :           0 :         return b;
     363                 :             :     }
     364                 :             : }
     365                 :             : 
     366                 :         531 : std::optional<std::vector<Opcode>> DecomposeScript(const CScript& script)
     367                 :             : {
     368                 :         531 :     std::vector<Opcode> out;
     369         [ +  + ]:        1062 :     CScript::const_iterator it = script.begin(), itend = script.end();
     370         [ +  + ]:       18760 :     while (it != itend) {
     371                 :       18233 :         std::vector<unsigned char> push_data;
     372                 :       18233 :         opcodetype opcode;
     373   [ +  -  -  + ]:       18233 :         if (!script.GetOp(it, opcode, push_data)) {
     374                 :           0 :             return {};
     375         [ +  + ]:       18233 :         } else if (opcode >= OP_1 && opcode <= OP_16) {
     376                 :             :             // Deal with OP_n (GetOp does not turn them into pushes).
     377         [ +  - ]:        2537 :             push_data.assign(1, CScript::DecodeOP_N(opcode));
     378         [ +  + ]:       15696 :         } else if (opcode == OP_CHECKSIGVERIFY) {
     379                 :             :             // Decompose OP_CHECKSIGVERIFY into OP_CHECKSIG OP_VERIFY
     380         [ +  - ]:          68 :             out.emplace_back(OP_CHECKSIG, std::vector<unsigned char>());
     381                 :          68 :             opcode = OP_VERIFY;
     382         [ +  + ]:       15628 :         } else if (opcode == OP_CHECKMULTISIGVERIFY) {
     383                 :             :             // Decompose OP_CHECKMULTISIGVERIFY into OP_CHECKMULTISIG OP_VERIFY
     384         [ +  - ]:           4 :             out.emplace_back(OP_CHECKMULTISIG, std::vector<unsigned char>());
     385                 :           4 :             opcode = OP_VERIFY;
     386         [ +  + ]:       15624 :         } else if (opcode == OP_EQUALVERIFY) {
     387                 :             :             // Decompose OP_EQUALVERIFY into OP_EQUAL OP_VERIFY
     388         [ +  - ]:         560 :             out.emplace_back(OP_EQUAL, std::vector<unsigned char>());
     389                 :         560 :             opcode = OP_VERIFY;
     390         [ +  + ]:       15064 :         } else if (opcode == OP_NUMEQUALVERIFY) {
     391                 :             :             // Decompose OP_NUMEQUALVERIFY into OP_NUMEQUAL OP_VERIFY
     392         [ +  - ]:           1 :             out.emplace_back(OP_NUMEQUAL, std::vector<unsigned char>());
     393                 :           1 :             opcode = OP_VERIFY;
     394         [ +  + ]:       15063 :         } else if (IsPushdataOp(opcode)) {
     395   [ +  -  +  + ]:        1801 :             if (!CheckMinimalPush(push_data, opcode)) return {};
     396   [ +  +  +  +  :       13262 :         } else if (it != itend && (opcode == OP_CHECKSIG || opcode == OP_CHECKMULTISIG || opcode == OP_EQUAL || opcode == OP_NUMEQUAL) && (*it == OP_VERIFY)) {
                   +  + ]
     397                 :             :             // Rule out non minimal VERIFY sequences
     398                 :           2 :             return {};
     399                 :             :         }
     400         [ +  - ]:       18229 :         out.emplace_back(opcode, std::move(push_data));
     401                 :       18233 :     }
     402                 :         527 :     std::reverse(out.begin(), out.end());
     403                 :         527 :     return out;
     404                 :         531 : }
     405                 :             : 
     406                 :        2891 : std::optional<int64_t> ParseScriptNumber(const Opcode& in) {
     407         [ -  + ]:        2891 :     if (in.first == OP_0) {
     408                 :           0 :         return 0;
     409                 :             :     }
     410         [ +  - ]:        2891 :     if (!in.second.empty()) {
     411   [ +  +  -  + ]:        2891 :         if (IsPushdataOp(in.first) && !CheckMinimalPush(in.second, in.first)) return {};
     412                 :        2891 :         try {
     413         [ +  - ]:        2891 :             return CScriptNum(in.second, true).GetInt64();
     414         [ -  - ]:           0 :         } catch(const scriptnum_error&) {}
     415                 :             :     }
     416                 :           0 :     return {};
     417                 :             : }
     418                 :             : 
     419                 :        6733 : int FindNextChar(Span<const char> sp, const char m)
     420                 :             : {
     421         [ +  - ]:       85255 :     for (int i = 0; i < (int)sp.size(); ++i) {
     422         [ +  + ]:       85255 :         if (sp[i] == m) return i;
     423                 :             :         // We only search within the current parentheses
     424         [ +  + ]:       78547 :         if (sp[i] == ')') break;
     425                 :             :     }
     426                 :             :     return -1;
     427                 :             : }
     428                 :             : 
     429                 :             : } // namespace internal
     430                 :             : } // namespace miniscript
        

Generated by: LCOV version 2.0-1