@aztec/protocol-contracts 0.65.0 → 0.65.1

package/artifacts/FeeJuice.json

@@ -1,8 +1,231 @@
 {
   "transpiled": true,
-  "noir_version": "0.39.0+5569eb8ea1578265649219a5497a61c4d93e8d83-x8664",
+  "noir_version": "1.0.0-beta.0+c8ff97767236adc0817b37c116f045c62eb981a1-x8664",
   "name": "FeeJuice",
   "functions": [
+    {
+      "name": "public_dispatch",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "error_types": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "15238796416211288225": {
+            "error_kind": "string",
+            "string": "Balance too low"
+          },
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "2236649814169388962": {
+            "error_kind": "string",
+            "string": "PublicImmutable already initialized"
+          },
+          "3219842053230618354": {
+            "error_kind": "string",
+            "string": "Function check_balance can only be called statically"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "selector",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "public_dispatch"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLNCoQgEAfwd5lzh9Tsw1eJJawsBNEwW1iid1+LdmmXLnoZGPE3c5j/Cr1ol7GRejAzsHoFZTrupNG+W7cEWiuVkmNzfYZ0Lwgd/+eJ672dHbcOWIYTELoHRlOvB6kEMFKR7ZEAwqGAhIIsFNBAgG83VBSXJ6kopV+EMDoQjUF5DCpiUBmByO31qxwVH5ST/Bdtvn1yK3mrxJmuYdHdJWzuNYm/3E3WdKJfrNgTeAmfr7XfhbEf60e/AQ==",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "_increase_public_balance",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "internal"
+      ],
+      "abi": {
+        "error_types": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "to",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "amount",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "_increase_public_balance"
+      ]
+    },
+    {
+      "name": "balance_of_public",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "error_types": {
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "owner",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "field"
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "balance_of_public"
+      ]
+    },
     {
       "name": "claim",
       "is_unconstrained": false,
@@ -386,6 +609,12 @@
                         "type": {
                           "kind": "field"
                         }
+                      },
+                      {
+                        "name": "total_mana_used",
+                        "type": {
+                          "kind": "field"
+                        }
                       }
                     ],
                     "kind": "struct",
@@ -1541,6 +1770,12 @@
                       "type": {
                         "kind": "field"
                       }
+                    },
+                    {
+                      "name": "total_mana_used",
+                      "type": {
+                        "kind": "field"
+                      }
                     }
                   ],
                   "kind": "struct",
@@ -1655,8 +1890,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "build_msg_block",
         "attach_len_to_msg_block",
