Binana 2026-0003 Simplicity implementation

cmake/module/ProcessConfigurations.cmake

@@ -104,6 +104,23 @@ function(remove_cxx_flag_from_all_configs flag)
   endforeach()
 endfunction()
 
+function(remove_c_flag_from_all_configs flag)
+  get_all_configs(all_configs)
+  foreach(config IN LISTS all_configs)
+    string(TOUPPER "${config}" config_uppercase)
+    set(flags "${CMAKE_C_FLAGS_${config_uppercase}}")
+    separate_arguments(flags)
+    list(FILTER flags EXCLUDE REGEX "${flag}")
+    list(JOIN flags " " new_flags)
+    set(CMAKE_C_FLAGS_${config_uppercase} "${new_flags}" PARENT_SCOPE)
+    set(CMAKE_C_FLAGS_${config_uppercase} "${new_flags}"
+      CACHE STRING
+      "Flags used by the C compiler during ${config_uppercase} builds."
+      FORCE
+    )
+  endforeach()
+endfunction()
+
 function(replace_cxx_flag_in_config config old_flag new_flag)
   string(TOUPPER "CMAKE_CXX_FLAGS_${config}" var_name)
   if("${var_name}" IN_LIST precious_variables)
@@ -121,8 +138,10 @@ include(TryAppendCXXFlags)
 # We leave assertions on.
 if(MSVC)
   remove_cxx_flag_from_all_configs(/DNDEBUG)
+  remove_c_flag_from_all_configs(/DNDEBUG)
 else()
   remove_cxx_flag_from_all_configs(-DNDEBUG)
+  remove_c_flag_from_all_configs(-DNDEBUG)
 
   # Adjust flags used by the CXX compiler during RELEASE builds.
   # Prefer -O2 optimization level. (-O3 is CMake's default for Release for many compilers.)

src/CMakeLists.txt

@@ -19,6 +19,7 @@ include(../cmake/crc32c.cmake)
 include(../cmake/leveldb.cmake)
 include(../cmake/minisketch.cmake)
 add_subdirectory(univalue)
+add_subdirectory(simplicity)
 #=============================
 # secp256k1 subtree
 #=============================
@@ -127,6 +128,7 @@ target_link_libraries(bitcoin_consensus
     core_interface
     bitcoin_crypto
     secp256k1
+    BitcoinSimplicity
 )
 add_dependencies(bitcoin_consensus generate_binana_info)
 

src/binana/simplicity.json

@@ -0,0 +1,7 @@
+{
+    "binana": [2026, 3, 0],
+    "deployment": "SIMPLICITY",
+    "scriptverify": true,
+    "scriptverify_discourage": true,
+    "opcodes": {}
+}

src/kernel/CMakeLists.txt

