Cherry-pick #7226 to 6.x LTS (#7229)

Author: Copilot

CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [6.0.11]
+
+[6.0.11]: https://github.com/microsoft/CCF/releases/tag/ccf-6.0.11
+
+### Added
+
+- Added `ccf.gov.validateConstitution` function to JS API, which can be used to confirm some basic properties of a proposed constitution (it is a string, parseable by our JS interpreter, exporting functions named `validate`, `resolve` and `apply` with the correct number of arguments). This is called in the default sample constitution's `set_constitution.validate`.
+
 ## [6.0.10]
 
 [6.0.10]: https://github.com/microsoft/CCF/releases/tag/ccf-6.0.10

CMakeLists.txt

@@ -328,6 +328,7 @@ set(CCF_JS_SOURCES
     ${CCF_DIR}/src/js/extensions/ccf/consensus.cpp
     ${CCF_DIR}/src/js/extensions/ccf/converters.cpp
     ${CCF_DIR}/src/js/extensions/ccf/crypto.cpp
+    ${CCF_DIR}/src/js/extensions/ccf/gov.cpp
     ${CCF_DIR}/src/js/extensions/ccf/gov_effects.cpp
     ${CCF_DIR}/src/js/extensions/ccf/historical.cpp
     ${CCF_DIR}/src/js/extensions/ccf/host.cpp

include/ccf/js/common_context.h

@@ -5,6 +5,7 @@
 #include "ccf/js/core/context.h"
 #include "ccf/js/extensions/ccf/converters.h"
 #include "ccf/js/extensions/ccf/crypto.h"
+#include "ccf/js/extensions/ccf/gov.h"
 #include "ccf/js/extensions/ccf/kv.h"
 #include "ccf/js/extensions/console.h"
 #include "ccf/js/extensions/math/random.h"
@@ -41,6 +42,10 @@ namespace ccf::js
       // add snp_attestation.*
       Base::add_extension(
         std::make_shared<ccf::js::extensions::SnpAttestationExtension>());
+
+      // add ccf.gov.*
+      Base::add_extension(
+        std::make_shared<ccf::js::extensions::GovExtension>());
     }
   };
 

include/ccf/js/extensions/ccf/gov.h

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the Apache 2.0 License.
+#pragma once
+
+#include "ccf/js/extensions/extension_interface.h"
+
+namespace ccf::js::extensions
+{
+  /**
+   * Adds the following functions:
+   *
+   * - ccf.gov.isValidConstitution
+   *
+   **/
+  class GovExtension : public ExtensionInterface
+  {
+  public:
+    GovExtension() = default;
+
+    void install(js::core::Context& ctx) override;
+  };
+}

python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ccf"
-version = "6.0.10"
+version = "6.0.11"
 authors = [
   { name="CCF Team", email="CCF-Sec@microsoft.com" },
 ]

samples/constitutions/default/actions.js

