From 1698454c2addd75e95add306577eeaf2dd35384d Mon Sep 17 00:00:00 2001
From: Russell O'Connor <roconnor@blockstream.io>
Date: Mon, 10 Jun 2024 12:19:21 -0400
Subject: [PATCH] Add Simplicity verification

Unactivated.
---
 src/script/interpreter.cpp  | 131 ++++++++++++++++++++++++++++++++++++
 src/script/interpreter.h    |  18 +++++
 src/script/script_error.cpp |  51 ++++++++++++++
 src/script/script_error.h   |  27 ++++++++
 4 files changed, 227 insertions(+)

diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 263f3691ab..5945356439 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -12,6 +12,10 @@
 #include <pubkey.h>
 #include <script/script.h>
 #include <uint256.h>
+extern "C" {
+#include <simplicity/elements/exec.h>
+#include <simplicity/errorCodes.h>
+}
 
 typedef std::vector<unsigned char> valtype;
 
@@ -2596,6 +2600,76 @@ void PrecomputedTransactionData::Init(const T& txTo, std::vector<CTxOut>&& spent
         m_spent_scripts_single_hash = GetSpentScriptsSHA256(m_spent_outputs);
         m_spent_output_spk_single_hashes = GetSpentScriptPubKeysSHA256(m_spent_outputs);
         m_output_spk_single_hashes = GetOutputScriptPubKeysSHA256(txTo);
+
+        std::vector<rawBuffer> simplicityRawAnnex(txTo.witness.vtxinwit.size());
+        std::vector<rawInput> simplicityRawInput(txTo.vin.size());
+        for (size_t i = 0; i < txTo.vin.size(); ++i) {
+            simplicityRawInput[i].prevTxid = txTo.vin[i].prevout.hash.begin();
+            simplicityRawInput[i].prevIx = txTo.vin[i].prevout.n;
+            simplicityRawInput[i].sequence = txTo.vin[i].nSequence;
+            simplicityRawInput[i].txo.asset = m_spent_outputs[i].nAsset.vchCommitment.empty() ? NULL : m_spent_outputs[i].nAsset.vchCommitment.data();
+            simplicityRawInput[i].txo.value = m_spent_outputs[i].nValue.vchCommitment.empty() ? NULL : m_spent_outputs[i].nValue.vchCommitment.data();
+            simplicityRawInput[i].txo.scriptPubKey.buf = m_spent_outputs[i].scriptPubKey.data();
+            simplicityRawInput[i].txo.scriptPubKey.len = m_spent_outputs[i].scriptPubKey.size();
+            simplicityRawInput[i].issuance.blindingNonce = txTo.vin[i].assetIssuance.assetBlindingNonce.begin();
+            simplicityRawInput[i].issuance.assetEntropy = txTo.vin[i].assetIssuance.assetEntropy.begin();
+            simplicityRawInput[i].issuance.amount = txTo.vin[i].assetIssuance.nAmount.vchCommitment.empty() ? NULL : txTo.vin[i].assetIssuance.nAmount.vchCommitment.data();
+            simplicityRawInput[i].issuance.inflationKeys = txTo.vin[i].assetIssuance.nInflationKeys.vchCommitment.empty() ? NULL : txTo.vin[i].assetIssuance.nInflationKeys.vchCommitment.data();
+            simplicityRawInput[i].annex = NULL;
+            if (i < txTo.witness.vtxinwit.size()) {
+                Span<const valtype> stack{txTo.witness.vtxinwit[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];
+                }
+                simplicityRawInput[i].issuance.amountRangePrf.buf = txTo.witness.vtxinwit[i].vchIssuanceAmountRangeproof.data();
+                simplicityRawInput[i].issuance.amountRangePrf.len = txTo.witness.vtxinwit[i].vchIssuanceAmountRangeproof.size();
+                simplicityRawInput[i].issuance.inflationKeysRangePrf.buf = txTo.witness.vtxinwit[i].vchInflationKeysRangeproof.data();
+                simplicityRawInput[i].issuance.inflationKeysRangePrf.len = txTo.witness.vtxinwit[i].vchInflationKeysRangeproof.size();
+                assert(!txTo.vin[i].m_is_pegin || ( txTo.witness.vtxinwit[i].m_pegin_witness.stack.size() >= 4 && txTo.witness.vtxinwit[i].m_pegin_witness.stack[2].size() == 32));
+                simplicityRawInput[i].pegin = txTo.vin[i].m_is_pegin ? txTo.witness.vtxinwit[i].m_pegin_witness.stack[2].data() : 0;
+            } else {
+                simplicityRawInput[i].issuance.amountRangePrf.buf = NULL;
+                simplicityRawInput[i].issuance.amountRangePrf.len = 0;
+                simplicityRawInput[i].issuance.inflationKeysRangePrf.buf = NULL;
+                simplicityRawInput[i].issuance.inflationKeysRangePrf.len = 0;
+                assert(!txTo.vin[i].m_is_pegin);
+                simplicityRawInput[i].pegin = 0;
+            }
+        }
+
+        std::vector<rawOutput> simplicityRawOutput(txTo.vout.size());
+        for (size_t i = 0; i < txTo.vout.size(); ++i) {
+            simplicityRawOutput[i].asset = txTo.vout[i].nAsset.vchCommitment.empty() ? NULL : txTo.vout[i].nAsset.vchCommitment.data();
+            simplicityRawOutput[i].value = txTo.vout[i].nValue.vchCommitment.empty() ? NULL : txTo.vout[i].nValue.vchCommitment.data();
+            simplicityRawOutput[i].nonce = txTo.vout[i].nNonce.vchCommitment.empty() ? NULL : txTo.vout[i].nNonce.vchCommitment.data();
+            simplicityRawOutput[i].scriptPubKey.buf = txTo.vout[i].scriptPubKey.data();
+            simplicityRawOutput[i].scriptPubKey.len = txTo.vout[i].scriptPubKey.size();
+            if (i < txTo.witness.vtxoutwit.size()) {
+                simplicityRawOutput[i].surjectionProof.buf = txTo.witness.vtxoutwit[i].vchSurjectionproof.data();
+                simplicityRawOutput[i].surjectionProof.len = txTo.witness.vtxoutwit[i].vchSurjectionproof.size();
+                simplicityRawOutput[i].rangeProof.buf = txTo.witness.vtxoutwit[i].vchRangeproof.data();
+                simplicityRawOutput[i].rangeProof.len = txTo.witness.vtxoutwit[i].vchRangeproof.size();
+            } else {
+                simplicityRawOutput[i].surjectionProof.buf = NULL;
+                simplicityRawOutput[i].surjectionProof.len = 0;
+                simplicityRawOutput[i].rangeProof.buf = NULL;
+                simplicityRawOutput[i].rangeProof.len = 0;
+            }
+        }
+
+        rawTransaction simplicityRawTx;
+        simplicityRawTx.txid = txTo.GetHash().begin();
+        simplicityRawTx.input = simplicityRawInput.data();
+        simplicityRawTx.numInputs = simplicityRawInput.size();
+        simplicityRawTx.output = simplicityRawOutput.data();
+        simplicityRawTx.numOutputs = simplicityRawOutput.size();
+        simplicityRawTx.version = txTo.nVersion;
+        simplicityRawTx.lockTime = txTo.nLockTime;
+
+        m_simplicity_tx_data = simplicity_elements_mallocTransaction(&simplicityRawTx);
+
         m_bip341_taproot_ready = true;
     }
 }