@@ -87,6 +87,7 @@ target_link_libraries(bitcoinkernel
     bitcoin_crypto
     leveldb
     secp256k1
+    BitcoinSimplicity
     $<TARGET_NAME_IF_EXISTS:USDT::headers>
   PUBLIC
     Boost::headers

src/script/interpreter.cpp

@@ -13,6 +13,11 @@
 #include <script/script.h>
 #include <tinyformat.h>
 #include <uint256.h>
+extern "C" {
+#include <simplicity/bitcoin/env.h>
+#include <simplicity/bitcoin/exec.h>
+#include <simplicity/errorCodes.h>
+}
 
 typedef std::vector<unsigned char> valtype;
 
@@ -1638,6 +1643,10 @@ template
 uint256 GetDefaultCheckTemplateVerifyHash(const CMutableTransaction& tx, const uint256& outputs_hash, const uint256& sequences_hash,
                                 const uint32_t input_index);
 
+void SimplicityTransactionDeleter::operator()(bitcoinTransaction* ptr) const {
+    simplicity_bitcoin_freeTransaction(ptr);
+}
+
 template <class T>
 void PrecomputedTransactionData::Init(const T& txTo, std::vector<CTxOut>&& spent_outputs, bool force)
 {
@@ -1693,6 +1702,44 @@ void PrecomputedTransactionData::Init(const T& txTo, std::vector<CTxOut>&& spent
     if (uses_bip341_taproot && m_spent_outputs_ready) {
         m_spent_amounts_single_hash = GetSpentAmountsSHA256(m_spent_outputs);
         m_spent_scripts_single_hash = GetSpentScriptsSHA256(m_spent_outputs);
+
+        std::vector<rawBitcoinBuffer> simplicityRawAnnex(txTo.vin.size());
+        std::vector<rawBitcoinInput> simplicityRawInput(txTo.vin.size());
+        for (size_t i = 0; i < txTo.vin.size(); ++i) {
+            simplicityRawInput[i].prevTxid = txTo.vin[i].prevout.hash.ToUint256().data();
+            simplicityRawInput[i].prevIx = txTo.vin[i].prevout.n;
+            simplicityRawInput[i].sequence = txTo.vin[i].nSequence;
+            simplicityRawInput[i].txo.value = m_spent_outputs[i].nValue;
+            simplicityRawInput[i].txo.scriptPubKey.buf = m_spent_outputs[i].scriptPubKey.data();
+            simplicityRawInput[i].txo.scriptPubKey.len = m_spent_outputs[i].scriptPubKey.size();
+            simplicityRawInput[i].annex = nullptr;
+            std::span<const valtype> stack{txTo.vin[i].scriptWitness.stack};
+            if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
+                simplicityRawAnnex[i].buf = stack.back().data()+1;
+                simplicityRawAnnex[i].len = stack.back().size()-1;
+                simplicityRawInput[i].annex = &simplicityRawAnnex[i];
+            }
+        }
+
+        std::vector<rawBitcoinOutput> simplicityRawOutput(txTo.vout.size());
+        for (size_t i = 0; i < txTo.vout.size(); ++i) {
+            simplicityRawOutput[i].value = txTo.vout[i].nValue;
+            simplicityRawOutput[i].scriptPubKey.buf = txTo.vout[i].scriptPubKey.data();
+            simplicityRawOutput[i].scriptPubKey.len = txTo.vout[i].scriptPubKey.size();
+        }
+
+        rawBitcoinTransaction simplicityRawTx;
+        uint256 rawHash = txTo.GetHash().ToUint256();
+        simplicityRawTx.txid = rawHash.begin();
+        simplicityRawTx.input = simplicityRawInput.data();
+        simplicityRawTx.numInputs = simplicityRawInput.size();
+        simplicityRawTx.output = simplicityRawOutput.data();
+        simplicityRawTx.numOutputs = simplicityRawOutput.size();
+        simplicityRawTx.version = txTo.version;
+        simplicityRawTx.lockTime = txTo.nLockTime;
+
+        m_simplicity_tx_data = SimplicityTransactionUniquePtr(simplicity_bitcoin_mallocTransaction(&simplicityRawTx));
+
         m_bip341_taproot_ready = true;
     }
 }
@@ -2135,6 +2182,52 @@ uint256 GenericTransactionSignatureChecker<T>::GetTemplateHash(ScriptExecutionDa
     return ss.GetSHA256();
 }
 
+template <class T>
+bool GenericTransactionSignatureChecker<T>::CheckSimplicity(const valtype& program, const valtype& witness, const rawBitcoinTapEnv& simplicityRawTap, int64_t minCost, int64_t budget, ScriptError* serror) const
+{
+    simplicity_err error;
+    bitcoinTapEnv* simplicityTapEnv = simplicity_bitcoin_mallocTapEnv(&simplicityRawTap);
+
+    assert(txdata->m_simplicity_tx_data);
+    assert(simplicityTapEnv);
+    if (!simplicity_bitcoin_execSimplicity(&error, nullptr, txdata->m_simplicity_tx_data.get(), nIn, simplicityTapEnv, minCost, budget, nullptr, program.data(), program.size(), witness.data(), witness.size())) {
+        assert(!"simplicity_elements_execSimplicity internal error");
+    }
+    simplicity_bitcoin_freeTapEnv(simplicityTapEnv);
+    switch (error) {
+    case SIMPLICITY_NO_ERROR: return set_success(serror);
+    case SIMPLICITY_ERR_MALLOC:
+    case SIMPLICITY_ERR_NOT_YET_IMPLEMENTED:
+        assert(!"simplicity_elements_execSimplicity internal error");
+        break;
+    case SIMPLICITY_ERR_DATA_OUT_OF_RANGE: return set_error(serror, SCRIPT_ERR_SIMPLICITY_DATA_OUT_OF_RANGE);
+    case SIMPLICITY_ERR_DATA_OUT_OF_ORDER: return set_error(serror, SCRIPT_ERR_SIMPLICITY_DATA_OUT_OF_ORDER);
+    case SIMPLICITY_ERR_FAIL_CODE: return set_error(serror, SCRIPT_ERR_SIMPLICITY_FAIL_CODE);
+    case SIMPLICITY_ERR_RESERVED_CODE: return set_error(serror, SCRIPT_ERR_SIMPLICITY_RESERVED_CODE);
+    case SIMPLICITY_ERR_HIDDEN: return set_error(serror, SCRIPT_ERR_SIMPLICITY_HIDDEN);
+    case SIMPLICITY_ERR_BITSTREAM_EOF: return set_error(serror, SCRIPT_ERR_SIMPLICITY_BITSTREAM_EOF);
+    case SIMPLICITY_ERR_BITSTREAM_TRAILING_BYTES: return set_error(serror, SCRIPT_ERR_SIMPLICITY_BITSTREAM_TRAILING_BYTES);
+    case SIMPLICITY_ERR_BITSTREAM_ILLEGAL_PADDING: return set_error(serror, SCRIPT_ERR_SIMPLICITY_BITSTREAM_ILLEGAL_PADDING);
+    case SIMPLICITY_ERR_TYPE_INFERENCE_UNIFICATION: return set_error(serror, SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_UNIFICATION);
+    case SIMPLICITY_ERR_TYPE_INFERENCE_OCCURS_CHECK: return set_error(serror, SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_OCCURS_CHECK);
+    case SIMPLICITY_ERR_TYPE_INFERENCE_NOT_PROGRAM: return set_error(serror, SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_NOT_PROGRAM);
+    case SIMPLICITY_ERR_WITNESS_EOF: return set_error(serror, SCRIPT_ERR_SIMPLICITY_WITNESS_EOF);
+    case SIMPLICITY_ERR_WITNESS_TRAILING_BYTES: return set_error(serror, SCRIPT_ERR_SIMPLICITY_WITNESS_TRAILING_BYTES);
+    case SIMPLICITY_ERR_WITNESS_ILLEGAL_PADDING: return set_error(serror, SCRIPT_ERR_SIMPLICITY_WITNESS_ILLEGAL_PADDING);
+    case SIMPLICITY_ERR_UNSHARED_SUBEXPRESSION: return set_error(serror, SCRIPT_ERR_SIMPLICITY_UNSHARED_SUBEXPRESSION);
+    case SIMPLICITY_ERR_CMR: return set_error(serror, SCRIPT_ERR_SIMPLICITY_CMR);
+    case SIMPLICITY_ERR_EXEC_BUDGET: return set_error(serror, SCRIPT_ERR_SIMPLICITY_EXEC_BUDGET);
+    case SIMPLICITY_ERR_EXEC_MEMORY: return set_error(serror, SCRIPT_ERR_SIMPLICITY_EXEC_MEMORY);
+    case SIMPLICITY_ERR_EXEC_JET: return set_error(serror, SCRIPT_ERR_SIMPLICITY_EXEC_JET);
+    case SIMPLICITY_ERR_EXEC_ASSERT: return set_error(serror, SCRIPT_ERR_SIMPLICITY_EXEC_ASSERT);
+    case SIMPLICITY_ERR_ANTIDOS: return set_error(serror, SCRIPT_ERR_SIMPLICITY_ANTIDOS);
+    case SIMPLICITY_ERR_HIDDEN_ROOT: return set_error(serror, SCRIPT_ERR_SIMPLICITY_HIDDEN_ROOT);
+    case SIMPLICITY_ERR_AMR: return set_error(serror, SCRIPT_ERR_SIMPLICITY_AMR);
+    case SIMPLICITY_ERR_OVERWEIGHT: return set_error(serror, SCRIPT_ERR_SIMPLICITY_OVERWEIGHT);
+    default: return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
+    }
+}
+
 // explicit instantiation
 template class GenericTransactionSignatureChecker<CTransaction>;
 template class GenericTransactionSignatureChecker<CMutableTransaction>;
@@ -2319,6 +2412,42 @@ static bool VerifyWitnessProgram(const CScriptWitness& witness, int witversion,
                 execdata.m_validation_weight_left_init = true;
                 return ExecuteWitnessScript(stack, exec_script, flags, SigVersion::TAPSCRIPT, checker, execdata, serror);
             }
+            if ((flags & SCRIPT_VERIFY_SIMPLICITY) && (script.size() == 32) && (control[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSIMPLICITY) {
+                if (stack.size() < 2 || 3 < stack.size()) return set_error(serror, SCRIPT_ERR_SIMPLICITY_WRONG_LENGTH);
+                // Tapsimplicity (leaf version 0xbe)
+                const valtype& simplicity_program = SpanPopBack(stack);
+                const valtype& simplicity_witness = SpanPopBack(stack);
+                const int64_t budget = ::GetSerializeSize(witness.stack) + VALIDATION_WEIGHT_OFFSET;
+                int64_t minCost = 0;
+                rawBitcoinTapEnv simplicityRawTap;
+                simplicityRawTap.controlBlock = control.data();
+                simplicityRawTap.pathLen = (control.size() - TAPROOT_CONTROL_BASE_SIZE) / TAPROOT_CONTROL_NODE_SIZE;
+                simplicityRawTap.scriptCMR = script.data();
+                // If a padding stack item exists, we want to make sure it is minimal.
+                if (!stack.empty()) {
+                    const valtype& padding = SpanPopBack(stack);
+                    valtype zero_padding(padding.size());
+
+                    // There should be no more stack items.
+                    assert(stack.empty());
+
+                    // Padding must be all zeros.
+                    if (padding != zero_padding) {
+                        return set_error(serror, SCRIPT_ERR_SIMPLICITY_PADDING_NONZERO);
+                    }
+
+                    // Compute what the budget would have been without the padding.
+                    // budget includes the padding cost, so subtracting this stack item won't underflow.
+                    minCost = budget - ::GetSerializeSize(padding);
+
+                    if (!zero_padding.empty()) {
+                        // Set the minCost to what the budget would have been if the padding were one byte smaller.
+                        zero_padding.pop_back();
+                        minCost += ::GetSerializeSize(zero_padding);
+                    }
+                }
+                return checker.CheckSimplicity(simplicity_program, simplicity_witness, simplicityRawTap, minCost, budget, serror);
+            }
             if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION) {
                 return set_error(serror, SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION);
             }

src/script/interpreter.h

@@ -167,10 +167,20 @@ static constexpr int MAX_SCRIPT_VERIFY_FLAGS_BITS = std::bit_width(MAX_SCRIPT_VE
 
 bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, script_verify_flags flags, ScriptError* serror);
 
+// Forward declarations of Simplicity structures.
+struct bitcoinTransaction;
+struct rawBitcoinTapEnv;
+
+struct SimplicityTransactionDeleter
+{
+    void operator()(bitcoinTransaction* ptr) const;
+};
+using SimplicityTransactionUniquePtr = std::unique_ptr<bitcoinTransaction, SimplicityTransactionDeleter>;
+
 struct PrecomputedTransactionData
 {
     // Order of fields is packed below (uint256 is 32 bytes, vector is 24 bytes
-    // (3 ptrs), ready flags (1 byte each).
+    // (3 ptrs), Simplicity tx data is 8 bytes (1 ptr), ready flags (1 byte each).
 
     // BIP341 precomputed data.
     // These are single-SHA256, see https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_note-16.
@@ -189,6 +199,9 @@ struct PrecomputedTransactionData
     // BIP341 cached outputs.
     std::vector<CTxOut> m_spent_outputs;
 
+    // Simplicity transaction data.
+    SimplicityTransactionUniquePtr m_simplicity_tx_data;
+
     //! Whether the bip341 fields above are initialized.
     bool m_bip341_taproot_ready = false;
 
@@ -274,6 +287,7 @@ static constexpr size_t WITNESS_V1_TAPROOT_SIZE = 32;
 
 static constexpr uint8_t TAPROOT_LEAF_MASK = 0xfe;
 static constexpr uint8_t TAPROOT_LEAF_TAPSCRIPT = 0xc0;
+static constexpr uint8_t TAPROOT_LEAF_TAPSIMPLICITY = 0xbe;
 static constexpr size_t TAPROOT_CONTROL_BASE_SIZE = 33;
 static constexpr size_t TAPROOT_CONTROL_NODE_SIZE = 32;
 static constexpr size_t TAPROOT_CONTROL_MAX_NODE_COUNT = 128;
@@ -340,6 +354,11 @@ class BaseSignatureChecker
         return {};
     }
 
+    virtual bool CheckSimplicity(const std::vector<unsigned char>& witness, const std::vector<unsigned char>& program, const rawBitcoinTapEnv& simplicityRawTap, int64_t minCost, int64_t budget, ScriptError* serror) const
+    {
+        return false;
+    }
+
     virtual ~BaseSignatureChecker() = default;
 };
 
@@ -379,6 +398,7 @@ class GenericTransactionSignatureChecker : public BaseSignatureChecker
     bool CheckSequence(const CScriptNum& nSequence) const override;
     bool CheckDefaultCheckTemplateVerifyHash(const Span<const unsigned char>& hash) const override;
     uint256 GetTemplateHash(ScriptExecutionData& execdata) const override;
+    bool CheckSimplicity(const std::vector<unsigned char>& program, const std::vector<unsigned char>& witness, const rawBitcoinTapEnv& simplicityRawTap, int64_t minCost, int64_t budget, ScriptError* serror) const override;
 };
 
 using TransactionSignatureChecker = GenericTransactionSignatureChecker<CTransaction>;