@@ -399,7 +399,8 @@ const actions = new Map([
     "set_constitution",
     new Action(
       function (args) {
-        checkType(args.constitution, "string");
+        checkType(args.constitution, "string", "constitution");
+        ccf.gov.validateConstitution(args.constitution);
       },
       function (args, proposalId) {
         ccf.kv["public:ccf.gov.constitution"].set(

src/js/extensions/ccf/gov.cpp

@@ -0,0 +1,150 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the Apache 2.0 License.
+
+#include "ccf/js/extensions/ccf/gov.h"
+
+#include "ccf/js/core/context.h"
+
+#include <iostream>
+#include <quickjs/quickjs.h>
+
+namespace ccf::js::extensions
+{
+  namespace
+  {
+    JSValue js_validate_constitution(
+      JSContext* ctx,
+      [[maybe_unused]] JSValueConst this_val,
+      int argc,
+      JSValueConst* argv)
+    {
+      js::core::Context& jsctx =
+        *reinterpret_cast<js::core::Context*>(JS_GetContextOpaque(ctx));
+
+      if (argc != 1)
+      {
+        return JS_ThrowTypeError(
+          ctx, "Passed %d arguments, but expected 1", argc);
+      }
+
+      auto arg = jsctx.wrap(argv[0]);
+      if (!arg.is_str())
+      {
+        return JS_ThrowTypeError(ctx, "constitution is not a string");
+      }
+
+      auto constitution = jsctx.to_str(arg);
+      if (!constitution.has_value())
+      {
+        return JS_ThrowTypeError(ctx, "constitution is not a string");
+      }
+
+      if (constitution->empty())
+      {
+        return JS_ThrowTypeError(ctx, "constitution is empty");
+      }
+
+      const std::string path("proposed constitution");
+
+      struct ArgsSpec
+      {
+        std::vector<std::string> required_args;
+        std::vector<std::string> optional_args;
+      };
+
+      std::map<std::string, ArgsSpec> funcs_to_args;
+      funcs_to_args["validate"] = {{"input"}, {}};
+      funcs_to_args["resolve"] = {
+        {"proposal", "proposerId", "votes"}, {"proposalId"}};
+      funcs_to_args["apply"] = {{"proposal", "proposerId"}, {}};
+      for (const auto& [fn_name, args_spec] : funcs_to_args)
+      {
+        try
+        {
+          // Create a new context to lookup this function, since doing so
+          // requires evaluating the module, and that must have no side effects
+          // or write to the parent's global environment.
+          ccf::js::core::Context sub_context(ccf::js::TxAccess::GOV_RO);
+          auto func = sub_context.get_exported_function(
+            constitution.value(), fn_name, path);
+
+          auto length_val = sub_context.get_property(func.val, "length");
+          uint32_t length = 0;
+          if (JS_ToUint32(ctx, &length, length_val.val) < 0)
+          {
+            return ccf::js::core::constants::Exception;
+          }
+
+          auto plural_arg = [](size_t n) { return n == 1 ? "arg" : "args"; };
+
+          const auto actual = fmt::format(
+            "{} exports function {} with {} {}",
+            path,
+            fn_name,
+            length,
+            plural_arg(length));
+
+          if (args_spec.optional_args.empty())
+          {
+            const auto required_size = args_spec.required_args.size();
+            if (length != required_size)
+            {
+              auto err = fmt::format(
+                "{}, expected {} {} ({})",
+                actual,
+                required_size,
+                plural_arg(required_size),
+                fmt::join(args_spec.required_args, ", "));
+              return JS_ThrowTypeError(ctx, "%s", err.c_str());
+            }
+          }
+          else
+          {
+            const auto min_size = args_spec.required_args.size();
+            const auto max_size = min_size + args_spec.optional_args.size();
+
+            if (length < min_size || length > max_size)
+            {
+              auto err = fmt::format(
+                "{}, expected between {} and {} args ({}[, {}])",
+                actual,
+                min_size,
+                max_size,
+                fmt::join(args_spec.required_args, ", "),
+                fmt::join(args_spec.optional_args, ", "));
+              return JS_ThrowTypeError(ctx, "%s", err.c_str());
+            }
+          }
+        }
+        catch (const std::exception& e)
+        {
+          return JS_ThrowTypeError(
+            ctx,
+            "%s does not export a function named %s: %s",
+            path.c_str(),
+            fn_name.c_str(),
+            e.what());
+        }
+      }
+
+      return ccf::js::core::constants::True;
+    }
+  }
+
+  void GovExtension::install(js::core::Context& ctx)
+  {
+    auto gov = JS_NewObject(ctx);
+
+    JS_SetPropertyStr(
+      ctx,
+      gov,
+      "validateConstitution",
+      JS_NewCFunction(
+        ctx, js_validate_constitution, "validateConstitution", 1));
+
+    auto ccf = ctx.get_or_create_global_property("ccf", ctx.new_obj());
+    // NOLINTBEGIN(performance-move-const-arg)
+    ccf.set("gov", std::move(gov));
+    // NOLINTEND(performance-move-const-arg)
+  }
+}