btcdeb miniscript support

Author: kallewoof

Makefile.am

@@ -124,6 +124,8 @@ libkerl_a_SOURCES = kerl/kerl.c kerl/kerl.h
 btcdeb_SOURCES = \
 	instance.h \
 	instance.cpp \
+	msenv.h \
+	msenv.cpp \
 	functions.h \
 	functions.cpp \
 	btcdeb.cpp \
@@ -173,6 +175,8 @@ btcc_LDADD = \
 test_btcdeb_SOURCES = \
 	instance.h \
 	instance.cpp \
+	msenv.h \
+	msenv.cpp \
 	functions.h \
 	functions.cpp \
 	test/catch.hpp \

ansi-colors.h

@@ -32,6 +32,72 @@ const std::string bg_magenta("\033[0;45m");
 const std::string bg_cyan   ("\033[0;46m");
 const std::string bg_white  ("\033[0;47m");
 
+inline size_t length(const std::string& s) {
+    size_t l = 0;
+    for (size_t i = 0; s[i]; ++i) {
+        char ch = s[i];
+        if (ch == 033) {
+            for (++i; s[i] != 'm'; ++i);
+            continue;
+        }
+        ++l;
+    }
+    return l;
+}
+
+inline std::string substring(const std::string& s, size_t start, size_t length) {
+    char buf[1024];
+    size_t p = 0;
+    size_t l = 0;
+    size_t end = start + length;
+    for (size_t i = 0; l < end && s[i]; ++i) {
+        bool xfer = l >= start;
+        if (s[i] == 033) {
+            if (xfer) buf[p++] = s[i];
+            for (++i; s[i] != 'm'; ++i) if (xfer) buf[p++] = s[i];
+            if (xfer) buf[p++] = s[i];
+            continue;
+        }
+        if (xfer) buf[p++] = s[i];
+        ++l;
+    }
+    buf[p] = 0;
+    return std::string(buf) + reset;
+}
+
+inline std::string trimmed_right(const std::string& s) {
+    size_t len = s.length();
+    if (len == 0) return s;
+    size_t j;
+    for (size_t i = len - 1; i > 1; --i) {
+        switch (s[i]) {
+            case ' ':
+            case '\t':
+            case '\n':
+                continue;
+            case 'm':
+                // ansi sequence?
+                j = i - 1;
+                while (j > 0 && s[j] >= '0' && s[j] <= '9') --j;
+                if (j > 0 && s[j] == ';') {
+                    --j;
+                    while (j > 0 && s[j] >= '0' && s[j] <= '9') --j;
+                    if (j > 0 && s[j] == ']') {
+                        if (s[j] == 033) {
+                            i = j;
+                            continue;
+                        }
+                    }
+                }
+                // nope, not an ansi sequence; we're done! fall-through
+            default:
+                return s.substr(0, i + 1);
+        }
+    }
+    // the entire string was whitespace and/or ansi codes
+    return "";
+}
+
 } // namespace ansi
 
 #endif // included_ansicolors_h_

approach.cpp

@@ -55,7 +55,7 @@ int main(int argc, char* const* argv)
         btc_logf("approach %d.%d.%d -- type `%s -h` for start up options\n", CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR, CLIENT_VERSION_REVISION, argv[0]);
     }
 