src/script/script_error.cpp

@@ -8,6 +8,9 @@
 #include <binana.h>
 
 #include <string>
+extern "C" {
+#include <simplicity/errorCodes.h>
+}
 
 std::string ScriptErrorString(const ScriptError serror)
 {
@@ -119,6 +122,58 @@ std::string ScriptErrorString(const ScriptError serror)
             return "Using OP_CODESEPARATOR in non-witness script";
         case SCRIPT_ERR_SIG_FINDANDDELETE:
             return "Signature is found in scriptCode";
+        case SCRIPT_ERR_SIMPLICITY_WRONG_LENGTH:
+            return "Simplicity witness has incorrect length";
+        case SCRIPT_ERR_SIMPLICITY_PADDING_NONZERO:
+            return "Simplicity padding must be all zeros";
+        case SCRIPT_ERR_SIMPLICITY_DATA_OUT_OF_RANGE:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_DATA_OUT_OF_RANGE);
+        case SCRIPT_ERR_SIMPLICITY_DATA_OUT_OF_ORDER:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_DATA_OUT_OF_ORDER);
+        case SCRIPT_ERR_SIMPLICITY_FAIL_CODE:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_FAIL_CODE);
+        case SCRIPT_ERR_SIMPLICITY_RESERVED_CODE:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_RESERVED_CODE);
+        case SCRIPT_ERR_SIMPLICITY_HIDDEN:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_HIDDEN);
+        case SCRIPT_ERR_SIMPLICITY_BITSTREAM_EOF:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_BITSTREAM_EOF);
+        case SCRIPT_ERR_SIMPLICITY_BITSTREAM_TRAILING_BYTES:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_BITSTREAM_TRAILING_BYTES);
+        case SCRIPT_ERR_SIMPLICITY_BITSTREAM_ILLEGAL_PADDING:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_BITSTREAM_ILLEGAL_PADDING);
+        case SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_UNIFICATION:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_TYPE_INFERENCE_UNIFICATION);
+        case SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_OCCURS_CHECK:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_TYPE_INFERENCE_OCCURS_CHECK);
+        case SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_NOT_PROGRAM:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_TYPE_INFERENCE_NOT_PROGRAM);
+        case SCRIPT_ERR_SIMPLICITY_WITNESS_EOF:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_WITNESS_EOF);
+        case SCRIPT_ERR_SIMPLICITY_WITNESS_TRAILING_BYTES:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_WITNESS_TRAILING_BYTES);
+        case SCRIPT_ERR_SIMPLICITY_WITNESS_ILLEGAL_PADDING:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_WITNESS_ILLEGAL_PADDING);
+        case SCRIPT_ERR_SIMPLICITY_UNSHARED_SUBEXPRESSION:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_UNSHARED_SUBEXPRESSION);
+        case SCRIPT_ERR_SIMPLICITY_CMR:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_CMR);
+        case SCRIPT_ERR_SIMPLICITY_EXEC_BUDGET:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_EXEC_BUDGET);
+        case SCRIPT_ERR_SIMPLICITY_EXEC_MEMORY:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_EXEC_MEMORY);
+        case SCRIPT_ERR_SIMPLICITY_EXEC_JET:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_EXEC_JET);
+        case SCRIPT_ERR_SIMPLICITY_EXEC_ASSERT:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_EXEC_ASSERT);
+        case SCRIPT_ERR_SIMPLICITY_ANTIDOS:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_ANTIDOS);
+        case SCRIPT_ERR_SIMPLICITY_HIDDEN_ROOT:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_HIDDEN_ROOT);
+        case SCRIPT_ERR_SIMPLICITY_AMR:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_AMR);
+        case SCRIPT_ERR_SIMPLICITY_OVERWEIGHT:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_OVERWEIGHT);
 
         INQ_SCRIPTERR_STRING
 