@@ -1672,29 +1907,84 @@
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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",
-      "artifact_hash": "7cb5566fe25622a27de9406180c3ef36c08c61ac-af95062002b9c90922e822b574aaf078-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "276b5434ac1f4ec77b1325d6224d183983db7ea8-7940de50cc65e61d2b0f21d50d48dfe0-mega-honk-true"
     },
     {
-      "name": "initialize",
-      "is_unconstrained": false,
+      "name": "check_balance",
+      "is_unconstrained": true,
       "custom_attributes": [
-        "private"
+        "public",
+        "view"
       ],
       "abi": {
         "error_types": {
+          "15238796416211288225": {
+            "error_kind": "string",
+            "string": "Balance too low"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "3219842053230618354": {
+            "error_kind": "string",
+            "string": "Function check_balance can only be called statically"
+          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
           }
         },
         "parameters": [
           {
-            "name": "inputs",
+            "name": "fee_limit",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "check_balance"
+      ]
+    },
+    {
+      "name": "initialize",
+      "is_unconstrained": false,
+      "custom_attributes": [
+        "private"
+      ],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          }
+        },
+        "parameters": [
+          {
+            "name": "inputs",
             "type": {
               "fields": [
                 {
@@ -2026,6 +2316,12 @@
                         "type": {
                           "kind": "field"
                         }
+                      },
+                      {
+                        "name": "total_mana_used",
+                        "type": {
+                          "kind": "field"
+                        }
                       }
                     ],
                     "kind": "struct",
@@ -2162,6 +2458,13 @@
               "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
             },
             "visibility": "private"
+          },
+          {
+            "name": "initial_mint",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
           }
         ],
         "return_type": {
@@ -3160,6 +3463,12 @@
                       "type": {
                         "kind": "field"
                       }
+                    },
+                    {
+                      "name": "total_mana_used",
+                      "type": {
+                        "kind": "field"
+                      }
                     }
                   ],
                   "kind": "struct",
@@ -3274,8 +3583,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7VjbjtpADP2XPOdhbM/Fw69U1YrbriIhQFwqVYh/70zEzNBl2siUskLKC8LJOZrj49gOnJrFcnb8eOvW75t9M/l2alab+fTQbdYhOjVA/bX9drqO4f4w3R2aCViv2ma5XoSvTqlz27x3q2UzIa/P7Q0amfiCRrYFDYYraDLgL2gyHgfQHhkuaI/eZDSSraCB2SbdXhU0UQ0MmIQAOL4Gf28b0KMxdWPMaEzdGDsaUzfG/bsxGtBc0BoslFSV74/g/3+Erx6ByqUjkHngCEeY0I60K0cAvm55UY3G1I2B0Zi6MfgIY0wxhnHAGMNpEFgo0oF0L4ceIcdjkqNpqE7gLebJ5O01PgybylpAztmG72w/DyfUr5+CeXYKqJAoSVIa9I2k+kYnSnsCQpcNSGJrUpOx83bAJcepbRiLnOBBL6e+R8lBljPokC+N6fG6FapywGSDwKqrJgsTIgqqb12dMwaj9BP72D9Czpc2AanXTwGencJAH4dotutWq+7j7befvip+6PoqApXVhrHz+UHTdA9J30My95CsmBQiiNj6u5wp1biad/0QCBFGpKsSfR5Nnm/GmQM5BeUUklO0nGLkFCunODmF5RQvprC8+iyvPsurz/Lqs7z6LK8+y6vP8upzvfo6vwKwu6F4McUrOQXkFJRTSE7RQkqI6C9/pDrIQ9c5vJmdetxBZQeF8Md0101nq2Vc0PHucT1P+zqEh5/bdCdt9O1uM18ujrtl3O1lrUdzSLVaBSkQH0/NraG85vpLSC1yXmCRYbi1nBjetkFtqW+8BqZFlev2p0POIZdf",
+      "bytecode": "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",
+      "debug_symbols": "7VjbiiIxEP2Xfu6HVOVW5a8sy+ClZ2gQFS8Li/jvm4hJdMxsU647g4wvYnWfQ06d6uS07ptZN9m9vfSL1+WmGf3YN/PldLztl4tQ7RvQx2ub1XgRy812vN42I3Cs2qZbzMJXr9ShbV77edeMNOtDe4VG0nRCI7mCBgsVtLbAJ7S2jANoRoITmpFtRiNyBQ1ELulmdYZ2NTBgEgLg6Rz8s23API2pG2OfxtSNcf9ujAG0J7QBB6VVhccl/P9fgqpLACdTAR0OLOE1+hPaa+PPlrAPPF6+hzG2GEM4YIylNFYHRTqgj3JQ3UMOY5Jj9NCcgB3m54zdBR5rmxwpdxu+k3v/qCE8fgv42S2gQq2TJGXAXEmqJzqWjaBh6IwgZ1MD5NkNuOQpbRvCIgfDSRTl1HNUI2Y5mgfkcNmYjOdboSoHbDYInDrbZOGEiILq+WVUFmSs/Y4HHLqnMXVj/NOYujF0D2PuF4l8DzlfmidaPX4L8NktDERiqCbrfj7v314ufvqq+GE+CHCVAzwk5/sHzehbSOYWkr2F5MSkUEHE1t8qbZmG5cs8DRVGpK8S2eeDia7eDDzIKSinaDnFyClWTnFyipdTSE5hMYXk0yf59Ek+fZJPn+TTJ/n0ST59kk+f6tM3+W2a/BWFxRRWcgrIKSinaDnFCCmh0n/5I9VDPnS9x6uz0zwzqGRQKH+N1/14Mu9iQMe7u8U05XUot79X6U5K9NV6Oe1mu3UXs73EejRHq9aoIAXi42motTrH3PES6hYpB1hkWGodJQa7Nqgt843XwLao8tw+WuQQevkD",
       "brillig_names": [
         "pack_arguments_oracle_wrapper",
         "enqueue_public_function_call_internal",
@@ -3283,199 +3592,8 @@
         "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
         "pack_arguments_oracle_wrapper"
       ],
-      "verification_key": "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",
-      "artifact_hash": "7cb5566fe25622a27de9406180c3ef36c08c61ac-6905d568780cdea21dc6c0bb43ed8b35-mega-honk-true"
-    },
-    {
-      "name": "balance_of_public",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
-      "abi": {
-        "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "owner",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "field"
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "balance_of_public"
-      ]
-    },
-    {
-      "name": "check_balance",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
-      "abi": {
-        "error_types": {
-          "15238796416211288225": {
-            "error_kind": "string",
-            "string": "Balance too low"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "3219842053230618354": {
-            "error_kind": "string",
-            "string": "Function check_balance can only be called statically"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "fee_limit",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "check_balance"
-      ]
-    },
-    {
-      "name": "public_dispatch",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "error_types": {
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
-          "15238796416211288225": {
-            "error_kind": "string",
-            "string": "Balance too low"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "16957488177269924912": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
-          "3219842053230618354": {
-            "error_kind": "string",
-            "string": "Function check_balance can only be called statically"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "selector",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "public_dispatch"
-      ]
+      "verification_key": "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",
+      "artifact_hash": "276b5434ac1f4ec77b1325d6224d183983db7ea8-f78a5a4fbfaed16b6eb17638bb8138b0-mega-honk-true"
     },
     {
       "name": "set_portal",
@@ -3519,105 +3637,18 @@
         "return_type": null
       },
       "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAADcJgICAAIuDAACAAMcDAMEACsCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiMCAAYAAACMJAAAAQUmAgQAAAo4AwQFIwIABQAAAKcmAgYEADsJAQYoAgADADuaygIuDAADAAUKOAUEBiMCAAYAAADIJAAAARcnAgAEAN6tLwwABAADLwwAAQACJScAgAQEeAANAAAAgASAAyMAgAMAAAEEKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVaAuQbtR6pnzsBAQIlKQEAAQUfCi0n3IKHojsBAQIlLQAYyhjK",
-      "debug_symbols": "7VfbisIwEP2XPPchM0kmib+yLFK1SqG0UuvCIv77JsXES10CRUWwL6UTzuTknM6kzIGtisV+My/rdbNjs68Dq5pl3pVN7aLDMWOLtqyqcjO/XGbcP8j2+N02r3246/K2YzMwCBkr6pV/lcbtsC6rgs2ElcdsgEYw+oRGBIxoMPYOWiPQCa1R6DMa+D0052FvzSUl0G6VTDi4C+AK/50xLT9KruGvl8shylWYkgsqgC/O0bMMsMaGjS1QAispHFlaccZS74maPLn1BBAnU4am6MmUgSliap+hKTJ9zxK/MqXPUmOy1CguZcZkkRiV9U/f6JhluUyUiDtw8BvovX+yoOmz9Bp8gF5SPOoldaW359DP57Dq6RzI+QM4DMYPYpRM1QZRvC7JiFRtSBIBrUAmawN0LFNw1/htbSDXn6UXxCP0WhHRYN9X79GFP3lb5ouqOE2W6329vBg0u99tcTNzbttmWaz2beGnz/PgCb4xhMiE8a0IPrCZBMfheP4A",
+      "debug_symbols": "7VfbioMwEP2XPPuQmSSTpL+yLMW2tgiixdqFpfTfN5FG2yoEpF0K+iKOnLmcw8zIXNgu25wP67zcVye2+rqwotqmTV6VzrpcE7ap86LID+v7z4z7B9kWfzqmpTdPTVo3bAVaY8KycudfrXUR9nmRsZWw4poM0AhG39CIgB0aDI6gNQLd0BqF7tF8LLbmPMTWXFIEDcDJhMKdAQ/474RpOSu6hv8/XQ4dXYUxuqACWJoOi1yNYI0NgS1QBCsplCw9p1CDbTVRiybPmgDiIspQFL2IMhBFLOMzFEVG96wBeBCl9VJTvNSkXMpM8SIxyWt8bgz2XkpFWsQVHPQG+uyfLGiaF1+DL+BLind8ST3wbXPo9+ew6u05kPMX5DBoerSM9QZRty7JiFhvSBIBrUBGe8PNftcbbo0/9wZyPS++IF7B14aawIL9XL5XZ/6kdZ5uiux2We7P5fbu0Gx+j9nTzXmsq222O9eZvz77wxP8YAiRCONHEbxhEwkuh8vzBw==",
       "brillig_names": [
         "set_portal"
       ]
     },
-    {
-      "name": "_increase_public_balance",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "internal"
-      ],
-      "abi": {
-        "error_types": {
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "to",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "amount",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "7V3bbts4EP0XP+eBlyGH7K8sFkGSpoUBIymSdIFF0X9f2bVoRyQ1yIG8rUm9FHXM48M5ImeGI0r8sfn8eP/96+326cvz6+bTXz82u+eHu7ft89Pw6cfPm839y3a32369Pf/zRu3/YXdo//rt7mn/8fXt7uVt80n7qG42j0+fh/+yUsMvfNnuHjefbKSff99sOAKgQAgIYYoWATEA0spAKIhLawiFXGBtFITCuD58jW+y1uScPbYm53VqrbUqtA5GmWPrYDS/a73vkaUFemRDGHtkI0s90taNPdJO5z1C5oEmZMppB41pVxzThqM/osxgWIbyBkJBXAxxsUdQQUEoglABQUVIjYioYZSCUA5BaYhLE4RClDfGQChIeSurYUjwZFrT6Fu19uHkm4IvtGajx99mYyW/N3gSHlsr8kLr4a8+pK5olflJY/3/b6/SyV5nBAvMEI/Hngzu+dQ66kP/SV95/92V9z9ed/8dXXn/r1x/b6+8/3zd/eey/wxWp/47zqJkJccTUJUcT0IRhIoIKkJcMQAoW14Jiyg5XltppeWUi8fWTrFNrT0fKLRegiKOC0Y3rPkzCn9xCrOEFcPCNlFQTuEXobCJ4mwde6QgvjiFM0tQ8OlaBJ9R8MIUkaYUfgkrjE5CGZNT8MUpeBErnEoUXmUUfHGK4C5OESuhJK12TAi584wOQkUARcpCKEZQFY8toRyEgtQwkBomICgLcVlIeYKUJ0h5gpR3shqRpQTVmrHoMJRdrZSg+jj+NrO2QoI6VMhS8hs5vEtQC0Vi70e3QJ7dxC2QC20Z6+aM9b/hyvq09PBBMpYpGctD+iRJozWnruihUviu/WCvq9xkUOlGgFbBnUlaZAk+6X9iMMr/YgiXZiB7cYaL2+AuboO7uA3ldHFRBn9phvLSfVEGtwCDS1nf2SJtz1C6zWhG3xWGGsOptS21tnF0RmRPv2xtqQpi1biQM9YIjb0de+zPyvFD070k5RpG35LQKslUkrhKMpEkrqMkk2QdJRNJvFpHSSZJWCWZSKLNKslUEl4lmUhi9CrJVBK/SjKRxK4JfSbJGoQzSdZUbSrJIqWs65OEx5KsZ51J0mcQnpPE9ZmqzUrSZxCek8T3GYRnJemz9jorSZdBmFNbft90L0nscuLMS0KrJFNJ1okzkWT4bpVkKsk6SqaS6HWUZJJ0WY6elcR0ucaZl6TLlfCsJLbLcvS8JF2uhGcloTWhzyTpciU8L0kHqdreTtdBjflgZwdJ1d5O30GmdLCzg8C2t5M7yGkOdnYQgg52dhJXetiyerCzk7gSO4krsYNl9WBnUH3ElaD6iCtBd7CqPdjZy/XsI08Ipo/1ZzB95AnBdnI9G9piRCc7nZvaydSKncGMr+QxgSzc+CBKM5P5I6Jo5vRoPcfp3qEQmpn5C4oSm0mzlxSlGd+5nChRNZPAf0iUcPZ4vHKZKM1k+0uK0szSYEFRdJ/RRxClmWLWgqK089DikqKsjjYXpZ0HF5cUZR0pBVHWkJyL0s7ji0uKsobkXBS3huSCKKujLYiyOtpcFL862oIofdZo50XhZnZxfKiar4xJXba5KF2GZEGUsI6UgihdFq4FUdp5QHpJUbpM3iRRukze5kXRSnWZvYmqdJm+SapUXsuo0yv79buzY4uq2HRoKoknxrId2zKd/W7wx+7wH9Ud82epUykf/67uNPTcY7qRbmyw2SRp51EvSueWGjo/4+5oaDvrfsnQXq4oN7PAEAwNzVR8STC0lyvazk43ydBmlnakUrJJOks2dTs70iRDqRdD24mj84a28/p6ydB2wsu8oaYXZ2R6cUammWqgYGg7L3sXDG1nw49kaC9xtJ23AwmG+nZWL/OGlk/XI3Ijiuj9efU5BfnxFFGKp6bGHwncZQkGPS9MUD7reUmCeGGCcg5BTqVh5FQ8J/iFigjKVrhsSCiiHFXhssks52yGKr/EXkDZ8ob/QONtmeCyGrKtbehNl2goSmaTy9YCoIBiBFXbMymgysULne5RaX12aPKIqhweIKEIQkUExRAXQ1wB4goQV0S4SCkIhXEFBFW7kSmgPIIykBoGmSlUvuc362uotj7QlGayzVG1Y18ElEdQtcNDBBRkV+1ezzyqtrFx1hsSI56XAsRV2yYloByAckpBKIwLiZSu9rimj6d82+SogKAMxFV7mbSA8giKIC6CuJw8NkooaGx4aBx6iIsthAoIqvZyw3lU1BDKAyivDIRC/GH1rFgBBdllFIQiCIWMDW8hDQnSEFo5eGgus0ayqNrxHobSqzCM1zkqIigDcVkDoRhBVfy8hCpfL8OpNmVirnzFzwuoihd1Ou1ZczrvYSWPElCVPSASykGoiKBiWQ1v0/XyXuWoAKCCQrhCuVYlojyCqmyvlFARQVXWRAKqssVRQjkE5SAuB9nloBHloRHlGUExNA4ZGoehonxI8YuVyVEOQUWIq+YBZlGx5gEEFCOomt8QUIiGsRKXKW1110Q6R0UEVXn9pIRiBFWJ5hLKQShIDQcp7yAuDynvIeUZUr5yxAA5TijOvE2seBsJ5RFUJd+QUOHjKKMq1V4JFRGUhrg0ZFclS5FQjKAqNSIJ5RAUKQhFH897B1RAUJWKtITyH0X9HD79c/eyvbvfPb4OmP2X358e3rbPT8ePb/9+G7+5f9nudtuvt99enh8eP39/ebzdPT/sv9uo4z9/DTcIbojUfi7tP0Z/M1Sb95/2V5c035COA+lA/B8=",
-      "brillig_names": [
-        "_increase_public_balance"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLBCoQgEAbgd5lzh7Ss9FViCSsLQTTMFpbo3deiXdqli14GRvxmDvOv0It2GRupBzMDq1dQpuNOGu27dUugtVIpOTbXZ0j3gtDxf5643tvZceuA5TgBoXtgJPV6kEoAy2i+PRJAOBRkoSAPBSQQ4NsNlODqJJQQ8kUIVwciMaiIQWUMqiJQdnt9WqDyg4qs+EWbb5/cSt4qcaZrWHR3CZt7TeIvd5M1negXK/YEXsLna+13YezH+tFv",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
     {
       "name": "compute_note_hash_and_optionally_a_nullifier",
       "is_unconstrained": true,
       "custom_attributes": [],
       "abi": {
         "error_types": {
-          "16957488177269924912": {
+          "16541607464495309456": {
             "error_kind": "fmtstring",
             "item_types": [],
             "length": 16
@@ -3695,8 +3726,8 @@
           "visibility": "public"
         }
       },
-      "bytecode": "H4sIAAAAAAAA/9VZS27bMBClLcmy5Mh27RsE6K4FxFj+ZGegn5xDTewT9ABadNOeuiHMkZ5Hk8KAh0U8QEBZQ715fDMiKWZgTjZ+/Rv469i3I9M36rP3bXmdWUWsMiTPwY3wHN4Iz+hGeMaKPAcCT9fS+5aY0zuXmtP72HPiwy7REfjNv4BY0D++zXw7BL9iYmwmDFYLf1dWz5k5N2X+q8xjpmHw14Q/DoNfEu8vTYePY6G4kW+fmk7LJ3jGWeGvsYgJl3xD8H1lvgh835gPa/g782HdEyfSbQRjUayrXei80NhSGNvgjdaYTju8R1rnJmiNWsp5xvhw/sSnoD5Nx2fEfDH4MuZLwEf6u/Ye+vHcp9DvM9znNRmZfg2Tn3KOWoeoqTgA/qtVku48J3FzHht9qHsMet4zfUKsFahPCP2dPss3+NO1s7QxrUVMT9SINBtjf+bLwBc353Fy/zuGOIhFPBLW/5P/PfPtCJ6h5+dC/BGLf8ZbuIcacaxIuEf93Tv50V9PzKl+flF/05+n9DbVm0qas/Xwty1+Fob/kfDzMPgbwp+EwW/3MndB8B9Kwi/C8H8k/GmY+mn3krMw/A+EPw+CXx1o3f1gOmvnB3+9gPt6c7e1l+yJMH7OuIbaEy0YH64Prr/OtxS4zgUfz+FSiLMU4khYmSLWnSLW7J2OcayINVHEmipiaeYxVcTS1CtXxCoUsTTrXlMvyqO0T3O29215pUn7NEV8K+3TNL/dSWuqr1jQEMeXsP4/mc6TIDztA6059K5TDIxdBIp96XpN8QuBD/HOBd81h7KHH+u1fay31pbHTbVq81kwrvwefhPhfIz9pbVf2vcpal1K3/1T0NVZDL6C+RLwEUfpu38aiP8l+mP8ueDj6/+luVyY/no4YePGM669ypi78z/pbD7w/LW+9N2k+Lnpz9f/63wR9eF76VzgOhd8fH+SC3FyIc4tYvEzetTQ1TXpFDedXyuX2133Dy6aixJzfu5vWPyE9f/tf+PYqL1mzj9ua3tc1cd6Xb+8VM/1guE7G4JOfwHiE0IYFR8AAA==",
-      "debug_symbols": "tdfNaoQwFAXgd8k6i9z8TIyvUsoQNQ6BECVqoYjv3jhM26GzLGcjXLl+AfEgZ2dD6LbbNeZxWlj7trM09X6NU67TfnDWlZhSvF2fbzNxXpy67y+zz+e4rL6srNWSs5AH1hpRnx5jCqxVTh/8ZdN+b1r7s2ma450zp2GygckXmGxhcgOTHUomIXA04WiJoxWO1jja4OgLjrY4usHRuDQSLo2ESyPh0ki4NBIujYRLI/0zjU49NuurfbEt0G6AtsPZUgBtAtoSaCugrYG2AdrAXEpgLiUwlxKVy6NOH75E36XwKFbjlvunnrV+zuFP5ZrL1IdhK+EsX7+96/yWleZa33/tdSAlOSlbD6kHfQE=",
+      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
+      "debug_symbols": "tdfNaoQwFAXgd8k6i9z8TIyvUsoQNQ6BECVqoYjv3jhM26GzLGcjXLl+AfEgZ2dD6LbbNeZxWlj7trM09X6NU67TfnDWlZhSvF2fbzNxXpy67y+zz+e4rL6srNWSs5AH1hpRnx5jCqxVTh38ZdN+b1r7s2noeOfMaZhsYPIFJluY3MBkh5JJCBxNOFriaIWjNY42OPqCoy2ObnA0Lo2ESyPh0ki4NBIujYRLI+HSSP9Mo1OPzfpqX2wLtBug7XC2FECbgLYE2gpoa6BtgDYwlxKYSwnMpUTl8qjThy/Rdyk8itW45f6pZ62fc/hTueYy9WHYSjjL12/vOr9lpbnW9197HUhJTsrWQ+pBXw==",
       "brillig_names": [
         "compute_note_hash_and_optionally_a_nullifier"
       ]
@@ -3768,7 +3799,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3779,35 +3810,23 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                    }
-                  },
-                  {
-                    "name": "amount",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
-                  {
-                    "name": "secret",
-                    "type": {
-                      "kind": "field"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   },
                   {
-                    "name": "message_leaf_index",
+                    "name": "initial_mint",
                     "type": {
                       "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::claim_parameters"
+                "path": "FeeJuice::initialize_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::claim_abi"
+          "path": "FeeJuice::initialize_abi"
         },
         {
           "fields": [
@@ -3816,7 +3835,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "owner",
                     "type": {
                       "fields": [
                         {
@@ -3827,17 +3846,23 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::initialize_parameters"
+                "path": "FeeJuice::balance_of_public_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::initialize_abi"
+          "path": "FeeJuice::balance_of_public_abi"
         },
         {
           "fields": [
@@ -3846,19 +3871,34 @@
               "type": {
                 "fields": [
                   {
-                    "name": "fee_limit",
+                    "name": "to",
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "inner",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                    }
+                  },
+                  {
+                    "name": "amount",
                     "type": {
                       "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::check_balance_parameters"
+                "path": "FeeJuice::_increase_public_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::check_balance_abi"
+          "path": "FeeJuice::_increase_public_balance_abi"
         },
         {
           "fields": [
@@ -3867,7 +3907,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "owner",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3878,23 +3918,17 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::balance_of_public_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
+                "path": "FeeJuice::set_portal_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::balance_of_public_abi"
+          "path": "FeeJuice::set_portal_abi"
         },
         {
           "fields": [
@@ -3903,34 +3937,19 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                    }
-                  },
-                  {
-                    "name": "amount",
+                    "name": "fee_limit",
                     "type": {
                       "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::_increase_public_balance_parameters"
+                "path": "FeeJuice::check_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::_increase_public_balance_abi"
+          "path": "FeeJuice::check_balance_abi"
         },
         {
           "fields": [
@@ -3939,7 +3958,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "to",
                     "type": {
                       "fields": [
                         {
@@ -3950,17 +3969,35 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                    }
+                  },
+                  {
+                    "name": "amount",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "secret",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "message_leaf_index",
+                    "type": {
+                      "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::set_portal_parameters"
+                "path": "FeeJuice::claim_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::set_portal_abi"
+          "path": "FeeJuice::claim_abi"
         }
       ]
     }
@@ -3970,143 +4007,143 @@
       "path": "std/cmp.nr",
       "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n    fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: StructDefinition) -> Quoted {\n    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n    let for_each_field = |name| quote { (_self.$name == _other.$name) };\n    let body = |fields| {\n        if s.fields().len() == 0 {\n            quote { true }\n        } else {\n            fields\n        }\n    };\n    crate::meta::make_trait_impl(\n        s,\n        quote { Eq },\n        signature,\n        for_each_field,\n        quote { & },\n        body,\n    )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n    fn eq(self, other: Field) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for u64 {\n    fn eq(self, other: u64) -> bool {\n        self == other\n    }\n}\nimpl Eq for u32 {\n    fn eq(self, other: u32) -> bool {\n        self == other\n    }\n}\nimpl Eq for u16 {\n    fn eq(self, other: u16) -> bool {\n        self == other\n    }\n}\nimpl Eq for u8 {\n    fn eq(self, other: u8) -> bool {\n        self == other\n    }\n}\nimpl Eq for u1 {\n    fn eq(self, other: u1) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for i8 {\n    fn eq(self, other: i8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i16 {\n    fn eq(self, other: i16) -> bool {\n        self == other\n    }\n}\nimpl Eq for i32 {\n    fn eq(self, other: i32) -> bool {\n        self == other\n    }\n}\nimpl Eq for i64 {\n    fn eq(self, other: i64) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for () {\n    fn eq(_self: Self, _other: ()) -> bool {\n        true\n    }\n}\nimpl Eq for bool {\n    fn eq(self, other: bool) -> bool {\n        self == other\n    }\n}\n\nimpl<T, let N: u32> Eq for [T; N]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T; N]) -> bool {\n        let mut result = true;\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<T> Eq for [T]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T]) -> bool {\n        let mut result = self.len() == other.len();\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<let N: u32> Eq for str<N> {\n    fn eq(self, other: str<N>) -> bool {\n        let self_bytes = self.as_bytes();\n        let other_bytes = other.as_bytes();\n        self_bytes == other_bytes\n    }\n}\n\nimpl<A, B> Eq for (A, B)\nwhere\n    A: Eq,\n    B: Eq,\n{\n    fn eq(self, other: (A, B)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1)\n    }\n}\n\nimpl<A, B, C> Eq for (A, B, C)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n{\n    fn eq(self, other: (A, B, C)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n    }\n}\n\nimpl<A, B, C, D> Eq for (A, B, C, D)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n    D: Eq,\n{\n    fn eq(self, other: (A, B, C, D)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n    }\n}\n\nimpl<A, B, C, D, E> Eq for (A, B, C, D, E)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n    D: Eq,\n    E: Eq,\n{\n    fn eq(self, other: (A, B, C, D, E)) -> bool {\n        self.0.eq(other.0)\n            & self.1.eq(other.1)\n            & self.2.eq(other.2)\n            & self.3.eq(other.3)\n            & self.4.eq(other.4)\n    }\n}\n\nimpl Eq for Ordering {\n    fn eq(self, other: Ordering) -> bool {\n        self.result == other.result\n    }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n    result: Field,\n}\n\nimpl Ordering {\n    // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n    // into the compiler, do not change these without also updating\n    // the compiler itself!\n    pub fn less() -> Ordering {\n        Ordering { result: 0 }\n    }\n\n    pub fn equal() -> Ordering {\n        Ordering { result: 1 }\n    }\n\n    pub fn greater() -> Ordering {\n        Ordering { result: 2 }\n    }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n    fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: StructDefinition) -> Quoted {\n    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n    let for_each_field = |name| quote {\n        if result == std::cmp::Ordering::equal() {\n            result = _self.$name.cmp(_other.$name);\n        }\n    };\n    let body = |fields| quote {\n        let mut result = std::cmp::Ordering::equal();\n        $fields\n        result\n    };\n    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u64 {\n    fn cmp(self, other: u64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u32 {\n    fn cmp(self, other: u32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u16 {\n    fn cmp(self, other: u16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u8 {\n    fn cmp(self, other: u8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i8 {\n    fn cmp(self, other: i8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i16 {\n    fn cmp(self, other: i16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i32 {\n    fn cmp(self, other: i32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i64 {\n    fn cmp(self, other: i64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for () {\n    fn cmp(_self: Self, _other: ()) -> Ordering {\n        Ordering::equal()\n    }\n}\n\nimpl Ord for bool {\n    fn cmp(self, other: bool) -> Ordering {\n        if self {\n            if other {\n                Ordering::equal()\n            } else {\n                Ordering::greater()\n            }\n        } else if other {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl<T, let N: u32> Ord for [T; N]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T; N]) -> Ordering {\n        let mut result = Ordering::equal();\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                let result_i = self[i].cmp(other[i]);\n\n                if result_i == Ordering::less() {\n                    result = result_i;\n                } else if result_i == Ordering::greater() {\n                    result = result_i;\n                }\n            }\n        }\n        result\n    }\n}\n\nimpl<T> Ord for [T]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T]) -> Ordering {\n        let mut result = self.len().cmp(other.len());\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                let result_i = self[i].cmp(other[i]);\n\n                if result_i == Ordering::less() {\n                    result = result_i;\n                } else if result_i == Ordering::greater() {\n                    result = result_i;\n                }\n            }\n        }\n        result\n    }\n}\n\nimpl<A, B> Ord for (A, B)\nwhere\n    A: Ord,\n    B: Ord,\n{\n    fn cmp(self, other: (A, B)) -> Ordering {\n        let result = self.0.cmp(other.0);\n\n        if result != Ordering::equal() {\n            result\n        } else {\n            self.1.cmp(other.1)\n        }\n    }\n}\n\nimpl<A, B, C> Ord for (A, B, C)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n{\n    fn cmp(self, other: (A, B, C)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        result\n    }\n}\n\nimpl<A, B, C, D> Ord for (A, B, C, D)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n    D: Ord,\n{\n    fn cmp(self, other: (A, B, C, D)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        if result == Ordering::equal() {\n            result = self.3.cmp(other.3);\n        }\n\n        result\n    }\n}\n\nimpl<A, B, C, D, E> Ord for (A, B, C, D, E)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n    D: Ord,\n    E: Ord,\n{\n    fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        if result == Ordering::equal() {\n            result = self.3.cmp(other.3);\n        }\n\n        if result == Ordering::equal() {\n            result = self.4.cmp(other.4);\n        }\n\n        result\n    }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v1\n    } else {\n        v2\n    }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v2\n    } else {\n        v1\n    }\n}\n\nmod cmp_tests {\n    use crate::cmp::{max, min};\n\n    #[test]\n    fn sanity_check_min() {\n        assert_eq(min(0 as u64, 1 as u64), 0);\n        assert_eq(min(0 as u64, 0 as u64), 0);\n        assert_eq(min(1 as u64, 1 as u64), 1);\n        assert_eq(min(255 as u8, 0 as u8), 0);\n    }\n\n    #[test]\n    fn sanity_check_max() {\n        assert_eq(max(0 as u64, 1 as u64), 1);\n        assert_eq(max(0 as u64, 0 as u64), 0);\n        assert_eq(max(1 as u64, 1 as u64), 1);\n        assert_eq(max(255 as u8, 0 as u8), 255);\n    }\n}\n"
     },
-    "25": {
+    "18": {
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 64 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low_lower_64 = (x as u64) as Field;\n    x = (x - low_lower_64) / TWO_POW_64;\n    let low_upper_64 = (x as u64) as Field;\n\n    let high = (x - low_upper_64) / TWO_POW_64;\n    let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(unsafe { field_less_than(b, a) });\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n"
     },
-    "26": {
+    "19": {
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::runtime::is_unconstrained;\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        assert(BIT_SIZE < modulus_num_bits() as u32);\n        self.__assert_max_bit_size(BIT_SIZE);\n    }\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_le_bits)]\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {}\n    // docs:end:to_le_bits\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_be_bits)]\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {}\n    // docs:end:to_be_bits\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    // docs:start:to_le_radix\n    pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_le_radix(radix)\n    }\n    // docs:end:to_le_radix\n\n    // docs:start:to_be_radix\n    pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_be_radix(radix)\n    }\n    // docs:end:to_be_radix\n\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    #[builtin(to_be_radix)]\n    fn __to_be_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n"
     },
-    "33": {
+    "26": {
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        if message_size == N {\n            Poseidon2::hash_internal(input, N, false)\n        } else {\n            Poseidon2::hash_internal(input, message_size, true)\n        }\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "34": {
+    "27": {
       "path": "std/hash/sha256.nr",
-      "source": "use crate::runtime::is_unconstrained;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// A message block is up to 64 bytes taken from the input.\nglobal BLOCK_SIZE = 64;\n\n// The first index in the block where the 8 byte message size will be written.\nglobal MSG_SIZE_PTR = 56;\n\n// Size of the message block when packed as 4-byte integer array.\nglobal INT_BLOCK_SIZE = 16;\n\n// A `u32` integer consists of 4 bytes.\nglobal INT_SIZE = 4;\n\n// Index of the integer in the `INT_BLOCK` where the length is written.\nglobal INT_SIZE_PTR = MSG_SIZE_PTR / INT_SIZE;\n\n// Magic numbers for bit shifting.\n// Works with actual bit shifting as well as the compiler turns them into * and /\n// but circuit execution appears to be 10% faster this way.\nglobal TWO_POW_8 = 256;\nglobal TWO_POW_16 = TWO_POW_8 * 256;\nglobal TWO_POW_24 = TWO_POW_16 * 256;\nglobal TWO_POW_32 = TWO_POW_24 as u64 * 256;\n\n// Index of a byte in a 64 byte block; ie. 0..=63\ntype BLOCK_BYTE_PTR = u32;\n\n// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.\ntype INT_BLOCK = [u32; INT_BLOCK_SIZE];\n\n// A message block is a slice of the original message of a fixed size,\n// potentially padded with zeros, with neighbouring 4 bytes packed into integers.\ntype MSG_BLOCK = INT_BLOCK;\n\n// The hash is 32 bytes.\ntype HASH = [u8; 32];\n\n// The state accumulates the blocks.\n// Its overall size is the same as the `HASH`.\ntype STATE = [u32; 8];\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n#[foreign(sha256_compression)]\npub fn sha256_compression(_input: INT_BLOCK, _state: STATE) -> STATE {}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    let num_blocks = N / BLOCK_SIZE;\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = [\n        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,\n        1541459225,\n    ];\n    // Pointer into msg_block on a 64 byte scale\n    let mut msg_byte_ptr = 0;\n    for i in 0..num_blocks {\n        let msg_start = BLOCK_SIZE * i;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n\n        // If the block is filled, compress it.\n        // An un-filled block is handled after this loop.\n        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n            h = sha256_compression(msg_block, h);\n        }\n    }\n\n    let modulo = N % BLOCK_SIZE;\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_blocks;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n    }\n\n    // If we had modulo == 0 then it means the last block was full,\n    // and we can reset the pointer to zero to overwrite it.\n    if msg_byte_ptr == BLOCK_SIZE {\n        msg_byte_ptr = 0;\n    }\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    msg_block = update_block_item(\n        msg_block,\n        msg_byte_ptr,\n        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),\n    );\n    msg_byte_ptr = msg_byte_ptr + 1;\n    let last_block = msg_block;\n\n    // If we don't have room to write the size, compress the block and reset it.\n    if msg_byte_ptr > MSG_SIZE_PTR {\n        h = sha256_compression(msg_block, h);\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        msg_byte_ptr = 0;\n    }\n\n    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n    if !is_unconstrained() {\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n    }\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if msg_start + BLOCK_SIZE > message_size {\n        if message_size < msg_start {\n            // This function is sometimes called with `msg_start` past the end of the message.\n            // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n            0\n        } else {\n            message_size - msg_start\n        }\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Apply a function on the block item which the pointer indicates.\nfn update_block_item<Env>(\n    mut msg_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    f: fn[Env](u32) -> u32,\n) -> MSG_BLOCK {\n    let i = msg_byte_ptr / INT_SIZE;\n    msg_block[i] = f(msg_block[i]);\n    msg_block\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        if item == 0 {\n            0\n        } else {\n            // Brillig wouldn't shift 0<<4 without overflow.\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod tests {\n    use super::{\n        attach_len_to_msg_block, build_msg_block, byte_into_item, get_item_byte, make_item,\n        set_item_byte_then_zeros, set_item_zeros,\n    };\n    use super::INT_BLOCK;\n    use super::sha256_var;\n\n    #[test]\n    fn smoke_test() {\n        let input = [0xbd];\n        let result = [\n            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d,\n            0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0,\n            0x8f, 0xfe, 0x73, 0x2b,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        let result = [\n            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94,\n            24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_multiple_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99,\n        ];\n        let result = [\n            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154,\n            60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_under_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59,\n        ];\n        let result = [\n            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213,\n            165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_not_block_multiple() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97,\n            103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61,\n        ];\n        let result = [\n            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186,\n            55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_with_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        let message_size = 297;\n        assert_eq(sha256_var(input, message_size), result);\n    }\n\n    #[test]\n    fn msg_big_no_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn same_msg_len_variable_padding() {\n        let input = [\n            29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253,\n            179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9,\n            236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214,\n            72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107,\n            218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198,\n            149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126,\n            32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36,\n            137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59,\n            245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97,\n            3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180,\n            170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216,\n            116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70,\n            86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246,\n            215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193,\n            104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74,\n            134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210,\n            188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210,\n            186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69,\n            79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22,\n            121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175,\n            169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53,\n            101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200,\n            157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86,\n            119, 30, 63, 129, 143, 32, 96,\n        ];\n\n        // Prepare inputs of different lengths\n        let mut input_511 = [0; 511];\n        let mut input_512 = [0; 512]; // Next block\n        let mut input_575 = [0; 575];\n        let mut input_576 = [0; 576]; // Next block\n        for i in 0..input.len() {\n            input_511[i] = input[i];\n            input_512[i] = input[i];\n            input_575[i] = input[i];\n            input_576[i] = input[i];\n        }\n\n        // Compute hashes of all inputs (with same message length)\n        let fixed_length_hash = super::sha256(input);\n        let var_full_length_hash = sha256_var(input, input.len() as u64);\n        let var_length_hash_511 = sha256_var(input_511, input.len() as u64);\n        let var_length_hash_512 = sha256_var(input_512, input.len() as u64);\n        let var_length_hash_575 = sha256_var(input_575, input.len() as u64);\n        let var_length_hash_576 = sha256_var(input_576, input.len() as u64);\n\n        // All of the above should have produced the same hash\n        assert_eq(var_full_length_hash, fixed_length_hash);\n        assert_eq(var_length_hash_511, fixed_length_hash);\n        assert_eq(var_length_hash_512, fixed_length_hash);\n        assert_eq(var_length_hash_575, fixed_length_hash);\n        assert_eq(var_length_hash_576, fixed_length_hash);\n    }\n\n    #[test]\n    fn test_get_item_byte() {\n        let fld = make_item(10, 20, 30, 40);\n        assert_eq(fld, 0x0a141e28);\n        assert_eq(get_item_byte(fld, 0), 10);\n        assert_eq(get_item_byte(fld, 4), 10);\n        assert_eq(get_item_byte(fld, 6), 30);\n    }\n\n    #[test]\n    fn test_byte_into_item() {\n        let fld = make_item(0, 20, 0, 0);\n        assert_eq(byte_into_item(20, 1), fld);\n        assert_eq(byte_into_item(20, 5), fld);\n    }\n\n    #[test]\n    fn test_set_item_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 0, 0, 0);\n        assert_eq(set_item_zeros(fld0, 3), fld1);\n        assert_eq(set_item_zeros(fld0, 4), 0);\n        assert_eq(set_item_zeros(0, 4), 0);\n    }\n\n    #[test]\n    fn test_set_item_byte_then_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 50, 0, 0);\n        assert_eq(set_item_byte_then_zeros(fld0, 1, 50), fld1);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_0() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48,\n        ];\n        assert_eq(input.len(), 22);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };\n        assert_eq(msg_byte_ptr, input.len());\n        assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));\n        assert_eq(msg_block[1], make_item(input[4], input[5], input[6], input[7]));\n        assert_eq(msg_block[5], make_item(input[20], input[21], 0, 0));\n        assert_eq(msg_block[6], 0);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_1() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        assert_eq(input.len(), 68);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };\n        assert_eq(msg_byte_ptr, 4);\n        assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));\n        assert_eq(msg_block[1], 0);\n    }\n\n    #[test]\n    fn test_attach_len_to_msg_block() {\n        let input: INT_BLOCK = [\n            2152555847, 1397309779, 1936618851, 1262052426, 1936876331, 1985297723, 543702374,\n            1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,\n            1849316213, 1651139939,\n        ];\n        let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };\n        assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);\n        assert_eq(msg_block[1], 0);\n        assert_eq(msg_block[15], 3584);\n    }\n}\n"
+      "source": "use crate::runtime::is_unconstrained;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// A message block is up to 64 bytes taken from the input.\nglobal BLOCK_SIZE: u32 = 64;\n\n// The first index in the block where the 8 byte message size will be written.\nglobal MSG_SIZE_PTR: u32 = 56;\n\n// Size of the message block when packed as 4-byte integer array.\nglobal INT_BLOCK_SIZE: u32 = 16;\n\n// A `u32` integer consists of 4 bytes.\nglobal INT_SIZE: u32 = 4;\n\n// Index of the integer in the `INT_BLOCK` where the length is written.\nglobal INT_SIZE_PTR: u32 = MSG_SIZE_PTR / INT_SIZE;\n\n// Magic numbers for bit shifting.\n// Works with actual bit shifting as well as the compiler turns them into * and /\n// but circuit execution appears to be 10% faster this way.\nglobal TWO_POW_8: u32 = 256;\nglobal TWO_POW_16: u32 = TWO_POW_8 * 256;\nglobal TWO_POW_24: u32 = TWO_POW_16 * 256;\nglobal TWO_POW_32: u64 = TWO_POW_24 as u64 * 256;\n\n// Index of a byte in a 64 byte block; ie. 0..=63\ntype BLOCK_BYTE_PTR = u32;\n\n// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.\ntype INT_BLOCK = [u32; INT_BLOCK_SIZE];\n\n// A message block is a slice of the original message of a fixed size,\n// potentially padded with zeros, with neighbouring 4 bytes packed into integers.\ntype MSG_BLOCK = INT_BLOCK;\n\n// The hash is 32 bytes.\ntype HASH = [u8; 32];\n\n// The state accumulates the blocks.\n// Its overall size is the same as the `HASH`.\ntype STATE = [u32; 8];\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n#[foreign(sha256_compression)]\npub fn sha256_compression(_input: INT_BLOCK, _state: STATE) -> STATE {}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    let num_blocks = N / BLOCK_SIZE;\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = [\n        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,\n        1541459225,\n    ];\n    // Pointer into msg_block on a 64 byte scale\n    let mut msg_byte_ptr = 0;\n    for i in 0..num_blocks {\n        let msg_start = BLOCK_SIZE * i;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n\n        // If the block is filled, compress it.\n        // An un-filled block is handled after this loop.\n        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n            h = sha256_compression(msg_block, h);\n        }\n    }\n\n    let modulo = N % BLOCK_SIZE;\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_blocks;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n    }\n\n    // If we had modulo == 0 then it means the last block was full,\n    // and we can reset the pointer to zero to overwrite it.\n    if msg_byte_ptr == BLOCK_SIZE {\n        msg_byte_ptr = 0;\n    }\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    msg_block = update_block_item(\n        msg_block,\n        msg_byte_ptr,\n        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),\n    );\n    msg_byte_ptr = msg_byte_ptr + 1;\n    let last_block = msg_block;\n\n    // If we don't have room to write the size, compress the block and reset it.\n    if msg_byte_ptr > MSG_SIZE_PTR {\n        h = sha256_compression(msg_block, h);\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        msg_byte_ptr = 0;\n    }\n\n    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n    if !is_unconstrained() {\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n    }\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if msg_start + BLOCK_SIZE > message_size {\n        if message_size < msg_start {\n            // This function is sometimes called with `msg_start` past the end of the message.\n            // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n            0\n        } else {\n            message_size - msg_start\n        }\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Apply a function on the block item which the pointer indicates.\nfn update_block_item<Env>(\n    mut msg_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    f: fn[Env](u32) -> u32,\n) -> MSG_BLOCK {\n    let i = msg_byte_ptr / INT_SIZE;\n    msg_block[i] = f(msg_block[i]);\n    msg_block\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        if item == 0 {\n            0\n        } else {\n            // Brillig wouldn't shift 0<<4 without overflow.\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod tests {\n    use super::{\n        attach_len_to_msg_block, build_msg_block, byte_into_item, get_item_byte, make_item,\n        set_item_byte_then_zeros, set_item_zeros,\n    };\n    use super::INT_BLOCK;\n    use super::sha256_var;\n\n    #[test]\n    fn smoke_test() {\n        let input = [0xbd];\n        let result = [\n            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d,\n            0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0,\n            0x8f, 0xfe, 0x73, 0x2b,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        let result = [\n            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94,\n            24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_multiple_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99,\n        ];\n        let result = [\n            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154,\n            60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_under_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59,\n        ];\n        let result = [\n            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213,\n            165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_not_block_multiple() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97,\n            103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61,\n        ];\n        let result = [\n            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186,\n            55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_with_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        let message_size = 297;\n        assert_eq(sha256_var(input, message_size), result);\n    }\n\n    #[test]\n    fn msg_big_no_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn same_msg_len_variable_padding() {\n        let input = [\n            29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253,\n            179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9,\n            236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214,\n            72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107,\n            218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198,\n            149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126,\n            32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36,\n            137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59,\n            245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97,\n            3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180,\n            170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216,\n            116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70,\n            86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246,\n            215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193,\n            104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74,\n            134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210,\n            188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210,\n            186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69,\n            79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22,\n            121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175,\n            169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53,\n            101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200,\n            157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86,\n            119, 30, 63, 129, 143, 32, 96,\n        ];\n\n        // Prepare inputs of different lengths\n        let mut input_511 = [0; 511];\n        let mut input_512 = [0; 512]; // Next block\n        let mut input_575 = [0; 575];\n        let mut input_576 = [0; 576]; // Next block\n        for i in 0..input.len() {\n            input_511[i] = input[i];\n            input_512[i] = input[i];\n            input_575[i] = input[i];\n            input_576[i] = input[i];\n        }\n\n        // Compute hashes of all inputs (with same message length)\n        let fixed_length_hash = super::sha256(input);\n        let var_full_length_hash = sha256_var(input, input.len() as u64);\n        let var_length_hash_511 = sha256_var(input_511, input.len() as u64);\n        let var_length_hash_512 = sha256_var(input_512, input.len() as u64);\n        let var_length_hash_575 = sha256_var(input_575, input.len() as u64);\n        let var_length_hash_576 = sha256_var(input_576, input.len() as u64);\n\n        // All of the above should have produced the same hash\n        assert_eq(var_full_length_hash, fixed_length_hash);\n        assert_eq(var_length_hash_511, fixed_length_hash);\n        assert_eq(var_length_hash_512, fixed_length_hash);\n        assert_eq(var_length_hash_575, fixed_length_hash);\n        assert_eq(var_length_hash_576, fixed_length_hash);\n    }\n\n    #[test]\n    fn test_get_item_byte() {\n        let fld = make_item(10, 20, 30, 40);\n        assert_eq(fld, 0x0a141e28);\n        assert_eq(get_item_byte(fld, 0), 10);\n        assert_eq(get_item_byte(fld, 4), 10);\n        assert_eq(get_item_byte(fld, 6), 30);\n    }\n\n    #[test]\n    fn test_byte_into_item() {\n        let fld = make_item(0, 20, 0, 0);\n        assert_eq(byte_into_item(20, 1), fld);\n        assert_eq(byte_into_item(20, 5), fld);\n    }\n\n    #[test]\n    fn test_set_item_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 0, 0, 0);\n        assert_eq(set_item_zeros(fld0, 3), fld1);\n        assert_eq(set_item_zeros(fld0, 4), 0);\n        assert_eq(set_item_zeros(0, 4), 0);\n    }\n\n    #[test]\n    fn test_set_item_byte_then_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 50, 0, 0);\n        assert_eq(set_item_byte_then_zeros(fld0, 1, 50), fld1);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_0() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48,\n        ];\n        assert_eq(input.len(), 22);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };\n        assert_eq(msg_byte_ptr, input.len());\n        assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));\n        assert_eq(msg_block[1], make_item(input[4], input[5], input[6], input[7]));\n        assert_eq(msg_block[5], make_item(input[20], input[21], 0, 0));\n        assert_eq(msg_block[6], 0);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_1() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        assert_eq(input.len(), 68);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };\n        assert_eq(msg_byte_ptr, 4);\n        assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));\n        assert_eq(msg_block[1], 0);\n    }\n\n    #[test]\n    fn test_attach_len_to_msg_block() {\n        let input: INT_BLOCK = [\n            2152555847, 1397309779, 1936618851, 1262052426, 1936876331, 1985297723, 543702374,\n            1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,\n            1849316213, 1651139939,\n        ];\n        let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };\n        assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);\n        assert_eq(msg_block[1], 0);\n        assert_eq(msg_block[15], 3584);\n    }\n}\n"
     },
-    "57": {
+    "50": {
       "path": "std/option.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n"
     },
-    "58": {
+    "51": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "67": {
+    "60": {
       "path": "std/uint128.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Not, Rem, Shl, Shr, Sub};\n\nglobal pow64: Field = 18446744073709551616; //2^64;\nglobal pow63: Field = 9223372036854775808; // 2^63;\npub struct U128 {\n    pub(crate) lo: Field,\n    pub(crate) hi: Field,\n}\n\nimpl U128 {\n\n    pub fn from_u64s_le(lo: u64, hi: u64) -> U128 {\n        // in order to handle multiplication, we need to represent the product of two u64 without overflow\n        assert(crate::field::modulus_num_bits() as u32 > 128);\n        U128 { lo: lo as Field, hi: hi as Field }\n    }\n\n    pub fn from_u64s_be(hi: u64, lo: u64) -> U128 {\n        U128::from_u64s_le(lo, hi)\n    }\n\n    pub fn zero() -> U128 {\n        U128 { lo: 0, hi: 0 }\n    }\n\n    pub fn one() -> U128 {\n        U128 { lo: 1, hi: 0 }\n    }\n    pub fn from_le_bytes(bytes: [u8; 16]) -> U128 {\n        let mut lo = 0;\n        let mut base = 1;\n        for i in 0..8 {\n            lo += (bytes[i] as Field) * base;\n            base *= 256;\n        }\n        let mut hi = 0;\n        base = 1;\n        for i in 8..16 {\n            hi += (bytes[i] as Field) * base;\n            base *= 256;\n        }\n        U128 { lo, hi }\n    }\n\n    pub fn to_be_bytes(self: Self) -> [u8; 16] {\n        let lo: [u8; 8] = self.lo.to_be_bytes();\n        let hi: [u8; 8] = self.hi.to_be_bytes();\n        let mut bytes = [0; 16];\n        for i in 0..8 {\n            bytes[i] = hi[i];\n            bytes[i + 8] = lo[i];\n        }\n        bytes\n    }\n\n    pub fn to_le_bytes(self: Self) -> [u8; 16] {\n        let lo: [u8; 8] = self.lo.to_le_bytes();\n        let hi: [u8; 8] = self.hi.to_le_bytes();\n        let mut bytes = [0; 16];\n        for i in 0..8 {\n            bytes[i] = lo[i];\n            bytes[i + 8] = hi[i];\n        }\n        bytes\n    }\n\n    pub fn from_hex<let N: u32>(hex: str<N>) -> U128 {\n        let N = N as u32;\n        let bytes = hex.as_bytes();\n        // string must starts with \"0x\"\n        assert((bytes[0] == 48) & (bytes[1] == 120), \"Invalid hexadecimal string\");\n        assert(N < 35, \"Input does not fit into a U128\");\n\n        let mut lo = 0;\n        let mut hi = 0;\n        let mut base = 1;\n        if N <= 18 {\n            for i in 0..N - 2 {\n                lo += U128::decode_ascii(bytes[N - i - 1]) * base;\n                base = base * 16;\n            }\n        } else {\n            for i in 0..16 {\n                lo += U128::decode_ascii(bytes[N - i - 1]) * base;\n                base = base * 16;\n            }\n            base = 1;\n            for i in 17..N - 1 {\n                hi += U128::decode_ascii(bytes[N - i]) * base;\n                base = base * 16;\n            }\n        }\n        U128 { lo: lo as Field, hi: hi as Field }\n    }\n\n    unconstrained fn uconstrained_check_is_upper_ascii(ascii: u8) -> bool {\n        ((ascii >= 65) & (ascii <= 90)) // Between 'A' and 'Z'\n    }\n\n    pub(crate) fn decode_ascii(ascii: u8) -> Field {\n        (\n            if ascii < 58 {\n                ascii - 48\n            } else {\n                let ascii =\n                    ascii + 32 * (unsafe { U128::uconstrained_check_is_upper_ascii(ascii) as u8 });\n                assert(ascii >= 97); // enforce >= 'a'\n                assert(ascii <= 102); // enforce <= 'f'\n                ascii - 87\n            }\n        ) as Field\n    }\n\n    // TODO: Replace with a faster version.\n    // A circuit that uses this function can be slow to compute\n    // (we're doing up to 127 calls to compute the quotient)\n    unconstrained fn unconstrained_div(self: Self, b: U128) -> (U128, U128) {\n        if b == U128::zero() {\n            // Return 0,0 to avoid eternal loop\n            (U128::zero(), U128::zero())\n        } else if self < b {\n            (U128::zero(), self)\n        } else if self == b {\n            (U128::one(), U128::zero())\n        } else {\n            let (q, r) = if b.hi as u64 >= pow63 as u64 {\n                // The result of multiplication by 2 would overflow\n                (U128::zero(), self)\n            } else {\n                self.unconstrained_div(b * U128::from_u64s_le(2, 0))\n            };\n            let q_mul_2 = q * U128::from_u64s_le(2, 0);\n            if r < b {\n                (q_mul_2, r)\n            } else {\n                (q_mul_2 + U128::one(), r - b)\n            }\n        }\n    }\n\n    pub fn from_integer<T>(i: T) -> U128 {\n        let f = crate::as_field(i);\n        // Reject values which would overflow a u128\n        f.assert_max_bit_size::<128>();\n        let lo = f as u64 as Field;\n        let hi = (f - lo) / pow64;\n        U128 { lo, hi }\n    }\n\n    pub fn to_integer<T>(self) -> T {\n        crate::from_field(self.lo + self.hi * pow64)\n    }\n\n    fn wrapping_mul(self: Self, b: U128) -> U128 {\n        let low = self.lo * b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = self.lo * b.hi + self.hi * b.lo + carry;\n        let hi = high as u64 as Field;\n        U128 { lo, hi }\n    }\n}\n\nimpl Add for U128 {\n    fn add(self: Self, b: U128) -> U128 {\n        let low = self.lo + b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = self.hi + b.hi + carry;\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to add with overflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Sub for U128 {\n    fn sub(self: Self, b: U128) -> U128 {\n        let low = pow64 + self.lo - b.lo;\n        let lo = low as u64 as Field;\n        let borrow = (low == lo) as Field;\n        let high = self.hi - b.hi - borrow;\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to subtract with underflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Mul for U128 {\n    fn mul(self: Self, b: U128) -> U128 {\n        assert(self.hi * b.hi == 0, \"attempt to multiply with overflow\");\n        let low = self.lo * b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = if crate::field::modulus_num_bits() as u32 > 196 {\n            (self.lo + self.hi) * (b.lo + b.hi) - low + carry\n        } else {\n            self.lo * b.hi + self.hi * b.lo + carry\n        };\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to multiply with overflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Div for U128 {\n    fn div(self: Self, b: U128) -> U128 {\n        unsafe {\n            let (q, r) = self.unconstrained_div(b);\n            let a = b * q + r;\n            assert_eq(self, a);\n            assert(r < b);\n            q\n        }\n    }\n}\n\nimpl Rem for U128 {\n    fn rem(self: Self, b: U128) -> U128 {\n        unsafe {\n            let (q, r) = self.unconstrained_div(b);\n            let a = b * q + r;\n            assert_eq(self, a);\n            assert(r < b);\n\n            r\n        }\n    }\n}\n\nimpl Eq for U128 {\n    fn eq(self: Self, b: U128) -> bool {\n        (self.lo == b.lo) & (self.hi == b.hi)\n    }\n}\n\nimpl Ord for U128 {\n    fn cmp(self, other: Self) -> Ordering {\n        let hi_ordering = (self.hi as u64).cmp((other.hi as u64));\n        let lo_ordering = (self.lo as u64).cmp((other.lo as u64));\n\n        if hi_ordering == Ordering::equal() {\n            lo_ordering\n        } else {\n            hi_ordering\n        }\n    }\n}\n\nimpl Not for U128 {\n    fn not(self) -> U128 {\n        U128 { lo: (!(self.lo as u64)) as Field, hi: (!(self.hi as u64)) as Field }\n    }\n}\n\nimpl BitOr for U128 {\n    fn bitor(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) | (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) | (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl BitAnd for U128 {\n    fn bitand(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) & (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) & (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl BitXor for U128 {\n    fn bitxor(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) ^ (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) ^ (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl Shl for U128 {\n    fn shl(self, other: u8) -> U128 {\n        assert(other < 128, \"attempt to shift left with overflow\");\n        let exp_bits: [u1; 7] = (other as Field).to_be_bits();\n\n        let mut r: Field = 2;\n        let mut y: Field = 1;\n        for i in 1..8 {\n            let bit = exp_bits[7 - i] as Field;\n            y = bit * (r * y) + (1 - bit) * y;\n            r *= r;\n        }\n        self.wrapping_mul(U128::from_integer(y))\n    }\n}\n\nimpl Shr for U128 {\n    fn shr(self, other: u8) -> U128 {\n        assert(other < 128, \"attempt to shift right with overflow\");\n        let exp_bits: [u1; 7] = (other as Field).to_be_bits();\n\n        let mut r: Field = 2;\n        let mut y: Field = 1;\n        for i in 1..8 {\n            let bit = exp_bits[7 - i] as Field;\n            y = bit * (r * y) + (1 - bit) * y;\n            r *= r;\n        }\n        self / U128::from_integer(y)\n    }\n}\n\nmod tests {\n    use crate::uint128::{pow63, pow64, U128};\n\n    #[test]\n    fn test_not(lo: u64, hi: u64) {\n        let num = U128::from_u64s_le(lo, hi);\n        let not_num = num.not();\n\n        assert_eq(not_num.hi, (hi.not() as Field));\n        assert_eq(not_num.lo, (lo.not() as Field));\n\n        let not_not_num = not_num.not();\n        assert_eq(num, not_not_num);\n    }\n    #[test]\n    fn test_construction() {\n        // Check little-endian u64 is inversed with big-endian u64 construction\n        let a = U128::from_u64s_le(2, 1);\n        let b = U128::from_u64s_be(1, 2);\n        assert_eq(a, b);\n        // Check byte construction is equivalent\n        let c = U128::from_le_bytes([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);\n        let d = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);\n        assert_eq(c, d);\n    }\n    #[test]\n    fn test_byte_decomposition() {\n        let a = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);\n        // Get big-endian and little-endian byte decompostions\n        let le_bytes_a = a.to_le_bytes();\n        let be_bytes_a = a.to_be_bytes();\n\n        // Check equivalence\n        for i in 0..16 {\n            assert_eq(le_bytes_a[i], be_bytes_a[15 - i]);\n        }\n        // Reconstruct U128 from byte decomposition\n        let b = U128::from_le_bytes(le_bytes_a);\n        // Check that it's the same element\n        assert_eq(a, b);\n    }\n    #[test]\n    fn test_hex_constuction() {\n        let a = U128::from_u64s_le(0x1, 0x2);\n        let b = U128::from_hex(\"0x20000000000000001\");\n        assert_eq(a, b);\n\n        let c = U128::from_hex(\"0xffffffffffffffffffffffffffffffff\");\n        let d = U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff);\n        assert_eq(c, d);\n\n        let e = U128::from_hex(\"0x00000000000000000000000000000000\");\n        let f = U128::from_u64s_le(0, 0);\n        assert_eq(e, f);\n    }\n\n    // Ascii decode tests\n\n    #[test]\n    fn test_ascii_decode_correct_range() {\n        // '0'..'9' range\n        for i in 0..10 {\n            let decoded = U128::decode_ascii(48 + i);\n            assert_eq(decoded, i as Field);\n        }\n        // 'A'..'F' range\n        for i in 0..6 {\n            let decoded = U128::decode_ascii(65 + i);\n            assert_eq(decoded, (i + 10) as Field);\n        }\n        // 'a'..'f' range\n        for i in 0..6 {\n            let decoded = U128::decode_ascii(97 + i);\n            assert_eq(decoded, (i + 10) as Field);\n        }\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_range_less_than_48_fails_0() {\n        crate::println(U128::decode_ascii(0));\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_less_than_48_fails_1() {\n        crate::println(U128::decode_ascii(47));\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_range_58_64_fails_0() {\n        let _ = U128::decode_ascii(58);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_58_64_fails_1() {\n        let _ = U128::decode_ascii(64);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_71_96_fails_0() {\n        let _ = U128::decode_ascii(71);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_71_96_fails_1() {\n        let _ = U128::decode_ascii(96);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_greater_than_102_fails() {\n        let _ = U128::decode_ascii(103);\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_regression() {\n        // This code will actually fail because of ascii_decode,\n        // but in the past it was possible to create a value > (1<<128)\n        let a = U128::from_hex(\"0x~fffffffffffffffffffffffffffffff\");\n        let b: Field = a.to_integer();\n        let c: [u8; 17] = b.to_le_bytes();\n        assert(c[16] != 0);\n    }\n\n    #[test]\n    fn test_unconstrained_div() {\n        // Test the potential overflow case\n        let a = U128::from_u64s_le(0x0, 0xffffffffffffffff);\n        let b = U128::from_u64s_le(0x0, 0xfffffffffffffffe);\n        let c = U128::one();\n        let d = U128::from_u64s_le(0x0, 0x1);\n        unsafe {\n            let (q, r) = a.unconstrained_div(b);\n            assert_eq(q, c);\n            assert_eq(r, d);\n        }\n\n        let a = U128::from_u64s_le(2, 0);\n        let b = U128::one();\n        // Check the case where a is a multiple of b\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (a, U128::zero()));\n        }\n\n        // Check where b is a multiple of a\n        unsafe {\n            let (c, d) = b.unconstrained_div(a);\n            assert_eq((c, d), (U128::zero(), b));\n        }\n\n        // Dividing by zero returns 0,0\n        let a = U128::from_u64s_le(0x1, 0x0);\n        let b = U128::zero();\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (U128::zero(), U128::zero()));\n        }\n        // Dividing 1<<127 by 1<<127 (special case)\n        let a = U128::from_u64s_le(0x0, pow63 as u64);\n        let b = U128::from_u64s_le(0x0, pow63 as u64);\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (U128::one(), U128::zero()));\n        }\n    }\n\n    #[test]\n    fn integer_conversions() {\n        // Maximum\n        let start: Field = 0xffffffffffffffffffffffffffffffff;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // Minimum\n        let start: Field = 0x0;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // Low limb\n        let start: Field = 0xffffffffffffffff;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // High limb\n        let start: Field = 0xffffffffffffffff0000000000000000;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n    }\n\n    #[test]\n    fn integer_conversions_fuzz(lo: u64, hi: u64) {\n        let start: Field = (lo as Field) + pow64 * (hi as Field);\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n    }\n\n    #[test]\n    fn test_wrapping_mul() {\n        // 1*0==0\n        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::one()));\n\n        // 0*1==0\n        assert_eq(U128::zero(), U128::one().wrapping_mul(U128::zero()));\n\n        // 1*1==1\n        assert_eq(U128::one(), U128::one().wrapping_mul(U128::one()));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::from_u64s_le(0, 1)));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::zero()));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(U128::from_u64s_le(0, 1), U128::from_u64s_le(0, 1).wrapping_mul(U128::one()));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(U128::from_u64s_le(0, 1), U128::one().wrapping_mul(U128::from_u64s_le(0, 1)));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::from_u64s_le(0, 1)));\n        // -1 * -1 == 1\n        assert_eq(\n            U128::one(),\n            U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff).wrapping_mul(\n                U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff),\n            ),\n        );\n    }\n}\n"
     },
-    "109": {
+    "102": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
       "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        logs::{emit_encrypted_event_log, emit_encrypted_note_log},\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log_hash::{EncryptedLogHash, LogHash, NoteLogHash},\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENCRYPTED_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_ENCRYPTED_LOGS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n        MAX_NOTE_HASHES_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub note_encrypted_logs_hashes: BoundedVec<NoteLogHash, MAX_NOTE_ENCRYPTED_LOGS_PER_CALL>,\n    pub encrypted_logs_hashes: BoundedVec<EncryptedLogHash, MAX_ENCRYPTED_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            note_encrypted_logs_hashes: self.note_encrypted_logs_hashes.storage(),\n            encrypted_logs_hashes: self.encrypted_logs_hashes.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    // NB: A randomness value of 0 signals that the kernels should not mask the contract address\n    // used in siloing later on e.g. 'handshaking' contract w/ known address.\n    pub fn emit_raw_event_log_with_masked_address<let M: u32>(\n        &mut self,\n        randomness: Field,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let contract_address = self.this_address();\n        let len = log.len() as Field + 4;\n        let side_effect = EncryptedLogHash { value: log_hash, counter, length: len, randomness };\n        self.encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_event_log(contract_address, randomness, log, counter);\n    }\n\n    pub fn emit_raw_note_log<let M: u32>(\n        &mut self,\n        note_hash_counter: u32,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let len = log.len() as Field + 4;\n        let side_effect = NoteLogHash { value: log_hash, counter, length: len, note_hash_counter };\n        self.note_encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_note_log(note_hash_counter, log, counter);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "110": {
+    "103": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
       "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Deserialize, Empty, Serialize};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_unencrypted_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_unencrypted_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call_static(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Deserialize<N>,\n    {\n        T::deserialize(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Serialize<N>,\n    {\n        self.raw_storage_write(storage_slot, value.serialize());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\n// TODO(9396): Remove.\nunconstrained fn portal() -> EthAddress {\n    portal_opcode()\n}\n// TODO(9396): Remove.\n//unconstrained fn function_selector() -> u32 {\n//    function_selector_opcode()\n//}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_unencrypted_log(message: [Field]) {\n    emit_unencrypted_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodePortal)]\nunconstrained fn portal_opcode() -> EthAddress {}\n\n// TODO(9396): Remove.\n//#[oracle(avmOpcodeFunctionSelector)]\n//unconstrained fn function_selector_opcode() -> u32 {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_unencrypted_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
-    "112": {
+    "105": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
     },
-    "123": {
+    "116": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/history/public_storage.nr",
       "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n    hash::poseidon2_hash_with_separator, header::Header, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\n\ntrait PublicStorageHistoricalRead {\n    fn public_storage_historical_read(\n        header: Header,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for Header {\n    fn public_storage_historical_read(\n        self,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field {\n        // 1) Compute the leaf index by siloing the storage slot with the contract address\n        let public_data_tree_index = poseidon2_hash_with_separator(\n            [contract_address.to_field(), storage_slot],\n            GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n        );\n\n        // 2) Get the membership witness for the tree index.\n        let witness = unsafe {\n            get_public_data_witness(\n                self.global_variables.block_number as u32,\n                public_data_tree_index,\n            )\n        };\n\n        // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n        // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n        // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n        // (slot, next index and next slot).\n        assert(\n            self.state.partial.public_data_tree.root\n                == root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path)\n                ,\n                \"Proving public value inclusion failed\",\n            );\n\n            // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n            // we have two scenarios:\n            // 1. The tree entry is initialized, and the value is the same as the one in the witness\n            // 2. The entry was never initialized, and the value is default zero (the default)\n            // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n            let preimage = witness.leaf_preimage;\n\n            let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n            let is_next_greater_than =\n                full_field_less_than(public_data_tree_index, preimage.next_slot);\n            let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n            let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n            let value = if is_in_range {\n                0\n            } else {\n                assert_eq(\n                    preimage.slot,\n                    public_data_tree_index,\n                    \"Public data tree index doesn't match witness\",\n                );\n                preimage.value\n            };\n\n            value\n        }\n}\n"
     },
-    "128": {
+    "121": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
       "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> [u8; 32] {\n    let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n    tag.to_be_bytes()\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "134": {
+    "127": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/arguments.nr",
       "source": "/// Notifies the simulator that `args` will later be used at some point during execution, referenced by their hash. This\n/// allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of arguments.\npub fn pack_arguments(args: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_oracle_wrapper(args) };\n}\n\n/// Same as `pack_arguments`, but using arrays instead of slices.\npub fn pack_arguments_array<let N: u32>(args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_array_oracle_wrapper(args) };\n}\n\nunconstrained fn pack_arguments_oracle_wrapper(args: [Field]) {\n    let _ = pack_arguments_oracle(args);\n}\n\nunconstrained fn pack_arguments_array_oracle_wrapper<let N: u32>(args: [Field; N]) {\n    let _ = pack_arguments_array_oracle(args);\n}\n\n#[oracle(packArguments)]\nunconstrained fn pack_arguments_oracle(_args: [Field]) -> Field {}\n\n#[oracle(packArgumentsArray)]\nunconstrained fn pack_arguments_array_oracle<let N: u32>(_args: [Field; N]) -> Field {}\n"
     },
-    "136": {
+    "129": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "137": {
+    "130": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_l1_to_l2_membership_witness.nr",
       "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::L1_TO_L2_MSG_TREE_HEIGHT, utils::arr_copy_slice,\n};\n\n/// Returns the leaf index and sibling path of an entry in the L1 to L2 messaging tree, which can then be used to prove\n/// its existence.\npub unconstrained fn get_l1_to_l2_membership_witness(\n    contract_address: AztecAddress,\n    message_hash: Field,\n    secret: Field,\n) -> (Field, [Field; L1_TO_L2_MSG_TREE_HEIGHT]) {\n    let returned_message =\n        get_l1_to_l2_membership_witness_oracle(contract_address, message_hash, secret);\n    let leaf_index = returned_message[0];\n    let sibling_path = arr_copy_slice(returned_message, [0; L1_TO_L2_MSG_TREE_HEIGHT], 1);\n\n    (leaf_index, sibling_path)\n}\n\n// Obtains membership witness (index and sibling path) for a message in the L1 to L2 message tree.\n#[oracle(getL1ToL2MembershipWitness)]\nunconstrained fn get_l1_to_l2_membership_witness_oracle(\n    _contract_address: AztecAddress,\n    _message_hash: Field,\n    _secret: Field,\n) -> [Field; L1_TO_L2_MSG_TREE_HEIGHT + 1] {}\n"
     },
-    "138": {
+    "131": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr",
       "source": "use dep::protocol_types::{\n    constants::PUBLIC_DATA_TREE_HEIGHT, data::PublicDataTreeLeafPreimage, utils::arr_copy_slice,\n};\n\nglobal LEAF_PREIMAGE_LENGTH: u32 = 4;\nglobal PUBLIC_DATA_WITNESS: u32 = 45;\n\npub struct PublicDataWitness {\n    pub index: Field,\n    pub leaf_preimage: PublicDataTreeLeafPreimage,\n    pub path: [Field; PUBLIC_DATA_TREE_HEIGHT],\n}\n\n#[oracle(getPublicDataTreeWitness)]\nunconstrained fn get_public_data_witness_oracle(\n    _block_number: u32,\n    _public_data_tree_index: Field,\n) -> [Field; PUBLIC_DATA_WITNESS] {}\n\npub unconstrained fn get_public_data_witness(\n    block_number: u32,\n    public_data_tree_index: Field,\n) -> PublicDataWitness {\n    let fields = get_public_data_witness_oracle(block_number, public_data_tree_index);\n    PublicDataWitness {\n        index: fields[0],\n        leaf_preimage: PublicDataTreeLeafPreimage {\n            slot: fields[1],\n            value: fields[2],\n            next_index: fields[3] as u32,\n            next_slot: fields[4],\n        },\n        path: arr_copy_slice(\n            fields,\n            [0; PUBLIC_DATA_TREE_HEIGHT],\n            1 + LEAF_PREIMAGE_LENGTH,\n        ),\n    }\n}\n"
     },
-    "143": {
+    "136": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/messaging.nr",
       "source": "use crate::{\n    hash::{compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash},\n    oracle::get_l1_to_l2_membership_witness::get_l1_to_l2_membership_witness,\n};\n\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    merkle_tree::root::root_from_sibling_path,\n};\n\npub fn process_l1_to_l2_message(\n    l1_to_l2_root: Field,\n    contract_address: AztecAddress,\n    portal_contract_address: EthAddress,\n    chain_id: Field,\n    version: Field,\n    content: Field,\n    secret: Field,\n    leaf_index: Field,\n) -> Field {\n    let secret_hash = compute_secret_hash(secret);\n    let message_hash = compute_l1_to_l2_message_hash(\n        portal_contract_address,\n        chain_id,\n        contract_address,\n        version,\n        content,\n        secret_hash,\n        leaf_index,\n    );\n\n    // We prove that `message_hash` is in the tree by showing the derivation of the tree root, using a merkle path we\n    // get from an oracle.\n    let (_leaf_index, sibling_path) =\n        unsafe { get_l1_to_l2_membership_witness(contract_address, message_hash, secret) };\n\n    let root = root_from_sibling_path(message_hash, leaf_index, sibling_path);\n    assert(root == l1_to_l2_root, \"Message not in state\");\n\n    compute_l1_to_l2_message_nullifier(message_hash, secret)\n}\n"
     },
-    "158": {
+    "151": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
     },
-    "186": {
+    "179": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
       "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicMutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicMutable<T, Context> {\n    // docs:start:public_mutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n    // docs:end:public_mutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_mutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_mutable_struct_read\n\n    // docs:start:public_mutable_struct_write\n    pub fn write(self, value: T) {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n    T: Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
     },
-    "189": {
+    "182": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr",
       "source": "use crate::{\n    context::{PrivateContext, PublicContext, UnconstrainedContext},\n    state_vars::storage::Storage,\n};\nuse dep::protocol_types::{\n    constants::INITIALIZATION_SLOT_SEPARATOR,\n    traits::{Deserialize, Serialize},\n};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n// docs:start:public_immutable_struct\npub struct PublicImmutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicImmutable<T, Context> {\n    // docs:start:public_immutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicImmutable { context, storage_slot }\n    }\n    // docs:end:public_immutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_immutable_struct_write\n    pub fn initialize(self, value: T) {\n        // We check that the struct is not yet initialized by checking if the initialization slot is 0\n        let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n        let init_field: Field = self.context.storage_read(initialization_slot);\n        assert(init_field == 0, \"PublicImmutable already initialized\");\n\n        // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n        self.context.storage_write(initialization_slot, 0xdead);\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_immutable_struct_write\n\n    // Note that we don't access the context, but we do call oracles that are only available in public\n    // docs:start:public_immutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_immutable_struct_read\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, UnconstrainedContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PrivateContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub fn read(self) -> T {\n        let header = self.context.get_header();\n        let mut fields = [0; T_SERIALIZED_LEN];\n\n        for i in 0..fields.len() {\n            fields[i] = header.public_storage_historical_read(\n                self.storage_slot + i as Field,\n                (*self.context).this_address(),\n            );\n        }\n        T::deserialize(fields)\n    }\n}\n"
     },
-    "190": {
+    "183": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
       "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n    storage::map::derive_storage_slot_in_map,\n    traits::{Deserialize, Serialize, ToField},\n};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<T, N> for Map<K, T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
     },
-    "191": {
+    "184": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
       "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for U128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        [self.to_integer()]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for U128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        U128::from_integer(fields[0])\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
     },
-    "195": {
+    "188": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/data/public_data_tree_leaf_preimage.nr",
       "source": "use crate::{merkle_tree::leaf_preimage::IndexedTreeLeafPreimage, traits::{Empty, Hash}};\n\npub struct PublicDataTreeLeafPreimage {\n    pub slot: Field,\n    pub value: Field,\n    pub next_slot: Field,\n    pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n    fn empty() -> Self {\n        Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n    }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n    fn hash(self) -> Field {\n        if self.is_empty() {\n            0\n        } else {\n            crate::hash::poseidon2_hash([\n                self.slot,\n                self.value,\n                (self.next_index as Field),\n                self.next_slot,\n            ])\n        }\n    }\n}\n\nimpl IndexedTreeLeafPreimage for PublicDataTreeLeafPreimage {\n    fn get_key(self) -> Field {\n        self.slot\n    }\n\n    fn get_next_key(self) -> Field {\n        self.next_slot\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n}\n\nimpl PublicDataTreeLeafPreimage {\n    pub fn is_empty(self) -> bool {\n        (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n    }\n}\n"
     },
-    "204": {
+    "197": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr",
       "source": "use crate::meta::{derive_deserialize, derive_serialize};\nuse crate::utils::field::field_from_bytes;\n\n// Trait: is_empty\n//\n// The general is_empty trait checks if a data type is is empty,\n// and it defines empty for the basic data types as 0.\n//\n// If a Field is equal to zero, then it is regarded as zero.\n// We will go with this definition for now, however it can be problematic\n// if a value can actually be zero. In a future refactor, we can\n// use the optional type for safety. Doing it now would lead to a worse devex\n// and would make it harder to sync up with the cpp code.\n// Preferred over Default trait to convey intent, as default doesn't necessarily mean empty.\npub trait Empty {\n    fn empty() -> Self;\n}\n\nimpl Empty for Field {\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl Empty for u1 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u8 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u32 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u64 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for U128 {\n    fn empty() -> Self {\n        U128::from_integer(0)\n    }\n}\n\npub fn is_empty<T>(item: T) -> bool\nwhere\n    T: Empty + Eq,\n{\n    item.eq(T::empty())\n}\n\npub fn is_empty_array<T, let N: u32>(array: [T; N]) -> bool\nwhere\n    T: Empty + Eq,\n{\n    array.all(|elem| is_empty(elem))\n}\n\npub trait Hash {\n    fn hash(self) -> Field;\n}\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u1 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for U128 {\n    fn to_field(self) -> Field {\n        self.to_integer()\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n\npub trait FromField {\n    fn from_field(value: Field) -> Self;\n}\n\nimpl FromField for Field {\n    fn from_field(value: Field) -> Self {\n        value\n    }\n}\n\nimpl FromField for bool {\n    fn from_field(value: Field) -> Self {\n        value as bool\n    }\n}\nimpl FromField for u1 {\n    fn from_field(value: Field) -> Self {\n        value as u1\n    }\n}\nimpl FromField for u8 {\n    fn from_field(value: Field) -> Self {\n        value as u8\n    }\n}\nimpl FromField for u32 {\n    fn from_field(value: Field) -> Self {\n        value as u32\n    }\n}\nimpl FromField for u64 {\n    fn from_field(value: Field) -> Self {\n        value as u64\n    }\n}\nimpl FromField for U128 {\n    fn from_field(value: Field) -> Self {\n        U128::from_integer(value)\n    }\n}\n\n// docs:start:serialize\n#[derive_via(derive_serialize)]\npub trait Serialize<let N: u32> {\n    fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl<let N: u32> Serialize<N> for str<N> {\n    fn serialize(self) -> [Field; N] {\n        let bytes = self.as_bytes();\n        let mut fields = [0; N];\n        for i in 0..bytes.len() {\n            fields[i] = bytes[i] as Field;\n        }\n        fields\n    }\n}\n\n// docs:start:deserialize\n#[derive_via(derive_deserialize)]\npub trait Deserialize<let N: u32> {\n    fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl<let N: u32> Deserialize<N> for str<N> {\n    fn deserialize(fields: [Field; N]) -> Self {\n        str<N>::from(fields.map(|value| value as u8))\n    }\n}\n"
     },
-    "206": {
+    "199": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
       "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
-    "207": {
+    "200": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "211": {
+    "204": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n    utils,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    ec::{pow, sqrt},\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
+      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n    utils,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "212": {
+    "205": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/eth_address.nr",
       "source": "use crate::{constants::ETH_ADDRESS_LENGTH, traits::{Deserialize, Empty, Serialize, ToField}, utils};\n\npub struct EthAddress {\n    inner: Field,\n}\n\nimpl Eq for EthAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for EthAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for EthAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn serialize(self: Self) -> [Field; ETH_ADDRESS_LENGTH] {\n        [self.inner]\n    }\n}\n\nimpl Deserialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn deserialize(fields: [Field; ETH_ADDRESS_LENGTH]) -> Self {\n        EthAddress::from_field(fields[0])\n    }\n}\n\nimpl EthAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn from_field(field: Field) -> Self {\n        field.assert_max_bit_size::<160>();\n        Self { inner: field }\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n"
     },
-    "236": {
+    "229": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedEncryptedLogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn silo_encrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    // We assume contract address has already been masked\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        accumulate_sha256(\n            [log_hash.contract_address.to_field(), log_hash.log_hash.value],\n        )\n    }\n}\n\npub fn mask_encrypted_log_hash(scoped_log: ScopedEncryptedLogHash) -> AztecAddress {\n    if scoped_log.contract_address.is_zero() {\n        AztecAddress::from_field(0)\n    } else if (scoped_log.log_hash.randomness == 0) {\n        scoped_log.contract_address\n    } else {\n        AztecAddress::from_field(poseidon2_hash_with_separator(\n            [scoped_log.contract_address.to_field(), scoped_log.log_hash.randomness],\n            0,\n        ))\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    sponge.squeeze()\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "293": {
+    "286": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr",
       "source": "use crate::{hash::merkle_hash, merkle_tree::merkle_tree::MerkleTree};\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like\n// this because it means we never even need to consider cases where\n// the index is greater than p.\npub fn root_from_sibling_path<let N: u32>(\n    leaf: Field,\n    leaf_index: Field,\n    sibling_path: [Field; N],\n) -> Field {\n    let mut node = leaf;\n    let indices: [u1; N] = leaf_index.to_le_bits();\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] == 1 {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = merkle_hash(hash_left, hash_right);\n    }\n    node\n}\n\npub fn calculate_subtree_root<let N: u32>(leaves: [Field; N]) -> Field {\n    MerkleTree::new(leaves).get_root()\n}\n\n// These values are precomputed and we run tests to ensure that they\n// are correct. The values themselves were computed from the cpp code.\n//\n// Would be good if we could use width since the compute_subtree\n// algorithm uses depth.\npub fn calculate_empty_tree_root(depth: u32) -> Field {\n    if depth == 0 {\n        0\n    } else if depth == 1 {\n        0x0b63a53787021a4a962a452c2921b3663aff1ffd8d5510540f8e659e782956f1\n    } else if depth == 2 {\n        0x0e34ac2c09f45a503d2908bcb12f1cbae5fa4065759c88d501c097506a8b2290\n    } else if depth == 3 {\n        0x21f9172d72fdcdafc312eee05cf5092980dda821da5b760a9fb8dbdf607c8a20\n    } else if depth == 4 {\n        0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e\n    } else if depth == 5 {\n        0x120157cfaaa49ce3da30f8b47879114977c24b266d58b0ac18b325d878aafddf\n    } else if depth == 6 {\n        0x01c28fe1059ae0237b72334700697bdf465e03df03986fe05200cadeda66bd76\n    } else if depth == 7 {\n        0x2d78ed82f93b61ba718b17c2dfe5b52375b4d37cbbed6f1fc98b47614b0cf21b\n    } else if depth == 8 {\n        0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1\n    } else if depth == 9 {\n        0x1849b85f3c693693e732dfc4577217acc18295193bede09ce8b97ad910310972\n    } else if depth == 10 {\n        0x2a775ea761d20435b31fa2c33ff07663e24542ffb9e7b293dfce3042eb104686\n    } else {\n        panic(f\"depth should be between 0 and 10\")\n    }\n}\n\n#[test]\nfn test_merkle_root_interop_test() {\n    // This is a test to ensure that we match the cpp implementation.\n    // You can grep for `TEST_F(root_rollup_tests, noir_interop_test)`\n    // to find the test that matches this.\n    let root = calculate_subtree_root([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);\n    assert(0x1a09d935ae110b4c861fcec8f9099ec30b4485022aeb3d3cf9d7168e38fdc231 == root);\n\n    let empty_root = calculate_subtree_root([0; 16]);\n    assert(0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e == empty_root);\n}\n\n#[test]\nfn test_empty_subroot() {\n    assert(calculate_empty_tree_root(0) == 0);\n\n    let expected_empty_root_2 = calculate_subtree_root([0; 2]);\n    assert(calculate_empty_tree_root(1) == expected_empty_root_2);\n\n    let expected_empty_root_4 = calculate_subtree_root([0; 4]);\n    assert(calculate_empty_tree_root(2) == expected_empty_root_4);\n\n    let expected_empty_root_8 = calculate_subtree_root([0; 8]);\n    assert(calculate_empty_tree_root(3) == expected_empty_root_8);\n\n    let expected_empty_root_16 = calculate_subtree_root([0; 16]);\n    assert(calculate_empty_tree_root(4) == expected_empty_root_16);\n\n    let expected_empty_root_32 = calculate_subtree_root([0; 32]);\n    assert(calculate_empty_tree_root(5) == expected_empty_root_32);\n\n    let expected_empty_root_64 = calculate_subtree_root([0; 64]);\n    assert(calculate_empty_tree_root(6) == expected_empty_root_64);\n\n    let expected_empty_root_128 = calculate_subtree_root([0; 128]);\n    assert(calculate_empty_tree_root(7) == expected_empty_root_128);\n\n    let expected_empty_root_256 = calculate_subtree_root([0; 256]);\n    assert(calculate_empty_tree_root(8) == expected_empty_root_256);\n\n    let expected_empty_root_512 = calculate_subtree_root([0; 512]);\n    assert(calculate_empty_tree_root(9) == expected_empty_root_512);\n\n    let expected_empty_root_1024 = calculate_subtree_root([0; 1024]);\n    assert(calculate_empty_tree_root(10) == expected_empty_root_1024);\n}\n"
     },
-    "319": {
+    "312": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
       "source": "pub fn field_from_bytes<let N: u32>(bytes: [u8; N], big_endian: bool) -> Field {\n    assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..15 {\n        // covers bytes 16..30 (31 is truncated and ignored)\n        low = low + (bytes32[15 + 15 - i] as Field) * v;\n        v = v * 256;\n        // covers bytes 0..14\n        high = high + (bytes32[14 - i] as Field) * v;\n    }\n    // covers byte 15\n    low = low + (bytes32[15] as Field) * v;\n\n    low + high * v\n}\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n    lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n    rhs.lt(lhs)\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n    // Tests correctness of field_from_bytes_32_trunc against existing methods\n    // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n    let inputs = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n    ];\n    let field = field_from_bytes(inputs, true);\n    let return_bytes: [u8; 31] = field.to_be_bytes();\n    assert_eq(inputs, return_bytes);\n    // 32 bytes - we remove the final byte, and check it matches the field\n    let inputs2 = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n    ];\n    let field2 = field_from_bytes_32_trunc(inputs2);\n    let return_bytes2: [u8; 31] = field.to_be_bytes();\n\n    assert_eq(return_bytes2, return_bytes);\n    assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n    // Tests the hardcoded value in constants.nr vs underlying modulus\n    // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n    let max_value = crate::constants::MAX_FIELD_VALUE;\n    assert_eq(max_value, 0 - 1);\n    // modulus == 0 is tested elsewhere, so below is more of a sanity check\n    let max_bytes: [u8; 32] = max_value.to_be_bytes();\n    let mod_bytes = std::field::modulus_be_bytes();\n    for i in 0..31 {\n        assert_eq(max_bytes[i], mod_bytes[i]);\n    }\n    assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n"
     },
-    "320": {
+    "313": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "322": {
+    "315": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/mod.nr",
       "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\npub mod arrays;\npub mod field;\npub mod reader;\npub mod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate {\n        lhs\n    } else {\n        rhs\n    }\n}\n\npub fn arr_copy_slice<T, let N: u32, let M: u32>(\n    src: [T; N],\n    mut dst: [T; M],\n    offset: u32,\n) -> [T; M] {\n    let iterator_len = if N > M { M } else { N };\n    for i in 0..iterator_len {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n"
     },
-    "394": {
+    "393": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/fee_juice_contract/src/main.nr",
-      "source": "mod lib;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract FeeJuice {\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, view}, storage::storage},\n        protocol_types::{address::{AztecAddress, EthAddress}, constants::FEE_JUICE_INITIAL_MINT},\n        state_vars::{Map, PublicImmutable, PublicMutable},\n    };\n\n    use crate::lib::get_bridge_gas_msg_hash;\n\n    #[storage]\n    struct Storage<Context> {\n        // This map is accessed directly by protocol circuits to check balances for fee payment.\n        // Do not change this storage layout unless you also update the base rollup circuits.\n        balances: Map<AztecAddress, PublicMutable<U128, Context>, Context>,\n        portal_address: PublicImmutable<EthAddress, Context>,\n    }\n\n    // Not flagged as initializer to reduce cost of checking init nullifier in all functions.\n    // This function should be called as entrypoint to initialize the contract by minting itself funds.\n    #[private]\n    fn initialize(portal_address: EthAddress) {\n        // Validate contract class parameters are correct\n        let self = context.this_address();\n\n        // Increase self balance and set as fee payer, and end setup\n        FeeJuice::at(self)._increase_public_balance(self, FEE_JUICE_INITIAL_MINT).enqueue(\n            &mut context,\n        );\n        context.set_as_fee_payer();\n        context.end_setup();\n\n        // Enqueue call to set the portal address\n        FeeJuice::at(self).set_portal(portal_address).enqueue(&mut context);\n    }\n\n    // We purposefully not set this function as an initializer so we do not bind\n    // the contract to a specific L1 portal address, since the Fee Juice address\n    // is a hardcoded constant in the rollup circuits.\n    #[public]\n    fn set_portal(portal_address: EthAddress) {\n        assert(storage.portal_address.read().is_zero());\n        storage.portal_address.initialize(portal_address);\n    }\n\n    #[private]\n    fn claim(to: AztecAddress, amount: Field, secret: Field, message_leaf_index: Field) {\n        let content_hash = get_bridge_gas_msg_hash(to, amount);\n        let portal_address = storage.portal_address.read();\n        assert(!portal_address.is_zero());\n\n        // Consume message and emit nullifier\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // TODO(palla/gas) Emit an unencrypted log to announce which L1 to L2 message has been claimed\n        // Otherwise, we cannot trace L1 deposits to their corresponding claims on L2\n        FeeJuice::at(context.this_address())._increase_public_balance(to, amount).enqueue(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    fn _increase_public_balance(to: AztecAddress, amount: Field) {\n        let new_balance = storage.balances.at(to).read().add(U128::from_integer(amount));\n        storage.balances.at(to).write(new_balance);\n    }\n\n    #[public]\n    #[view]\n    fn check_balance(fee_limit: Field) {\n        let fee_limit = U128::from_integer(fee_limit);\n        assert(storage.balances.at(context.msg_sender()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    // utility function for testing\n    #[public]\n    #[view]\n    fn balance_of_public(owner: AztecAddress) -> pub Field {\n        storage.balances.at(owner).read().to_field()\n    }\n}\n"
+      "source": "mod lib;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract FeeJuice {\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, view}, storage::storage},\n        protocol_types::address::{AztecAddress, EthAddress},\n        state_vars::{Map, PublicImmutable, PublicMutable},\n    };\n\n    use crate::lib::get_bridge_gas_msg_hash;\n\n    #[storage]\n    struct Storage<Context> {\n        // This map is accessed directly by protocol circuits to check balances for fee payment.\n        // Do not change this storage layout unless you also update the base rollup circuits.\n        balances: Map<AztecAddress, PublicMutable<U128, Context>, Context>,\n        portal_address: PublicImmutable<EthAddress, Context>,\n    }\n\n    // Not flagged as initializer to reduce cost of checking init nullifier in all functions.\n    // This function should be called as entrypoint to initialize the contract by minting itself funds.\n    #[private]\n    fn initialize(portal_address: EthAddress, initial_mint: Field) {\n        // Validate contract class parameters are correct\n        let self = context.this_address();\n\n        // Increase self balance and set as fee payer, and end setup\n        FeeJuice::at(self)._increase_public_balance(self, initial_mint).enqueue(&mut context);\n        context.set_as_fee_payer();\n        context.end_setup();\n\n        // Enqueue call to set the portal address\n        FeeJuice::at(self).set_portal(portal_address).enqueue(&mut context);\n    }\n\n    // We purposefully not set this function as an initializer so we do not bind\n    // the contract to a specific L1 portal address, since the Fee Juice address\n    // is a hardcoded constant in the rollup circuits.\n    #[public]\n    fn set_portal(portal_address: EthAddress) {\n        assert(storage.portal_address.read().is_zero());\n        storage.portal_address.initialize(portal_address);\n    }\n\n    #[private]\n    fn claim(to: AztecAddress, amount: Field, secret: Field, message_leaf_index: Field) {\n        let content_hash = get_bridge_gas_msg_hash(to, amount);\n        let portal_address = storage.portal_address.read();\n        assert(!portal_address.is_zero());\n\n        // Consume message and emit nullifier\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // TODO(palla/gas) Emit an unencrypted log to announce which L1 to L2 message has been claimed\n        // Otherwise, we cannot trace L1 deposits to their corresponding claims on L2\n        FeeJuice::at(context.this_address())._increase_public_balance(to, amount).enqueue(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    fn _increase_public_balance(to: AztecAddress, amount: Field) {\n        let new_balance = storage.balances.at(to).read().add(U128::from_integer(amount));\n        storage.balances.at(to).write(new_balance);\n    }\n\n    #[public]\n    #[view]\n    fn check_balance(fee_limit: Field) {\n        let fee_limit = U128::from_integer(fee_limit);\n        assert(storage.balances.at(context.msg_sender()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    // utility function for testing\n    #[public]\n    #[view]\n    fn balance_of_public(owner: AztecAddress) -> pub Field {\n        storage.balances.at(owner).read().to_field()\n    }\n}\n"
     },
-    "395": {
+    "394": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/fee_juice_contract/src/lib.nr",
       "source": "use dep::aztec::context::PublicContext;\nuse dep::aztec::prelude::AztecAddress;\nuse dep::aztec::protocol_types::hash::sha256_to_field;\n\npub fn calculate_fee<TPublicContext>(context: PublicContext) -> Field {\n    context.transaction_fee()\n}\n\npub fn get_bridge_gas_msg_hash(owner: AztecAddress, amount: Field) -> Field {\n    let mut hash_bytes = [0; 68];\n    let recipient_bytes: [u8; 32] = owner.to_field().to_be_bytes();\n    let amount_bytes: [u8; 32] = amount.to_be_bytes();\n\n    // The purpose of including the following selector is to make the message unique to that specific call. Note that\n    // it has nothing to do with calling the function.\n    let selector = comptime { std::hash::keccak256(\"claim(bytes32,uint256)\".as_bytes(), 22) };\n\n    for i in 0..4 {\n        hash_bytes[i] = selector[i];\n    }\n\n    for i in 0..32 {\n        hash_bytes[i + 4] = recipient_bytes[i];\n        hash_bytes[i + 36] = amount_bytes[i];\n    }\n\n    let content_hash = sha256_to_field(hash_bytes);\n    content_hash\n}\n"
     }