-    COMPILER_CTX.SymbolicOutputs = true;
+    COMPILER_CTX.symbolic_outputs = true;
 
     char* script_str = nullptr;
     if (pipe_in) {

approach.functions.cpp

@@ -34,7 +34,7 @@ int fn_rewind(const char* arg) {
 }
 
 int fn_script(const char* arg) {
-    CScript script = env->m_root.m_node->ToScript(COMPILER_CTX);
+    CScript& script = env->m_script;
     CScript::const_iterator it = script.begin();
     opcodetype opcode;
     std::vector<uint8_t> vchPushValue;

btcdeb.cpp

@@ -176,6 +176,13 @@ int main(int argc, char* const* argv)
         script_str = strdup(ca.l[0]);
         ca.l.erase(ca.l.begin(), ca.l.begin() + 1);
     }
+
+    if (ca.m.count('P')) {
+        if (!instance.parse_pretend_valid_expr(ca.m['P'].c_str())) {
+            return 1;
+        }
+    }
+
     CScript script;
     if (script_str) {
         if (instance.parse_script(script_str)) {
@@ -189,12 +196,6 @@ int main(int argc, char* const* argv)
 
     instance.parse_stack_args(ca.l);
 
-    if (ca.m.count('P')) {
-        if (!instance.parse_pretend_valid_expr(ca.m['P'].c_str())) {
-            return 1;
-        }
-    }
-
     if (instance.txin && instance.tx && ca.l.size() == 0 && instance.script.size() == 0) {
         if (!instance.configure_tx_txin()) return 1;
     }

functions.cpp

@@ -1,6 +1,9 @@
 
+#include <sstream>
+
 #include <functions.h>
 #include <value.h>
+#include <ansi-colors.h>
 
 InterpreterEnv* env;
 Instance instance;
@@ -105,6 +108,19 @@ void print_dualstack() {
         if (s.length() > rmax) rmax = s.length();
         r.push_back(s);
     }
+
+    if (r.size() > 0 && instance.msenv) r.push_back(""); // spacing between stack and miniscript
+    size_t ms_start = r.size();
+
+    // miniscript representation
+    if (instance.msenv) {
+        std::istringstream ms(instance.msenv->TreeString(env->curr_op_seq));
+        for (std::string l; std::getline(ms, l); ) {
+            if (ansi::length(l) > rmax) rmax = ansi::length(l);
+            r.push_back(l);
+        }
+    }
+
     if (glmax < lmax) glmax = lmax;
     if (grmax < rmax) grmax = rmax;
     lmax = glmax; rmax = grmax;
@@ -133,8 +149,15 @@ void print_dualstack() {
         printf("| ");
         if (ri < r.size()) {
             auto s = r[ri++];
-            if (s.length() > rcap) s = s.substr(0, rcap-3) + "...";
-            printf(rfmt, s.c_str());
+            if (ms_start > ri) {
+                // printing stack items; right-align, no ansi
+                if (s.length() > rcap) s = s.substr(0, rcap-3) + "...";
+                printf(rfmt, s.c_str());
+            } else {
+                // printing miniscript tree; left-align, ansi enabled
+                if (ansi::length(s) > rcap) s = ansi::substring(s, 0, rcap-3) + "...";
+                printf("%s", s.c_str());
+            }
         }
         printf("\n");
     }

instance.cpp

@@ -97,14 +97,20 @@ bool Instance::parse_input_transaction(const char* txdata, int select_index) {
 bool Instance::parse_script(const char* script_str) {
     std::vector<unsigned char> scriptData = Value(script_str).data_value();
     script = CScript(scriptData.begin(), scriptData.end());
-    for (const auto& keymap : COMPILER_CTX.KeyMap) {
+    for (const auto& keymap : COMPILER_CTX.keymap) {
         auto cs = keymap.first.c_str();
         auto key = Value(std::vector<uint8_t>(keymap.second.begin(), keymap.second.end())).data;
         auto sig = Value((std::string("sig:") + keymap.first).c_str()).data_value();
         pretend_valid_map[sig] = key;
         pretend_valid_pubkeys.insert(key);
         printf("info: provide sig:%s as signature for %s [%s=%s]\n", cs, cs, HexStr(sig).c_str(), HexStr(key).c_str());
     }
+    try {
+        msenv = new MSEnv(script, true);
+    } catch (const std::exception& ex) {
+        printf("miniscript failed to parse script; miniscript support disabled\n");
+        msenv = nullptr;
+    }
     return script.HasValidOps();
 }
 
@@ -116,31 +122,43 @@ bool Instance::parse_script(const std::vector<uint8_t>& script_data) {
 bool Instance::parse_pretend_valid_expr(const char* expr) {
     const char* p = expr;
     const char* c = p;
-    valtype key;
-    bool got_key = false;
+    valtype sig;
+    uint160 keyid;
+    bool got_sig = false;
+    COMPILER_CTX.symbolic_outputs = true;
     while (*c) {
         while (*c && *c != ',' && *c != ':') ++c;
         char* cs = strndup(p, c-p);
-        valtype s = Value(cs).data_value();
+        Value v = Value(cs);
+        valtype s = v.data_value();
         free(cs);
         switch (*c) {
         case ':':
-            if (got_key) {
+            if (got_sig) {
                 fprintf(stderr, "parse error (unexpected colon) near %s\n", p);
                 return false;
             }
-            key = s;
-            got_key = true;
+            sig = s;
+            got_sig = true;
             break;
         case ',':
         case 0:
-            if (!got_key) {
-                fprintf(stderr, "parse error (missing key) near %s\n", p);
+            if (!got_sig) {
+                fprintf(stderr, "parse error (missing signature) near %s\n", p);
                 return false;
             }
-            got_key = false;
-            pretend_valid_map[key] = s;
+            got_sig = false;
+            COMPILER_CTX.fake_sigs.insert(sig);
+            v.do_hash160();
+            keyid = uint160(v.data_value());
+            // pretend_valid_map[sig] = s;
             pretend_valid_pubkeys.insert(s);
+            CompilerContext::Key ctx_key;
+            COMPILER_CTX.FromString(p, c, ctx_key);
+            COMPILER_CTX.pkh_map[CKeyID(keyid)] = ctx_key;
+            pretend_valid_pubkeys.insert(valtype(ctx_key.begin(), ctx_key.end()));
+            // note: we override below; this may lead to issues
+            pretend_valid_map[sig] = valtype(ctx_key.begin(), ctx_key.end());
             break;
         }
         p = c = c + (*c != 0);
@@ -150,7 +168,13 @@ bool Instance::parse_pretend_valid_expr(const char* expr) {
 
 void Instance::parse_stack_args(const std::vector<const char*> args) {
     for (auto& v : args) {
-        stack.push_back(Value(v).data_value());
+        auto z = Value(v).data_value();
+        stack.push_back(z);
+        if (z.size() == 33) {
+            // add if valid pubkey
+            CompilerContext::Key key;
+            COMPILER_CTX.FromPKBytes(z.begin(), z.end(), key);
+        }
     }
 }
 
@@ -186,7 +210,7 @@ bool Instance::step(size_t steps) {
         if (env->done) return false;
         try {
             if (!StepScript(*env)) return false;
-        } catch (std::exception const& ex) {
+        } catch (const std::exception& ex) {
             exception_string = ex.what();
             return false;
         }
@@ -333,7 +357,7 @@ bool Instance::configure_tx_txin() {
         if (scriptSig.size() > 0) {
             btc_segwit_logf("script sig non-empty; embedded P2SH (extracting payload)\n");
             // Embedded in P2SH -- payload extraction required
-            auto it2 = scriptSig.begin();
+            CScript::const_iterator it2 = scriptSig.begin();
             if (!scriptSig.GetOp(it2, opcode, pushval)) {
                 fprintf(stderr, "can't parse sig script, or sig script ended prematurely\n");
                 return false;
@@ -451,11 +475,29 @@ bool Instance::configure_tx_txin() {
         script = scriptSig;
         successor_script = scriptPubKey;
     }
+
     parse_stack_args(push_del);
     while (!push_del.empty()) {
         delete push_del.back();
         push_del.pop_back();
     }
 
+    // extract pubkeys from script
+    CScript::const_iterator it = script.begin();
+    while (script.GetOp(it, opcode, pushval)) {
+        if (pushval.size() == 33) {
+            // add if valid pubkey
+            CompilerContext::Key key;
+            COMPILER_CTX.FromPKBytes(pushval.begin(), pushval.end(), key);
+        }
+    }
+
+    try {
+        msenv = new MSEnv(successor_script, true);
+    } catch (const std::exception& ex) {
+        printf("miniscript failed to parse script; miniscript support disabled\n");
+        msenv = nullptr;
+    }
+
     return true;
 }

instance.h

@@ -9,12 +9,14 @@
 #include <value.h>
 #include <vector>
 #include <map>
+#include <msenv.h>
 
 typedef std::vector<unsigned char> valtype;
 
 class Instance {
 public:
     InterpreterEnv* env;
+    MSEnv* msenv;
     int count;
     ECCVerifyHandle evh;
     CTransactionRef tx;
@@ -41,6 +43,7 @@ class Instance {
 
     Instance()
     : env(nullptr)
+    , msenv(nullptr)
     , count(0)
     , txin_index(-1)
     , txin_vout_index(-1)

miniscript/compiler.cpp

@@ -487,6 +487,7 @@ CostPair CalcCostPair(NodeType nt, const std::vector<const Result*>& s, double l
     switch (nt) {
         case NodeType::PK: return {73, 1};
         case NodeType::PK_H: return {107, 35};
+        case NodeType::SIG: return {75, 75};
         case NodeType::OLDER:
         case NodeType::AFTER:
             return {0, INF};
@@ -544,6 +545,7 @@ std::pair<std::vector<double>, std::vector<double>> GetPQs(NodeType nt, double p
         case NodeType::HASH160:
         case NodeType::SHA256:
         case NodeType::RIPEMD160:
+        case NodeType::SIG:
             return NONE;
         case NodeType::WRAP_A:
         case NodeType::WRAP_S:
@@ -611,6 +613,7 @@ const TypeFilters& GetTypeFilter(NodeType nt) {
         case NodeType::HASH160:
         case NodeType::SHA256:
         case NodeType::RIPEMD160:
+        case NodeType::SIG:
             return FILTER_NO;
         case NodeType::WRAP_A: return FILTER_WRAP_A;
         case NodeType::WRAP_S: return FILTER_WRAP_S;