@@ -3038,6 +3112,51 @@ uint32_t GenericTransactionSignatureChecker<T>::GetnIn() const
     return nIn;
 }
 
+template <class T>
+bool GenericTransactionSignatureChecker<T>::CheckSimplicity(const valtype& program, const valtype& witness, const rawTapEnv& simplicityRawTap, int64_t budget, ScriptError* serror) const
+{
+    simplicity_err error;
+    tapEnv* simplicityTapEnv = simplicity_elements_mallocTapEnv(&simplicityRawTap);
+
+    assert(txdata->m_simplicity_tx_data);
+    assert(simplicityTapEnv);
+    if (!simplicity_elements_execSimplicity(&error, 0, txdata->m_simplicity_tx_data, nIn, simplicityTapEnv, txdata->m_hash_genesis_block.data(), budget, 0, program.data(), program.size(), witness.data(), witness.size())) {
+        assert(!"simplicity_elements_execSimplicity internal error");
+    }
+    free(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_STOP_CODE: return set_error(serror, SCRIPT_ERR_SIMPLICITY_STOP_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);
+    default: return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
+    }
+}
+
 // explicit instantiation
 template class GenericTransactionSignatureChecker<CTransaction>;
 template class GenericTransactionSignatureChecker<CMutableTransaction>;
