From ad67003124b792d51cdd46ceb91164e3d70b0764 Mon Sep 17 00:00:00 2001
From: Tom French <tom@tomfren.ch>
Date: Sat, 26 Aug 2023 22:35:05 +0100
Subject: [PATCH] chore: constrain length of slice returned from field
 decomposition functions

---
 noir_stdlib/src/field.nr | 39 ++++++++++++++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/noir_stdlib/src/field.nr b/noir_stdlib/src/field.nr
index 5d3581689f5..25ce3897cec 100644
--- a/noir_stdlib/src/field.nr
+++ b/noir_stdlib/src/field.nr
@@ -1,9 +1,16 @@
 
 impl Field {
-    #[builtin(to_le_bits)]
-    fn to_le_bits(_x : Field, _bit_size: u32) -> [u1] {}
-    #[builtin(to_be_bits)]
-    fn to_be_bits(_x : Field, _bit_size: u32) -> [u1] {}
+    
+    fn to_le_bits(x : Field, bit_size: u32) -> [u1] {
+        let bit_array = x.__to_le_bits(bit_size);
+        assert(bit_array.len() == bit_size as Field);
+        bit_array
+    }
+    fn to_be_bits(x : Field, bit_size: u32) -> [u1] {
+        let bit_array = x.__to_be_bits(bit_size);
+        assert(bit_array.len() == bit_size as Field);
+        bit_array
+    }
 
     fn to_le_bytes(x : Field, byte_size: u32) -> [u8] {
         x.to_le_radix(256, byte_size)
@@ -12,12 +19,30 @@ impl Field {
         x.to_be_radix(256, byte_size)
     }
 
-    #[builtin(to_le_radix)]
+    fn to_le_radix(x : Field, radix: u32, result_len: u32) -> [u8] {
+        let radix_array = x.__to_le_radix(radix, result_len);
+        assert(radix_array.len() == result_len as Field);
+        radix_array
+    }
+    
+    fn to_be_radix(x : Field, radix: u32, result_len: u32) -> [u8] {
+        let radix_array = x.__to_be_radix(radix, result_len);
+        assert(radix_array.len() == result_len as Field);
+        radix_array
+    }
+
+    #[builtin(to_le_bits)]
+    fn __to_le_bits(_x : Field, _bit_size: u32) -> [u1] {}
+    #[builtin(to_be_bits)]
+    fn __to_be_bits(_x : Field, _bit_size: u32) -> [u1] {}
+
+
     //decompose _x into a _result_len vector over the _radix basis
     //_radix must be less than 256
-    fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}
+    #[builtin(to_le_radix)]
+    fn __to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}
     #[builtin(to_be_radix)]
-    fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}
+    fn __to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}
 
     // Returns self to the power of the given exponent value.
     // Caution: we assume the exponent fits into 32 bits