src/script/script_error.h

@@ -85,6 +85,35 @@ typedef enum ScriptError_t
     SCRIPT_ERR_OP_CODESEPARATOR,
     SCRIPT_ERR_SIG_FINDANDDELETE,
 
+    /* Simplicity related errors */
+    SCRIPT_ERR_SIMPLICITY_WRONG_LENGTH,
+    SCRIPT_ERR_SIMPLICITY_PADDING_NONZERO,
+    SCRIPT_ERR_SIMPLICITY_NOT_YET_IMPLEMENTED,
+    SCRIPT_ERR_SIMPLICITY_DATA_OUT_OF_RANGE,
+    SCRIPT_ERR_SIMPLICITY_DATA_OUT_OF_ORDER,
+    SCRIPT_ERR_SIMPLICITY_FAIL_CODE,
+    SCRIPT_ERR_SIMPLICITY_RESERVED_CODE,
+    SCRIPT_ERR_SIMPLICITY_HIDDEN,
+    SCRIPT_ERR_SIMPLICITY_BITSTREAM_EOF,
+    SCRIPT_ERR_SIMPLICITY_BITSTREAM_TRAILING_BYTES,
+    SCRIPT_ERR_SIMPLICITY_BITSTREAM_ILLEGAL_PADDING,
+    SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_UNIFICATION,
+    SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_OCCURS_CHECK,
+    SCRIPT_ERR_SIMPLICITY_TYPE_INFERENCE_NOT_PROGRAM,
+    SCRIPT_ERR_SIMPLICITY_WITNESS_EOF,
+    SCRIPT_ERR_SIMPLICITY_WITNESS_TRAILING_BYTES,
+    SCRIPT_ERR_SIMPLICITY_WITNESS_ILLEGAL_PADDING,
+    SCRIPT_ERR_SIMPLICITY_UNSHARED_SUBEXPRESSION,
+    SCRIPT_ERR_SIMPLICITY_CMR,
+    SCRIPT_ERR_SIMPLICITY_EXEC_BUDGET,
+    SCRIPT_ERR_SIMPLICITY_EXEC_MEMORY,
+    SCRIPT_ERR_SIMPLICITY_EXEC_JET,
+    SCRIPT_ERR_SIMPLICITY_EXEC_ASSERT,
+    SCRIPT_ERR_SIMPLICITY_ANTIDOS,
+    SCRIPT_ERR_SIMPLICITY_HIDDEN_ROOT,
+    SCRIPT_ERR_SIMPLICITY_AMR,
+    SCRIPT_ERR_SIMPLICITY_OVERWEIGHT,
+
     /* Inquisition additions */
     INQ_SCRIPTERR