@@ -3186,6 +3305,18 @@ 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) && (control[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSIMPLICITY) {
+                if (stack.size() != 2 || script_bytes.size() != 32) 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, PROTOCOL_VERSION) + VALIDATION_WEIGHT_OFFSET;
+                rawTapEnv simplicityRawTap;
+                simplicityRawTap.controlBlock = control.data();
+                simplicityRawTap.pathLen = (control.size() - TAPROOT_CONTROL_BASE_SIZE) / TAPROOT_CONTROL_NODE_SIZE;
+                simplicityRawTap.scriptCMR = script_bytes.data();
+                return checker.CheckSimplicity(simplicity_program, simplicity_witness, simplicityRawTap, budget, serror);
+            }
             if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION) {
                 return set_error(serror, SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION);
             }
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index 7216644bf4..4881b74651 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -10,6 +10,9 @@
 #include <script/script_error.h>
 #include <span.h>
 #include <primitives/transaction.h>
+extern "C" {
+#include <simplicity/elements/env.h>
+}
 
 #include <optional>
 #include <vector>
@@ -155,6 +158,10 @@ enum : uint32_t {
     //
     SCRIPT_SIGHASH_RANGEPROOF = (1U << 22),
 
+    // Support simplicity
+    //
+    SCRIPT_VERIFY_SIMPLICITY = (1U << 23),
+
     // Constants to point to the highest flag in use. Add new flags above this line.
     //
     SCRIPT_VERIFY_END_MARKER
@@ -164,6 +171,7 @@ bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned i
 
 struct PrecomputedTransactionData
 {
+    transaction* m_simplicity_tx_data = nullptr;
     // BIP341 precomputed data.
     // These are single-SHA256, see https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_note-15.
     uint256 m_prevouts_single_hash;
@@ -213,6 +221,9 @@ struct PrecomputedTransactionData
 
     template <class T>
     explicit PrecomputedTransactionData(const T& tx);
+    ~PrecomputedTransactionData() {
+        free(m_simplicity_tx_data);
+    }
 };
 
 enum class SigVersion
@@ -262,6 +273,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 = 0xc4;
+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;
@@ -327,6 +339,11 @@ public:
         return std::numeric_limits<uint32_t>::max();
     }
 
+    virtual bool CheckSimplicity(const std::vector<unsigned char>& witness, const std::vector<unsigned char>& program, const rawTapEnv& simplicityRawTap, int64_t budget, ScriptError* serror) const
+    {
+         return false;
+    }
+
     virtual ~BaseSignatureChecker() {}
 };
 
@@ -370,6 +387,7 @@ public:
 
     const PrecomputedTransactionData* GetPrecomputedTransactionData() const override;
     uint32_t GetnIn() const override;
+    bool CheckSimplicity(const std::vector<unsigned char>& program, const std::vector<unsigned char>& witness, const rawTapEnv& simplicityRawTap, int64_t budget, ScriptError* serror) const override;
 };
 
 using TransactionSignatureChecker = GenericTransactionSignatureChecker<CTransaction>;
diff --git a/src/script/script_error.cpp b/src/script/script_error.cpp
index 438e86f2f2..b7be7b2139 100644
--- a/src/script/script_error.cpp
+++ b/src/script/script_error.cpp
@@ -6,6 +6,9 @@
 #include <script/script_error.h>
 
 #include <string>
+extern "C" {
+#include <simplicity/errorCodes.h>
+}
 
 std::string ScriptErrorString(const ScriptError serror)
 {
@@ -129,6 +132,54 @@ std::string ScriptErrorString(const ScriptError serror)
             return "Arithmetic opcode error";
         case SCRIPT_ERR_ECMULTVERIFYFAIL:
             return "EC scalar mult verify fail";
+        case SCRIPT_ERR_SIMPLICITY_WRONG_LENGTH:
+            return "Simplicity witness has incorrect length";
+        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_STOP_CODE:
+            return SIMPLICITY_ERR_MSG(SIMPLICITY_ERR_STOP_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_UNKNOWN_ERROR:
         case SCRIPT_ERR_ERROR_COUNT:
         default: break;
diff --git a/src/script/script_error.h b/src/script/script_error.h
index 712ed07e35..db137937f2 100644
--- a/src/script/script_error.h
+++ b/src/script/script_error.h
@@ -96,6 +96,33 @@ typedef enum ScriptError_t
     SCRIPT_ERR_ARITHMETIC64,
     SCRIPT_ERR_ECMULTVERIFYFAIL,
 
+    /* Elements: Simplicity related errors */
+    SCRIPT_ERR_SIMPLICITY_WRONG_LENGTH,
+    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_STOP_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,
+
     /* Must go last */
     SCRIPT_ERR_ERROR_COUNT
 } ScriptError;