libmongocrypt-helper 1.8.0.0.1001 → 1.11.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-insert-update-payload-private-v2.h

@@ -20,6 +20,7 @@
 #include <bson/bson.h>
 
 #include "mc-array-private.h"
+#include "mc-optional-private.h"
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt-private.h"
 #include "mongocrypt.h"
@@ -36,8 +37,8 @@
  * } FLE2InsertUpdatePayloadV2;
  *
  * bson is a BSON document of this form:
- * d: <binary> // EDCDerivedFromDataTokenAndCounter
- * s: <binary> // ESCDerivedFromDataTokenAndCounter
+ * d: <binary> // EDCDerivedFromDataTokenAndContentionFactor
+ * s: <binary> // ESCDerivedFromDataTokenAndContentionFactor
  * p: <binary> // Encrypted Tokens
  * u: <UUID>   // Index KeyId
  * t: <int32>  // Encrypted type
@@ -45,13 +46,18 @@
  * e: <binary> // ServerDataEncryptionLevel1Token
  * l: <binary> // ServerDerivedFromDataToken
  * k: <int64> // Randomly sampled contention factor value
- * g: array<EdgeTokenSetV2> // Array of Edges
+ * g: array<EdgeTokenSetV2> // Array of Edges. Only included for range payloads.
+ * sp: optional<int64> // Sparsity. Only included for range payloads.
+ * pn: optional<int32> // Precision. Only included for range payloads.
+ * tf: optional<int32> // Trim Factor. Only included for range payloads.
+ * mn: optional<any> // Index Min. Only included for range payloads.
+ * mx: optional<any> // Index Max. Only included for range payloads.
  *
  * p is the result of:
  * Encrypt(
  * key=ECOCToken,
  * plaintext=(
- *    ESCDerivedFromDataTokenAndCounter)
+ *    ESCDerivedFromDataTokenAndContentionFactor)
  * )
  *
  * v is the result of:
@@ -72,14 +78,19 @@ typedef struct {
     _mongocrypt_buffer_t serverDerivedFromDataToken; // l
     int64_t contentionFactor;                        // k
     mc_array_t edgeTokenSetArray;                    // g
+    mc_optional_int64_t sparsity;                    // sp
+    mc_optional_int32_t precision;                   // pn
+    mc_optional_int32_t trimFactor;                  // tf
+    bson_value_t indexMin;                           // mn
+    bson_value_t indexMax;                           // mx
     _mongocrypt_buffer_t plaintext;
     _mongocrypt_buffer_t userKeyId;
 } mc_FLE2InsertUpdatePayloadV2_t;
 
 /**
  * EdgeTokenSetV2 is the following BSON document:
- * d: <binary> // EDCDerivedFromDataTokenAndCounter
- * s: <binary> // ESCDerivedFromDataTokenAndCounter
+ * d: <binary> // EDCDerivedFromDataTokenAndContentionFactor
+ * s: <binary> // ESCDerivedFromDataTokenAndContentionFactor
  * l: <binary> // ServerDerivedFromDataToken
  * p: <binary> // Encrypted Tokens
  *
@@ -110,7 +121,9 @@ const _mongocrypt_buffer_t *mc_FLE2InsertUpdatePayloadV2_decrypt(_mongocrypt_cry
 
 bool mc_FLE2InsertUpdatePayloadV2_serialize(const mc_FLE2InsertUpdatePayloadV2_t *payload, bson_t *out);
 
-bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePayloadV2_t *payload, bson_t *out);
+bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePayloadV2_t *payload,
+                                                    bson_t *out,
+                                                    bool use_range_v2);
 
 void mc_FLE2InsertUpdatePayloadV2_cleanup(mc_FLE2InsertUpdatePayloadV2_t *payload);
 

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-insert-update-payload-private.h

@@ -36,9 +36,9 @@
  * } FLE2InsertUpdatePayload;
  *
  * bson is a BSON document of this form:
- * d: <binary> // EDCDerivedFromDataTokenAndCounter
- * s: <binary> // ESCDerivedFromDataTokenAndCounter
- * c: <binary> // ECCDerivedFromDataTokenAndCounter
+ * d: <binary> // EDCDerivedFromDataTokenAndContentionFactor
+ * s: <binary> // ESCDerivedFromDataTokenAndContentionFactor
+ * c: <binary> // ECCDerivedFromDataTokenAndContentionFactor
  * p: <binary> // Encrypted Tokens
  * u: <UUID>   // Index KeyId
  * t: <int32>  // Encrypted type
@@ -50,8 +50,8 @@
  * Encrypt(
  * key=ECOCToken,
  * plaintext=(
- *    ESCDerivedFromDataTokenAndCounter ||
- *    ECCDerivedFromDataTokenAndCounter)
+ *    ESCDerivedFromDataTokenAndContentionFactor ||
+ *    ECCDerivedFromDataTokenAndContentionFactor)
  * )
  *
  * v is the result of:
@@ -77,9 +77,9 @@ typedef struct {
 
 /**
  * EdgeTokenSet is the following BSON document:
- * d: <binary> // EDCDerivedFromDataTokenAndCounter
- * s: <binary> // ESCDerivedFromDataTokenAndCounter
- * c: <binary> // ECCDerivedFromDataTokenAndCounter
+ * d: <binary> // EDCDerivedFromDataTokenAndContentionFactor
+ * s: <binary> // ESCDerivedFromDataTokenAndContentionFactor
+ * c: <binary> // ECCDerivedFromDataTokenAndContentionFactor
  * p: <binary> // Encrypted Tokens
  *
  * Instances of mc_EdgeTokenSet_t are expected to be owned by

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-insert-update-payload-v2.c

@@ -18,6 +18,7 @@
 
 #include "mc-fle2-insert-update-payload-private-v2.h"
 #include "mongocrypt-buffer-private.h"
+#include "mongocrypt-util-private.h" // mc_bson_type_to_string
 #include "mongocrypt.h"
 
 void mc_FLE2InsertUpdatePayloadV2_init(mc_FLE2InsertUpdatePayloadV2_t *payload) {
@@ -53,6 +54,8 @@ void mc_FLE2InsertUpdatePayloadV2_cleanup(mc_FLE2InsertUpdatePayloadV2_t *payloa
         mc_EdgeTokenSetV2_cleanup(&entry);
     }
     _mc_array_destroy(&payload->edgeTokenSetArray);
+    bson_value_destroy(&payload->indexMin);
+    bson_value_destroy(&payload->indexMax);
 }
 
 #define IF_FIELD(Name)                                                                                                 \
@@ -104,6 +107,7 @@ bool mc_FLE2InsertUpdatePayloadV2_parse(mc_FLE2InsertUpdatePayloadV2_t *out,
     bool has_d = false, has_s = false, has_p = false;
     bool has_u = false, has_t = false, has_v = false;
     bool has_e = false, has_l = false, has_k = false;
+    bool has_sp = false, has_pn = false, has_tf = false, has_mn = false, has_mx = false;
     bson_t in_bson;
 
     BSON_ASSERT_PARAM(out);
@@ -163,6 +167,57 @@ bool mc_FLE2InsertUpdatePayloadV2_parse(mc_FLE2InsertUpdatePayloadV2_t *out,
         PARSE_BINARY(v, value)
         PARSE_BINARY(e, serverEncryptionToken)
         PARSE_BINARY(l, serverDerivedFromDataToken)
+
+        IF_FIELD(sp) {
+            if (!BSON_ITER_HOLDS_INT64(&iter)) {
+                CLIENT_ERR("Field 'sp' expected to hold an int64, got: %s",
+                           mc_bson_type_to_string(bson_iter_type(&iter)));
+                goto fail;
+            }
+            int64_t sparsity = bson_iter_int64(&iter);
+            out->sparsity = OPT_I64(sparsity);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(pn) {
+            if (!BSON_ITER_HOLDS_INT32(&iter)) {
+                CLIENT_ERR("Field 'pn' expected to hold an int32, got: %s",
+                           mc_bson_type_to_string(bson_iter_type(&iter)));
+                goto fail;
+            }
+            int32_t precision = bson_iter_int32(&iter);
+            if (precision < 0) {
+                CLIENT_ERR("Field 'pn' must be non-negative, got: %" PRId32, precision);
+                goto fail;
+            }
+            out->precision = OPT_I32(precision);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(tf) {
+            if (!BSON_ITER_HOLDS_INT32(&iter)) {
+                CLIENT_ERR("Field 'tf' expected to hold an int32, got: %s",
+                           mc_bson_type_to_string(bson_iter_type(&iter)));
+                goto fail;
+            }
+            int32_t trimFactor = bson_iter_int32(&iter);
+            if (trimFactor < 0) {
+                CLIENT_ERR("Field 'tf' must be non-negative, got: %" PRId32, trimFactor);
+                goto fail;
+            }
+            out->trimFactor = OPT_I32(trimFactor);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(mn) {
+            bson_value_copy(bson_iter_value(&iter), &out->indexMin);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(mx) {
+            bson_value_copy(bson_iter_value(&iter), &out->indexMax);
+        }
+        END_IF_FIELD
     }
 
     CHECK_HAS(d);
@@ -174,6 +229,7 @@ bool mc_FLE2InsertUpdatePayloadV2_parse(mc_FLE2InsertUpdatePayloadV2_t *out,
     CHECK_HAS(e);
     CHECK_HAS(l);
     CHECK_HAS(k);
+    // The fields `sp`, `pn`, `tf`, `mn`, and `mx` are only set for "range" payloads.
 
     if (!_mongocrypt_buffer_from_subrange(&out->userKeyId, &out->value, 0, UUID_LEN)) {
         CLIENT_ERR("failed to create userKeyId buffer");
@@ -213,7 +269,9 @@ bool mc_FLE2InsertUpdatePayloadV2_serialize(const mc_FLE2InsertUpdatePayloadV2_t
     return true;
 }
 
-bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePayloadV2_t *payload, bson_t *out) {
+bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePayloadV2_t *payload,
+                                                    bson_t *out,
+                                                    bool use_range_v2) {
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(payload);
 
@@ -257,6 +315,36 @@ bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePay
         return false;
     }
 
+    if (use_range_v2) {
+        // Encode parameters that were used to generate the payload.
+        BSON_ASSERT(payload->sparsity.set);
+        if (!BSON_APPEND_INT64(out, "sp", payload->sparsity.value)) {
+            return false;
+        }
+
+        // Precision may be unset.
+        if (payload->precision.set) {
+            if (!BSON_APPEND_INT32(out, "pn", payload->precision.value)) {
+                return false;
+            }
+        }
+
+        BSON_ASSERT(payload->trimFactor.set);
+        if (!BSON_APPEND_INT32(out, "tf", payload->trimFactor.value)) {
+            return false;
+        }
+
+        BSON_ASSERT(payload->indexMin.value_type != BSON_TYPE_EOD);
+        if (!BSON_APPEND_VALUE(out, "mn", &payload->indexMin)) {
+            return false;
+        }
+
+        BSON_ASSERT(payload->indexMax.value_type != BSON_TYPE_EOD);
+        if (!BSON_APPEND_VALUE(out, "mx", &payload->indexMax)) {
+            return false;
+        }
+    }
+
     return true;
 }
 

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-payload-iev-v2.c

@@ -180,7 +180,7 @@ bool mc_FLE2IndexedEncryptedValueV2_add_S_Key(_mongocrypt_crypto_t *crypto,
         CLIENT_ERR("Invalid ServerEncryptedValue length, got %" PRIu32 ", expected more than %d",
                    DecryptedServerEncryptedValueLen,
                    UUID_LEN);
-        return false;
+        goto fail;
     }
     _mongocrypt_buffer_resize(&iev->DecryptedServerEncryptedValue, DecryptedServerEncryptedValueLen);
     uint32_t bytes_written = 0;
@@ -196,7 +196,7 @@ bool mc_FLE2IndexedEncryptedValueV2_add_S_Key(_mongocrypt_crypto_t *crypto,
     BSON_ASSERT(bytes_written == DecryptedServerEncryptedValueLen);
     if (!_mongocrypt_buffer_from_subrange(&iev->K_KeyId, &iev->DecryptedServerEncryptedValue, 0, UUID_LEN)) {
         CLIENT_ERR("Error creating K_KeyId subrange from DecryptedServerEncryptedValue");
-        return false;
+        goto fail;
     }
     iev->K_KeyId.subtype = BSON_SUBTYPE_UUID;
 
@@ -207,7 +207,7 @@ bool mc_FLE2IndexedEncryptedValueV2_add_S_Key(_mongocrypt_crypto_t *crypto,
                                           iev->DecryptedServerEncryptedValue.len - UUID_LEN)) {
         CLIENT_ERR("Error creating ClientEncryptedValue subrange from "
                    "DecryptedServerEncryptedValue");
-        return false;
+        goto fail;
     }
 
     iev->ClientEncryptedValueDecoded = true;

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-payload-iev.c

@@ -100,7 +100,6 @@ bool mc_FLE2IndexedEncryptedValue_write(_mongocrypt_crypto_t *crypto,
         goto cleanup;                                                                                                  \
     }
 
-    const _mongocrypt_value_encryption_algorithm_t *fle2alg = _mcFLE2Algorithm();
     bool ok = false;
 
     BSON_ASSERT_PARAM(crypto);
@@ -130,27 +129,6 @@ bool mc_FLE2IndexedEncryptedValue_write(_mongocrypt_crypto_t *crypto,
                                                         index_tokens,
                                                         &encryption_out,
                                                         status));
-    uint32_t expected_plaintext_size = 0;
-    CHECK_AND_GOTO(safe_uint32_t_sum(ClientEncryptedValue->len,
-                                     (uint32_t)(sizeof(uint64_t) * 2 + sizeof(uint32_t) * 3),
-                                     &expected_plaintext_size,
-                                     status));
-
-    uint32_t expected_cipher_size = fle2alg->get_ciphertext_len(expected_plaintext_size, status);
-
-    if (expected_cipher_size == 0) {
-        CHECK_AND_GOTO(false);
-    }
-
-    uint32_t expected_buf_size = 0;
-    CHECK_AND_RETURN(
-        safe_uint32_t_sum(expected_cipher_size, (uint32_t)(1 + sizeof(S_KeyId)), &expected_buf_size, status));
-
-    if (buf->len < expected_buf_size) {
-        CLIENT_ERR("mc_FLE2IndexedEncryptedValue_write buf is not large enough for iev");
-        CHECK_AND_GOTO(false);
-    }
-
     mc_writer_t writer;
     mc_writer_init_from_buffer(&writer, buf, __FUNCTION__);
 
@@ -207,7 +185,7 @@ static bool mc_fle2IndexedEncryptedValue_encrypt(_mongocrypt_crypto_t *crypto,
     uint32_t ciphertext_len = fle2alg->get_ciphertext_len(expected_buf_size, status);
 
     if (ciphertext_len == 0) {
-        return false;
+        goto cleanup;
     }
 
     _mongocrypt_buffer_resize(out, ciphertext_len);

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-rfds-private.h

@@ -52,7 +52,7 @@ bool mc_FLE2RangeFindDriverSpec_parse(mc_FLE2RangeFindDriverSpec_t *spec,
 // `out` must be initialized by caller.
 bool mc_FLE2RangeFindDriverSpec_to_placeholders(mc_FLE2RangeFindDriverSpec_t *spec,
                                                 const mc_RangeOpts_t *range_opts,
-                                                int64_t maxContentionCounter,
+                                                int64_t maxContentionFactor,
                                                 const _mongocrypt_buffer_t *user_key_id,
                                                 const _mongocrypt_buffer_t *index_key_id,
                                                 int32_t payloadId,
@@ -73,9 +73,10 @@ typedef struct {
     mc_FLE2RangeOperator_t secondOp;
     bson_iter_t indexMin;
     bson_iter_t indexMax;
-    int64_t maxContentionCounter;
+    int64_t maxContentionFactor;
     int64_t sparsity;
-    mc_optional_uint32_t precision;
+    mc_optional_int32_t precision;
+    mc_optional_int32_t trimFactor;
 } mc_makeRangeFindPlaceholder_args_t;
 
 // mc_makeRangeFindPlaceholder creates a placeholder to be consumed by

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-rfds.c

@@ -70,7 +70,7 @@ static bool parse_and(const bson_t *in, bson_iter_t *out, mongocrypt_status_t *s
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT(status || true);
 
-    bson_iter_t and;
+    bson_iter_t and = {0};
     if (!bson_iter_init(&and, in) || !bson_iter_next(&and) || 0 != strcmp(bson_iter_key(&and), "$and")) {
         ERR_WITH_BSON(in, "%s", "error unable to find '$and'");
         return false;
@@ -105,7 +105,7 @@ parse_aggregate_expression(const bson_t *orig, bson_iter_t *in, operator_value_t
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT(status || true);
 
-    bson_iter_t array, value;
+    bson_iter_t array = {0}, value;
     const char *op_type_str = bson_iter_key(in);
     bool ok = false;
     const char *field;
@@ -162,7 +162,7 @@ parse_match_expression(const bson_t *orig, bson_iter_t *in, operator_value_t *ou
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT(status || true);
 
-    bson_iter_t document, value;
+    bson_iter_t document = {0}, value;
     const char *op_type_str;
     bool ok = false;
     const char *field = bson_iter_key(in);
@@ -217,7 +217,7 @@ bool mc_FLE2RangeFindDriverSpec_parse(mc_FLE2RangeFindDriverSpec_t *spec,
     // {$and: [{$gt: ["$age", 5]}, {$lt:["$age", 50]}]}
     // Or `in` may be a Match Expression with this form:
     // {$and: [{age: {$gt: 5}}, {age: {$lt: 50}} ]}
-    bson_iter_t and, array;
+    bson_iter_t and = {0}, array = {0};
     bool ok = false;
 
     if (!parse_and(in, &and, status)) {
@@ -264,7 +264,7 @@ bool mc_FLE2RangeFindDriverSpec_parse(mc_FLE2RangeFindDriverSpec_t *spec,
             }
         }
 
-        operator_value_t op;
+        operator_value_t op = {0};
         switch (arg_type) {
         case AGGREGATE_EXPRESSION:
             if (!parse_aggregate_expression(in, &doc, &op, status)) {
@@ -364,8 +364,10 @@ bool mc_makeRangeFindPlaceholder(mc_makeRangeFindPlaceholder_args_t *args,
         TRY(bson_append_iter(edgesInfo, "indexMin", -1, &args->indexMin));
         TRY(bson_append_iter(edgesInfo, "indexMax", -1, &args->indexMax));
         if (args->precision.set) {
-            BSON_ASSERT(args->precision.value <= INT32_MAX);
-            TRY(BSON_APPEND_INT32(edgesInfo, "precision", (int32_t)args->precision.value));
+            TRY(BSON_APPEND_INT32(edgesInfo, "precision", args->precision.value));
+        }
+        if (args->trimFactor.set) {
+            TRY(BSON_APPEND_INT32(edgesInfo, "trimFactor", args->trimFactor.value));
         }
         TRY(BSON_APPEND_DOCUMENT(v, "edgesInfo", edgesInfo));
     }
@@ -383,7 +385,7 @@ bool mc_makeRangeFindPlaceholder(mc_makeRangeFindPlaceholder_args_t *args,
     TRY(_mongocrypt_buffer_append(args->index_key_id, p, "ki", 2));
     TRY(_mongocrypt_buffer_append(args->user_key_id, p, "ku", 2));
     TRY(BSON_APPEND_DOCUMENT(p, "v", v));
-    TRY(BSON_APPEND_INT64(p, "cm", args->maxContentionCounter));
+    TRY(BSON_APPEND_INT64(p, "cm", args->maxContentionFactor));
     TRY(BSON_APPEND_INT64(p, "s", args->sparsity));
 #undef TRY
 
@@ -403,7 +405,7 @@ fail:
 
 bool mc_FLE2RangeFindDriverSpec_to_placeholders(mc_FLE2RangeFindDriverSpec_t *spec,
                                                 const mc_RangeOpts_t *range_opts,
-                                                int64_t maxContentionCounter,
+                                                int64_t maxContentionFactor,
                                                 const _mongocrypt_buffer_t *user_key_id,
                                                 const _mongocrypt_buffer_t *index_key_id,
                                                 int32_t payloadId,
@@ -469,8 +471,9 @@ bool mc_FLE2RangeFindDriverSpec_to_placeholders(mc_FLE2RangeFindDriverSpec_t *sp
                                                .indexMin = indexMin,
                                                .indexMax = indexMax,
                                                .precision = range_opts->precision,
-                                               .maxContentionCounter = maxContentionCounter,
-                                               .sparsity = range_opts->sparsity};
+                                               .maxContentionFactor = maxContentionFactor,
+                                               .sparsity = range_opts->sparsity,
+                                               .trimFactor = range_opts->trimFactor};
 
     // First operator is the non-stub.
     if (!mc_makeRangeFindPlaceholder(&args, &p1, status)) {
@@ -485,7 +488,7 @@ bool mc_FLE2RangeFindDriverSpec_to_placeholders(mc_FLE2RangeFindDriverSpec_t *sp
                                                    .payloadId = payloadId,
                                                    .firstOp = spec->firstOp,
                                                    .secondOp = spec->secondOp,
-                                                   .maxContentionCounter = maxContentionCounter,
+                                                   .maxContentionFactor = maxContentionFactor,
                                                    .sparsity = range_opts->sparsity};
 
         // First operator is the non-stub.

data/ext/libmongocrypt/libmongocrypt/src/mc-optional-private.h

@@ -23,6 +23,17 @@
 #include "./mc-dec128.h"
 #include "./mlib/int128.h"
 
+typedef struct {
+    bool set;
+    bool value;
+} mc_optional_bool_t;
+
+#define OPT_BOOL(val)                                                                                                  \
+    (mc_optional_bool_t) { .set = true, .value = val }
+
+#define OPT_BOOL_C(val)                                                                                                \
+    { .set = true, .value = val }
+
 typedef struct {
     bool set;
     int32_t value;

data/ext/libmongocrypt/libmongocrypt/src/mc-range-edge-generation-private.h

@@ -37,49 +37,59 @@ size_t mc_edges_len(mc_edges_t *edges);
 // mc_edges_destroys frees `edges`.
 void mc_edges_destroy(mc_edges_t *edges);
 
+// mc_edges_is_leaf returns whether the given edge is the leaf node of the edge set.
+bool mc_edges_is_leaf(const mc_edges_t *edges, const char *edge);
+
+// Return the trimFactor that was used to generate these edges.
+int32_t mc_edges_get_used_trimFactor(const mc_edges_t *edges);
+
 typedef struct {
     int32_t value;
     mc_optional_int32_t min;
     mc_optional_int32_t max;
     size_t sparsity;
+    mc_optional_int32_t trimFactor;
 } mc_getEdgesInt32_args_t;
 
 // mc_getEdgesInt32 implements the Edge Generation algorithm described in
 // SERVER-67751 for int32_t.
-mc_edges_t *mc_getEdgesInt32(mc_getEdgesInt32_args_t args, mongocrypt_status_t *status);
+mc_edges_t *mc_getEdgesInt32(mc_getEdgesInt32_args_t args, mongocrypt_status_t *status, bool use_range_v2);
 
 typedef struct {
     int64_t value;
     mc_optional_int64_t min;
     mc_optional_int64_t max;
     size_t sparsity;
+    mc_optional_int32_t trimFactor;
 } mc_getEdgesInt64_args_t;
 
 // mc_getEdgesInt64 implements the Edge Generation algorithm described in
 // SERVER-67751 for int64_t.
-mc_edges_t *mc_getEdgesInt64(mc_getEdgesInt64_args_t args, mongocrypt_status_t *status);
+mc_edges_t *mc_getEdgesInt64(mc_getEdgesInt64_args_t args, mongocrypt_status_t *status, bool use_range_v2);
 
 typedef struct {
     double value;
     size_t sparsity;
     mc_optional_double_t min;
     mc_optional_double_t max;
-    mc_optional_uint32_t precision;
+    mc_optional_int32_t precision;
+    mc_optional_int32_t trimFactor;
 } mc_getEdgesDouble_args_t;
 
 // mc_getEdgesDouble implements the Edge Generation algorithm described in
 // SERVER-67751 for double.
-mc_edges_t *mc_getEdgesDouble(mc_getEdgesDouble_args_t args, mongocrypt_status_t *status);
+mc_edges_t *mc_getEdgesDouble(mc_getEdgesDouble_args_t args, mongocrypt_status_t *status, bool use_range_v2);
 
 #if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 typedef struct {
     mc_dec128 value;
     size_t sparsity;
     mc_optional_dec128_t min, max;
-    mc_optional_uint32_t precision;
+    mc_optional_int32_t precision;
+    mc_optional_int32_t trimFactor;
 } mc_getEdgesDecimal128_args_t;
 
-mc_edges_t *mc_getEdgesDecimal128(mc_getEdgesDecimal128_args_t args, mongocrypt_status_t *status);
+mc_edges_t *mc_getEdgesDecimal128(mc_getEdgesDecimal128_args_t args, mongocrypt_status_t *status, bool use_range_v2);
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
 BSON_STATIC_ASSERT2(ull_is_u64, sizeof(uint64_t) == sizeof(unsigned long long));