Bitcoin Core  25.99.0
P2P Digital Currency
miniscript.cpp
Go to the documentation of this file.
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 
10 #include <assert.h>
11 
12 namespace miniscript {
13 namespace internal {
14 
16  int num_types = (e << "K"_mst) + (e << "V"_mst) + (e << "B"_mst) + (e << "W"_mst);
17  if (num_types == 0) return ""_mst; // No valid type, don't care about the rest
18  assert(num_types == 1); // K, V, B, W all conflict with each other
19  assert(!(e << "z"_mst) || !(e << "o"_mst)); // z conflicts with o
20  assert(!(e << "n"_mst) || !(e << "z"_mst)); // n conflicts with z
21  assert(!(e << "n"_mst) || !(e << "W"_mst)); // n conflicts with W
22  assert(!(e << "V"_mst) || !(e << "d"_mst)); // V conflicts with d
23  assert(!(e << "K"_mst) || (e << "u"_mst)); // K implies u
24  assert(!(e << "V"_mst) || !(e << "u"_mst)); // V conflicts with u
25  assert(!(e << "e"_mst) || !(e << "f"_mst)); // e conflicts with f
26  assert(!(e << "e"_mst) || (e << "d"_mst)); // e implies d
27  assert(!(e << "V"_mst) || !(e << "e"_mst)); // V conflicts with e
28  assert(!(e << "d"_mst) || !(e << "f"_mst)); // d conflicts with f
29  assert(!(e << "V"_mst) || (e << "f"_mst)); // V implies f
30  assert(!(e << "K"_mst) || (e << "s"_mst)); // K implies s
31  assert(!(e << "z"_mst) || (e << "m"_mst)); // z implies m
32  return e;
33 }
34 
35 Type ComputeType(Fragment fragment, Type x, Type y, Type z, const std::vector<Type>& sub_types, uint32_t k, size_t data_size, size_t n_subs, size_t n_keys) {
36  // Sanity check on data
37  if (fragment == Fragment::SHA256 || fragment == Fragment::HASH256) {
38  assert(data_size == 32);
39  } else if (fragment == Fragment::RIPEMD160 || fragment == Fragment::HASH160) {
40  assert(data_size == 20);
41  } else {
42  assert(data_size == 0);
43  }
44  // Sanity check on k
45  if (fragment == Fragment::OLDER || fragment == Fragment::AFTER) {
46  assert(k >= 1 && k < 0x80000000UL);
47  } else if (fragment == Fragment::MULTI) {
48  assert(k >= 1 && k <= n_keys);
49  } else if (fragment == Fragment::THRESH) {
50  assert(k >= 1 && k <= n_subs);
51  } else {
52  assert(k == 0);
53  }
54  // Sanity check on subs
55  if (fragment == Fragment::AND_V || fragment == Fragment::AND_B || fragment == Fragment::OR_B ||
56  fragment == Fragment::OR_C || fragment == Fragment::OR_I || fragment == Fragment::OR_D) {
57  assert(n_subs == 2);
58  } else if (fragment == Fragment::ANDOR) {
59  assert(n_subs == 3);
60  } else if (fragment == Fragment::WRAP_A || fragment == Fragment::WRAP_S || fragment == Fragment::WRAP_C ||
61  fragment == Fragment::WRAP_D || fragment == Fragment::WRAP_V || fragment == Fragment::WRAP_J ||
62  fragment == Fragment::WRAP_N) {
63  assert(n_subs == 1);
64  } else if (fragment != Fragment::THRESH) {
65  assert(n_subs == 0);
66  }
67  // Sanity check on keys
68  if (fragment == Fragment::PK_K || fragment == Fragment::PK_H) {
69  assert(n_keys == 1);
70  } else if (fragment == Fragment::MULTI) {
71  assert(n_keys >= 1 && n_keys <= 20);
72  } else {
73  assert(n_keys == 0);
74  }
75 
76  // Below is the per-fragment logic for computing the expression types.
77  // It heavily relies on Type's << operator (where "X << a_mst" means
78  // "X has all properties listed in a").
79  switch (fragment) {
80  case Fragment::PK_K: return "Konudemsxk"_mst;
81  case Fragment::PK_H: return "Knudemsxk"_mst;
82  case Fragment::OLDER: return
84  "h"_mst.If(!(k & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG)) |
85  "Bzfmxk"_mst;
86  case Fragment::AFTER: return
87  "i"_mst.If(k >= LOCKTIME_THRESHOLD) |
88  "j"_mst.If(k < LOCKTIME_THRESHOLD) |
89  "Bzfmxk"_mst;
90  case Fragment::SHA256: return "Bonudmk"_mst;
91  case Fragment::RIPEMD160: return "Bonudmk"_mst;
92  case Fragment::HASH256: return "Bonudmk"_mst;
93  case Fragment::HASH160: return "Bonudmk"_mst;
94  case Fragment::JUST_1: return "Bzufmxk"_mst;
95  case Fragment::JUST_0: return "Bzudemsxk"_mst;
96  case Fragment::WRAP_A: return
97  "W"_mst.If(x << "B"_mst) | // W=B_x
98  (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
99  (x & "udfems"_mst) | // u=u_x, d=d_x, f=f_x, e=e_x, m=m_x, s=s_x
100  "x"_mst; // x
101  case Fragment::WRAP_S: return
102  "W"_mst.If(x << "Bo"_mst) | // W=B_x*o_x
103  (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
104  (x & "udfemsx"_mst); // u=u_x, d=d_x, f=f_x, e=e_x, m=m_x, s=s_x, x=x_x
105  case Fragment::WRAP_C: return
106  "B"_mst.If(x << "K"_mst) | // B=K_x
107  (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
108  (x & "ondfem"_mst) | // o=o_x, n=n_x, d=d_x, f=f_x, e=e_x, m=m_x
109  "us"_mst; // u, s
110  case Fragment::WRAP_D: return
111  "B"_mst.If(x << "Vz"_mst) | // B=V_x*z_x
112  "o"_mst.If(x << "z"_mst) | // o=z_x
113  "e"_mst.If(x << "f"_mst) | // e=f_x
114  (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
115  (x & "ms"_mst) | // m=m_x, s=s_x
116  // NOTE: 'd:' is not 'u' under P2WSH as MINIMALIF is only a policy rule there.
117  "ndx"_mst; // n, d, x
118  case Fragment::WRAP_V: return
119  "V"_mst.If(x << "B"_mst) | // V=B_x
120  (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
121  (x & "zonms"_mst) | // z=z_x, o=o_x, n=n_x, m=m_x, s=s_x
122  "fx"_mst; // f, x
123  case Fragment::WRAP_J: return
124  "B"_mst.If(x << "Bn"_mst) | // B=B_x*n_x
125  "e"_mst.If(x << "f"_mst) | // e=f_x
126  (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
127  (x & "oums"_mst) | // o=o_x, u=u_x, m=m_x, s=s_x
128  "ndx"_mst; // n, d, x
129  case Fragment::WRAP_N: return
130  (x & "ghijk"_mst) | // g=g_x, h=h_x, i=i_x, j=j_x, k=k_x
131  (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
132  "ux"_mst; // u, x
133  case Fragment::AND_V: return
134  (y & "KVB"_mst).If(x << "V"_mst) | // B=V_x*B_y, V=V_x*V_y, K=V_x*K_y
135  (x & "n"_mst) | (y & "n"_mst).If(x << "z"_mst) | // n=n_x+z_x*n_y
136  ((x | y) & "o"_mst).If((x | y) << "z"_mst) | // o=o_x*z_y+z_x*o_y
137  (x & y & "dmz"_mst) | // d=d_x*d_y, m=m_x*m_y, z=z_x*z_y
138  ((x | y) & "s"_mst) | // s=s_x+s_y
139  "f"_mst.If((y << "f"_mst) || (x << "s"_mst)) | // f=f_y+s_x
140  (y & "ux"_mst) | // u=u_y, x=x_y
141  ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
142  "k"_mst.If(((x & y) << "k"_mst) &&
143  !(((x << "g"_mst) && (y << "h"_mst)) ||
144  ((x << "h"_mst) && (y << "g"_mst)) ||
145  ((x << "i"_mst) && (y << "j"_mst)) ||
146  ((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)
147  case Fragment::AND_B: return
148  (x & "B"_mst).If(y << "W"_mst) | // B=B_x*W_y
149  ((x | y) & "o"_mst).If((x | y) << "z"_mst) | // o=o_x*z_y+z_x*o_y
150  (x & "n"_mst) | (y & "n"_mst).If(x << "z"_mst) | // n=n_x+z_x*n_y
151  (x & y & "e"_mst).If((x & y) << "s"_mst) | // e=e_x*e_y*s_x*s_y
152  (x & y & "dzm"_mst) | // d=d_x*d_y, z=z_x*z_y, m=m_x*m_y
153  "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
154  ((x | y) & "s"_mst) | // s=s_x+s_y
155  "ux"_mst | // u, x
156  ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
157  "k"_mst.If(((x & y) << "k"_mst) &&
158  !(((x << "g"_mst) && (y << "h"_mst)) ||
159  ((x << "h"_mst) && (y << "g"_mst)) ||
160  ((x << "i"_mst) && (y << "j"_mst)) ||
161  ((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)
162  case Fragment::OR_B: return
163  "B"_mst.If(x << "Bd"_mst && y << "Wd"_mst) | // B=B_x*d_x*W_x*d_y
164  ((x | y) & "o"_mst).If((x | y) << "z"_mst) | // o=o_x*z_y+z_x*o_y
165  (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)
166  (x & y & "zse"_mst) | // z=z_x*z_y, s=s_x*s_y, e=e_x*e_y
167  "dux"_mst | // d, u, x
168  ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
169  (x & y & "k"_mst); // k=k_x*k_y
170  case Fragment::OR_D: return
171  (y & "B"_mst).If(x << "Bdu"_mst) | // B=B_y*B_x*d_x*u_x
172  (x & "o"_mst).If(y << "z"_mst) | // o=o_x*z_y
173  (x & y & "m"_mst).If(x << "e"_mst && (x | y) << "s"_mst) | // m=m_x*m_y*e_x*(s_x+s_y)
174  (x & y & "zs"_mst) | // z=z_x*z_y, s=s_x*s_y
175  (y & "ufde"_mst) | // u=u_y, f=f_y, d=d_y, e=e_y
176  "x"_mst | // x
177  ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
178  (x & y & "k"_mst); // k=k_x*k_y
179  case Fragment::OR_C: return
180  (y & "V"_mst).If(x << "Bdu"_mst) | // V=V_y*B_x*u_x*d_x
181  (x & "o"_mst).If(y << "z"_mst) | // o=o_x*z_y
182  (x & y & "m"_mst).If(x << "e"_mst && (x | y) << "s"_mst) | // m=m_x*m_y*e_x*(s_x+s_y)
183  (x & y & "zs"_mst) | // z=z_x*z_y, s=s_x*s_y
184  "fx"_mst | // f, x
185  ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
186  (x & y & "k"_mst); // k=k_x*k_y
187  case Fragment::OR_I: return
188  (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
189  "o"_mst.If((x & y) << "z"_mst) | // o=z_x*z_y
190  ((x | y) & "e"_mst).If((x | y) << "f"_mst) | // e=e_x*f_y+f_x*e_y
191  (x & y & "m"_mst).If((x | y) << "s"_mst) | // m=m_x*m_y*(s_x+s_y)
192  ((x | y) & "d"_mst) | // d=d_x+d_y
193  "x"_mst | // x
194  ((x | y) & "ghij"_mst) | // g=g_x+g_y, h=h_x+h_y, i=i_x+i_y, j=j_x+j_y
195  (x & y & "k"_mst); // k=k_x*k_y
196  case Fragment::ANDOR: return
197  (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
198  (x & y & z & "z"_mst) | // z=z_x*z_y*z_z
199  ((x | (y & z)) & "o"_mst).If((x | (y & z)) << "z"_mst) | // o=o_x*z_y*z_z+z_x*o_y*o_z
200  (y & z & "u"_mst) | // u=u_y*u_z
201  (z & "f"_mst).If((x << "s"_mst) || (y << "f"_mst)) | // f=(s_x+f_y)*f_z
202  (z & "d"_mst) | // d=d_z
203  (z & "e"_mst).If(x << "s"_mst || y << "f"_mst) | // e=e_z*(s_x+f_y)
204  (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)
205  (z & (x | y) & "s"_mst) | // s=s_z*(s_x+s_y)
206  "x"_mst | // x
207  ((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
208  "k"_mst.If(((x & y & z) << "k"_mst) &&
209  !(((x << "g"_mst) && (y << "h"_mst)) ||
210  ((x << "h"_mst) && (y << "g"_mst)) ||
211  ((x << "i"_mst) && (y << "j"_mst)) ||
212  ((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)
213  case Fragment::MULTI: return "Bnudemsk"_mst;
214  case Fragment::THRESH: {
215  bool all_e = true;
216  bool all_m = true;
217  uint32_t args = 0;
218  uint32_t num_s = 0;
219  Type acc_tl = "k"_mst;
220  for (size_t i = 0; i < sub_types.size(); ++i) {
221  Type t = sub_types[i];
222  if (!(t << (i ? "Wdu"_mst : "Bdu"_mst))) return ""_mst; // Require Bdu, Wdu, Wdu, ...
223  if (!(t << "e"_mst)) all_e = false;
224  if (!(t << "m"_mst)) all_m = false;
225  if (t << "s"_mst) num_s += 1;
226  args += (t << "z"_mst) ? 0 : (t << "o"_mst) ? 1 : 2;
227  acc_tl = ((acc_tl | t) & "ghij"_mst) |
228  // Thresh contains a combination of timelocks if it has threshold > 1 and
229  // it contains two different children that have different types of timelocks
230  // Note how if any of the children don't have "k", the parent also does not have "k"
231  "k"_mst.If(((acc_tl & t) << "k"_mst) && ((k <= 1) ||
232  ((k > 1) && !(((acc_tl << "g"_mst) && (t << "h"_mst)) ||
233  ((acc_tl << "h"_mst) && (t << "g"_mst)) ||
234  ((acc_tl << "i"_mst) && (t << "j"_mst)) ||
235  ((acc_tl << "j"_mst) && (t << "i"_mst))))));
236  }
237  return "Bdu"_mst |
238  "z"_mst.If(args == 0) | // z=all z
239  "o"_mst.If(args == 1) | // o=all z except one o
240  "e"_mst.If(all_e && num_s == n_subs) | // e=all e and all s
241  "m"_mst.If(all_e && all_m && num_s >= n_subs - k) | // m=all e, >=(n-k) s
242  "s"_mst.If(num_s >= n_subs - k + 1) | // s= >=(n-k+1) s
243  acc_tl; // timelock info
244  }
245  }
246  assert(false);
247 }
248 
249 size_t ComputeScriptLen(Fragment fragment, Type sub0typ, size_t subsize, uint32_t k, size_t n_subs, size_t n_keys) {
250  switch (fragment) {
251  case Fragment::JUST_1:
252  case Fragment::JUST_0: return 1;
253  case Fragment::PK_K: return 34;
254  case Fragment::PK_H: return 3 + 21;
255  case Fragment::OLDER:
256  case Fragment::AFTER: return 1 + BuildScript(k).size();
257  case Fragment::HASH256:
258  case Fragment::SHA256: return 4 + 2 + 33;
259  case Fragment::HASH160:
260  case Fragment::RIPEMD160: return 4 + 2 + 21;
261  case Fragment::MULTI: return 1 + BuildScript(n_keys).size() + BuildScript(k).size() + 34 * n_keys;
262  case Fragment::AND_V: return subsize;
263  case Fragment::WRAP_V: return subsize + (sub0typ << "x"_mst);
264  case Fragment::WRAP_S:
265  case Fragment::WRAP_C:
266  case Fragment::WRAP_N:
267  case Fragment::AND_B:
268  case Fragment::OR_B: return subsize + 1;
269  case Fragment::WRAP_A:
270  case Fragment::OR_C: return subsize + 2;
271  case Fragment::WRAP_D:
272  case Fragment::OR_D:
273  case Fragment::OR_I:
274  case Fragment::ANDOR: return subsize + 3;
275  case Fragment::WRAP_J: return subsize + 4;
276  case Fragment::THRESH: return subsize + n_subs + BuildScript(k).size();
277  }
278  assert(false);
279 }
280 
282  available = avail;
283  if (avail == Availability::NO) {
284  stack.clear();
285  size = std::numeric_limits<size_t>::max();
286  has_sig = false;
287  malleable = false;
288  non_canon = false;
289  }
290  return *this;
291 }
292 
294  has_sig = true;
295  return *this;
296 }
297 
299  non_canon = true;
300  return *this;
301 }
302 
304  malleable = x;
305  return *this;
306 }
307 
309  a.stack = Cat(std::move(a.stack), std::move(b.stack));
311  a.has_sig |= b.has_sig;
312  a.malleable |= b.malleable;
313  a.non_canon |= b.non_canon;
318  }
319  return a;
320 }
321 
323  // If only one is invalid, pick the other one. If both are invalid, pick an arbitrary one.
324  if (a.available == Availability::NO) return b;
325  if (b.available == Availability::NO) return a;
326  // If only one of the solutions has a signature, we must pick the other one.
327  if (!a.has_sig && b.has_sig) return a;
328  if (!b.has_sig && a.has_sig) return b;
329  if (!a.has_sig && !b.has_sig) {
330  // If neither solution requires a signature, the result is inevitably malleable.
331  a.malleable = true;
332  b.malleable = true;
333  } else {
334  // If both options require a signature, prefer the non-malleable one.
335  if (b.malleable && !a.malleable) return a;
336  if (a.malleable && !b.malleable) return b;
337  }
338  // Between two malleable or two non-malleable solutions, pick the smaller one between
339  // YESes, and the bigger ones between MAYBEs. Prefer YES over MAYBE.
341  return std::move(a.size <= b.size ? a : b);
343  return std::move(a.size >= b.size ? a : b);
344  } else if (a.available == Availability::YES) {
345  return a;
346  } else {
347  return b;
348  }
349 }
350 
351 std::optional<std::vector<Opcode>> DecomposeScript(const CScript& script)
352 {
353  std::vector<Opcode> out;
354  CScript::const_iterator it = script.begin(), itend = script.end();
355  while (it != itend) {
356  std::vector<unsigned char> push_data;
357  opcodetype opcode;
358  if (!script.GetOp(it, opcode, push_data)) {
359  return {};
360  } else if (opcode >= OP_1 && opcode <= OP_16) {
361  // Deal with OP_n (GetOp does not turn them into pushes).
362  push_data.assign(1, CScript::DecodeOP_N(opcode));
363  } else if (opcode == OP_CHECKSIGVERIFY) {
364  // Decompose OP_CHECKSIGVERIFY into OP_CHECKSIG OP_VERIFY
365  out.emplace_back(OP_CHECKSIG, std::vector<unsigned char>());
366  opcode = OP_VERIFY;
367  } else if (opcode == OP_CHECKMULTISIGVERIFY) {
368  // Decompose OP_CHECKMULTISIGVERIFY into OP_CHECKMULTISIG OP_VERIFY
369  out.emplace_back(OP_CHECKMULTISIG, std::vector<unsigned char>());
370  opcode = OP_VERIFY;
371  } else if (opcode == OP_EQUALVERIFY) {
372  // Decompose OP_EQUALVERIFY into OP_EQUAL OP_VERIFY
373  out.emplace_back(OP_EQUAL, std::vector<unsigned char>());
374  opcode = OP_VERIFY;
375  } else if (IsPushdataOp(opcode)) {
376  if (!CheckMinimalPush(push_data, opcode)) return {};
377  } else if (it != itend && (opcode == OP_CHECKSIG || opcode == OP_CHECKMULTISIG || opcode == OP_EQUAL) && (*it == OP_VERIFY)) {
378  // Rule out non minimal VERIFY sequences
379  return {};
380  }
381  out.emplace_back(opcode, std::move(push_data));
382  }
383  std::reverse(out.begin(), out.end());
384  return out;
385 }
386 
387 std::optional<int64_t> ParseScriptNumber(const Opcode& in) {
388  if (in.first == OP_0) {
389  return 0;
390  }
391  if (!in.second.empty()) {
392  if (IsPushdataOp(in.first) && !CheckMinimalPush(in.second, in.first)) return {};
393  try {
394  return CScriptNum(in.second, true).GetInt64();
395  } catch(const scriptnum_error&) {}
396  }
397  return {};
398 }
399 
400 int FindNextChar(Span<const char> sp, const char m)
401 {
402  for (int i = 0; i < (int)sp.size(); ++i) {
403  if (sp[i] == m) return i;
404  // We only search within the current parentheses
405  if (sp[i] == ')') break;
406  }
407  return -1;
408 }
409 
410 } // namespace internal
411 } // namespace miniscript
ArgsManager & args
Definition: bitcoind.cpp:269
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:413
static int DecodeOP_N(opcodetype opcode)
Encode/decode small integers:
Definition: script.h:505
bool GetOp(const_iterator &pc, opcodetype &opcodeRet, std::vector< unsigned char > &vchRet) const
Definition: script.h:494
int64_t GetInt64() const
Definition: script.h:340
static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG
If CTxIn::nSequence encodes a relative lock-time and this flag is set, the relative lock-time has uni...
Definition: transaction.h:112
A Span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:97
constexpr std::size_t size() const noexcept
Definition: span.h:186
This type encapsulates the miniscript type system properties.
Definition: miniscript.h:121
constexpr Type If(bool x) const
The empty type if x is false, itself otherwise.
Definition: miniscript.h:148
size_type size() const
Definition: prevector.h:291
iterator begin()
Definition: prevector.h:299
iterator end()
Definition: prevector.h:301
int FindNextChar(Span< const char > sp, const char m)
Definition: miniscript.cpp:400
std::optional< int64_t > ParseScriptNumber(const Opcode &in)
Determine whether the passed pair (created by DecomposeScript) is pushing a number.
Definition: miniscript.cpp:387
Type SanitizeType(Type e)
A helper sanitizer/checker for the output of CalcType.
Definition: miniscript.cpp:15
Type ComputeType(Fragment fragment, Type x, Type y, Type z, const std::vector< Type > &sub_types, uint32_t k, size_t data_size, size_t n_subs, size_t n_keys)
Helper function for Node::CalcType.
Definition: miniscript.cpp:35
std::optional< std::vector< Opcode > > DecomposeScript(const CScript &script)
Decode a script into opcode/push pairs.
Definition: miniscript.cpp:351
InputStack operator+(InputStack a, InputStack b)
Definition: miniscript.cpp:308
InputStack operator|(InputStack a, InputStack b)
Definition: miniscript.cpp:322
size_t ComputeScriptLen(Fragment fragment, Type sub0typ, size_t subsize, uint32_t k, size_t n_subs, size_t n_keys)
Helper function for Node::CalcScriptLen.
Definition: miniscript.cpp:249
std::pair< opcodetype, std::vector< unsigned char > > Opcode
Definition: miniscript.h:183
Fragment
The different node types in miniscript.
Definition: miniscript.h:193
@ OR_I
OP_IF [X] OP_ELSE [Y] OP_ENDIF.
@ RIPEMD160
OP_SIZE 32 OP_EQUALVERIFY OP_RIPEMD160 [hash] OP_EQUAL.
@ HASH160
OP_SIZE 32 OP_EQUALVERIFY OP_HASH160 [hash] OP_EQUAL.
@ OR_B
[X] [Y] OP_BOOLOR
@ WRAP_A
OP_TOALTSTACK [X] OP_FROMALTSTACK.
@ WRAP_V
[X] OP_VERIFY (or -VERIFY version of last opcode in X)
@ ANDOR
[X] OP_NOTIF [Z] OP_ELSE [Y] OP_ENDIF
@ THRESH
[X1] ([Xn] OP_ADD)* [k] OP_EQUAL
@ WRAP_N
[X] OP_0NOTEQUAL
@ WRAP_S
OP_SWAP [X].
@ OR_C
[X] OP_NOTIF [Y] OP_ENDIF
@ HASH256
OP_SIZE 32 OP_EQUALVERIFY OP_HASH256 [hash] OP_EQUAL.
@ OLDER
[n] OP_CHECKSEQUENCEVERIFY
@ SHA256
OP_SIZE 32 OP_EQUALVERIFY OP_SHA256 [hash] OP_EQUAL.
@ WRAP_J
OP_SIZE OP_0NOTEQUAL OP_IF [X] OP_ENDIF.
@ AFTER
[n] OP_CHECKLOCKTIMEVERIFY
@ OR_D
[X] OP_IFDUP OP_NOTIF [Y] OP_ENDIF
@ WRAP_D
OP_DUP OP_IF [X] OP_ENDIF.
@ AND_B
[X] [Y] OP_BOOLAND
@ PK_H
OP_DUP OP_HASH160 [keyhash] OP_EQUALVERIFY.
@ WRAP_C
[X] OP_CHECKSIG
@ MULTI
[k] [key_n]* [n] OP_CHECKMULTISIG
bool CheckMinimalPush(const std::vector< unsigned char > &data, opcodetype opcode)
Definition: script.cpp:346
static const unsigned int LOCKTIME_THRESHOLD
Definition: script.h:45
opcodetype
Script opcodes.
Definition: script.h:72
@ OP_CHECKMULTISIG
Definition: script.h:190
@ OP_CHECKSIG
Definition: script.h:188
@ OP_16
Definition: script.h:97
@ OP_EQUAL
Definition: script.h:144
@ OP_1
Definition: script.h:81
@ OP_VERIFY
Definition: script.h:108
@ OP_CHECKMULTISIGVERIFY
Definition: script.h:191
@ OP_CHECKSIGVERIFY
Definition: script.h:189
@ OP_0
Definition: script.h:74
@ OP_EQUALVERIFY
Definition: script.h:145
CScript BuildScript(Ts &&... inputs)
Build a script by concatenating other scripts, or any argument accepted by CScript::operator<<.
Definition: script.h:596
constexpr bool IsPushdataOp(opcodetype opcode)
Definition: solver.h:39
An object representing a sequence of witness stack elements.
Definition: miniscript.h:244
bool malleable
Whether this stack is malleable (can be turned into an equally valid other stack by a third party).
Definition: miniscript.h:254
std::vector< std::vector< unsigned char > > stack
Data elements.
Definition: miniscript.h:261
bool has_sig
Whether this stack contains a digital signature.
Definition: miniscript.h:252
InputStack & SetAvailable(Availability avail)
Change availability.
Definition: miniscript.cpp:281
Availability available
Whether this stack is valid for its intended purpose (satisfaction or dissatisfaction of a Node).
Definition: miniscript.h:250
InputStack & SetMalleable(bool x=true)
Mark this input stack as malleable.
Definition: miniscript.cpp:303
size_t size
Serialized witness size.
Definition: miniscript.h:259
bool non_canon
Whether this stack is non-canonical (using a construction known to be unnecessary for satisfaction).
Definition: miniscript.h:257
InputStack & SetWithSig()
Mark this input stack as having a signature.
Definition: miniscript.cpp:293
InputStack & SetNonCanon()
Mark this input stack as non-canonical (known to not be necessary in non-malleable satisfactions).
Definition: miniscript.cpp:298
assert(!tx.IsCoinBase())
V Cat(V v1, V &&v2)
Concatenate two vectors, moving elements.
Definition: vector.h:32