@sip-protocol/sdk 0.7.3 → 0.7.4

package/dist/chunk-3INS3PR5.mjs

@@ -1,884 +0,0 @@
-// src/proofs/circuits/funding_proof.json
-var funding_proof_default = { noir_version: "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", hash: "3675851086238636874", abi: { parameters: [{ name: "minimum_required", type: { kind: "field" }, visibility: "public" }, { name: "asset_id", type: { kind: "field" }, visibility: "public" }, { name: "balance", type: { kind: "field" }, visibility: "private" }, { name: "blinding", type: { kind: "field" }, visibility: "private" }], return_type: { abi_type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "public" }, error_types: { "2900908756532713827": { error_kind: "string", string: "Insufficient balance" }, "12469291177396340830": { error_kind: "string", string: "call to assert_max_bit_size" }, "15764276373176857197": { error_kind: "string", string: "Stack too deep" }, "15835548349546956319": { error_kind: "string", string: "Field failed to decompose into specified 32 limbs" } } }, bytecode: "H4sIAAAAAAAA/+1dB7gVtbZe2RRpiigqcK8yVkBsgFixoXQVFaS3QwfhHEBAsOCxY6XYBQQEqSJdQQHl2vWCICpgAyt6LVhRLNc38WQ42XMye/JnJjO+9718Xwg7szLrX1n5V/59AGVU1EqLcXDegPyKpYh2l6ISzZtySKsx2faE3hcO+7DetDorLmryxHXXdehau8HnzUevHDLh3A9/uvtb93kGsD1CH8NfcZXywKgAAvEgfmV/R0ZxeKTBuqNIfzNNcR0lTTh66/YcsozqpSAGwLbkQsBPhsySXkv+7HcalhQ5gWE++bu9E+45LS3GOE49sgFyYmuLsY4HUnaqswG1DMDWIuxUmOLK+NYhuMJ8HE3RYggzry18oLHXJYwJ3qHk6wqledJ/D6tjiPUYMsN6TA6sOnmra7Du10ysZ7aL7/3saBEXiuu3iLjCzDmHODaUS8B+MSSG0gJLJoeNEzDv3/MsECFrfY2hPPPasZTjxgl7D1J0ZMLITkN8lriMjvat99aFHczfwYPptdI+P/6WqxCHYTqO7BxgJFY5LxxPoe95WPz+GJH4j5ds969Hm2tuazi67oEnFbQeeeO2tgvGVJ1RZ0flat+MaDRy93sFMikPbnDBpLWXDFx052mVm9WvsOmaTTcPbPD2uFuvP/qHwvajyx4+0TT+40X8cSohwDariJwgxnqUEEFN338C4WSsT2YJ4usKpXkiDGs9A6wNyAxrA4qmCuobrPtvAqqggQGuPy2rAv6LiSoA9ov9+b9QFaA889qJlIIqkJ2aqIITCT+Y3HmAj5zNpipoSHYOMBKrnBeOp9D33KYqOIn0VcGfgCowjf8kKlYFQaRGOYLI9Sh+TAvAyZRCAZCdmhSAkwkvAMywAJQB/SAEOAWwRb4WIMWCGZKFYy/0PfcXi7CYTiV9UstfC+IsFqbxn0p/n68Qp4nxdFL8MDXMadAPLZGfQofZAj94ZXt+MYihVEIxhNk2IrvxniZ8oEXwDDI77HxdoTRP+u9hpxtiPZPMsJ5J5l/HGolY0XWlwcsF/TrWSMSF4ioTEZeOOceGfh0D9oshMfxdvo6hPPPaWRRBjQFFJ4swslNUjTXyrffWhR3Msgl9HWsEYDqb7BzgsoYK42yK/nUMif8c0ldYMinDFJZp/OdQ/ArL9I+rG4vxXEqIoKbvb0w4Gc8jswTxdYXSPBGG9VwDrE3IDGsTiqYKzjNYVy4BVdDEAFd5y6qAE8dEFQD7xcr/L1QFKM+81pRSUAWyUxNV0JTwg1nhb6gKmpGdA1zB8FbkeAp9z22qguakrwrKA6rANP7mFP8PaRG5HsWPaQFoQSkUANmpSQFoQXgBqJjQD2kRArQEbJGvBUixqGhIFo690Pcc/SFtK9Intfy1IM5iYRp/K0X8Nvnzd/iqcr4YL/AboX9BH/lL9+eTvmy9gNLZ0FJktqEXirG13wjdUBlA2IZeSPob2powdpRze3lpzhFjuTNHV9nSsPzIOt+WHVHv9wNe/WP0nEnfvHbq+LMGtD+mV0HLTrJtjWu7/brg2npdjpxb7YdKL29ucNa/51+5+ZXKVT+4btULtXff3VW21WmebZmWcwZe/tptJ17SrfOatz85fXr1u26u3P3Ui44aN3RbkwmrP8nIts6U15855rf2u3eVLjhvc40Xf/1lWNuFL519dekve9boecura4+SbREMx/6y8uxPb93nwv2v2N7m8l8/e+jgEa0HNPxsduETfe8ZXu/7detk2+PWjd3Ysd+qNitumnDc3gfenNf2sSfm/WvTL91qvTpm55K142+QbcNaWTHyHJ0vxgvEeKEYW/uwhrQMYIu8l13k/nKx2y+hIpJ6/5KmhKHBezVtlc2JYOaQTmNZqshb08btbd1+qdvbub292zu4vaPbOXE6u72L2zkxurm9u9t7uD3P7T3d3svtvd3ex+193d7P7f3dPsDtA91+mdsHuX2w2/PdXuD2IW4f6vZhHhjv2uNgyvnm2irmLlXMtVPMtVfMdVDMdVTMdVLMdVbMdVHMdVXMdVPMdVfM9VDM5Snmeirmeinmeivm+ijm+irm+inm+ivmBijmBirmLlPMDVLMDVbM5SvmChRzQxRzQxVzw8Sc3A4Vo0NaLYv0YRdjG03bnX/+ydpq2xK7VNfWxdtOz3Yiv5zba9n++NdF3kHHdnvRpd9Rw7axEAidwm3He2Kic6htwR7h0SXMdkWxSOkaYjtKEjTdcts2k8VP95y2O7KEUo9ctvWzRVVeDttaPgHWk/TFWq9A2/b+s856B9kWluAF6xNgW1iSQ6yv2na5gm+sn9L2PBU3WX+VbWslj9kAhe2Tas6zgSVtawfUB3ZZCdupQbWEDfLbnhBYd9hgn+324BrF8rNth+aoZ6wgy/aCXLWPDZFte+Wsk2yoZHt87prKhpG+6Irzn0wPI+1avlH2d3kUh3wx8neduPPLAR/DNd9r+s+reQzDFevCYhhOWJL5z9Ti+OEqcLg2qCYd0nKThXWEGEcWPSo+sSOo+OcJ3hw38isY9Ks9cJLZCNI/ICMJ2zw0OfxQjCDsMH0r1jh6PmKtGENJe5+nyP6uiOKQLwYrxpQrAB+jSH/jTWMYRXDFmDKKKJWKMVTfdrJq0iEtN1lYR4vxyqJHxSd2NJWsGNwoasUATjIbTfoH5Eoy2zz0r/8imK4i/X3Z8wvwfl7FRhH+Fw6Qq/pq/fcWBwJguUr4QGNHcMVZiYeQ9vldKvu7JopDvhisxEuvAXyMIf2NN41hDMGVeOkYinb4dAjED5JNAl1LWAxeQwsTksNC0o81zhtuiL7tEtWkQ1pusrBeJ8brix4VV4LrqOQNx42i3nBAhWDXkX7SriezzUMPEoLpBop2w4Wt4eQpJJzYN5LdW+sG4cM2Lq+hObwRsL2J7OYwqMjqFGdd25sJK2hxqYEC0ub6ONnfLVEc8sWgGhh3C+BjLOlvvGkMYwlWA+PG6vtQ4tIhAj9INsl2K2Fk8xqKCcnhbZSOGijQt71LNemQlpssrLeL8Y6iR8WV4HYqqQa4UVQ1AFQIdjvpJ+0OMts89CAhmO4kuzcJJ89thBP7Ln0fxeAAXHcKH7ZxeQ3N4V2A7Tiym8OgIhu2Dimy4/XfG+vPBvJJm+uO7G9CFId8MagGnAmAj4mkv/GmMUwkWA04E/V9KHHpEIEfJJtku5uSUQNIDu+hdNRAvr5tTdWkQ1pusrDeK8b7ih4VV4J7qaQa4EZR1QBQIdi9pJ+0+8hs89CDhGC6n+zeJJw89xBO7Af0fRSDA3DdL3zYxuU1NIcPALYPkt0cBhXZsHVIkX1I/72xqoHBpM31DbK/SVEc8sWgGtgwCfAxmfQ33jSGyQSrgQ2T9X0ocekQgR8km2SbQsmoASSHD1M6amCwvu3rqkmHtNxkYZ0qxmlFj4orwVQqqQa4UVQ1AFQINpX0kzaNzDYPPUgIpulk9ybh5HmYcGI/ou+jGByAa7rwYRuX19AcPgLYziC7OQwqsmHrkCI7U/+9saqBQaTN9TzZ36NRHPLFoBrIexTwMYv0N940hlkEq4G8Wfo+lLh0iMAPkk2yzaZk1ACSwzmUjhoYpG/bQzXpkJabLKxzxTiv6FFxJZhLJdUAN4qqBoAKweaSftLmkdnmoQcJwTSf7N4knDxzCCf2Y/o+isEBuOYLH7ZxeQ3N4WOA7QKym8OgIhu2Dimyj+u/N1Y1cBlpc32L7G9hFId8MagGtiwEfCwi/Y03jWERwWpgyyJ9H0pcOkTgB8km2RZTMmoAyeESSkcNXKZvu1k16ZCWmyysS8W4rOhRcSVYSiXVADeKqgaACsGWkn7SlpHZ5qEHCcG0nOzeJJw8Swgn9hP6PorBAbiWCx+2cXkNzeETgO2TZDeHQUU2bB1SZFfovzdWNTCQtLneQva3MopDvhhUAy1WAj6eIv2NN43hKYLVQIun9H0ocekQgR8km2R7mpJRA0gOV1E6amCgvm1z1aRDWm6ysK4W45qiR8WVYDWVVAPcKKoaACoEW036SVtDZpuHHiQE0zNk9ybh5FlFOLGfJbtq4BnhwzYur6E5fBawXUt2cxhUZMPWIUX2X/rvjVUNDCBtri+W/T0XxSFfDKqBxc8BPp4n/Y03jeF5gtXA4uf1fShx6RCBHySbZHuBklEDSA5fpHTUwAB920WqSYe03GRhfUmMLxc9Kq4EL1FJNcCNoqoBoEKwl0g/aS+T2eahBwnB9ArZvUk4eV4knNiv6vsoBgfgekX4sI3La2gOXwVsXyO7OQwqsmHrniX9GP6t/95Y1UB/0ub6KtnfuigO+WJQDaxaB/hYT/obbxrDeoLVwKr1+j6UuHSIwA+STbK9TsmoASSHGygdNdBf3/Zp1aRDWm6ysG4U4xtFj4orwUYqqQa4UVQ1AFQItpH0k/YGmW0eepAQTJvI7k3CybOBcGK/qe+jGByAa5PwYRuX19AcvgnYvkV2cxhUZMPWIUX2bf33xqoG+pE211vJ/jZHccgXg2qg1WbAxxbS33jTGLYQrAZabdH3ocSlQwR+kGySbSslowaQHL5D6aiBfvq2LVWTDmm5ycL6rhjfK3pUXAnepZJqgBtFVQNAhWDvkn7S3iOzzUMPEoLpfbJ7k3DyvEM4sT/Q91EMDsD1vvBhG5fX0Bx+ANhuI7s5DCqyYeuQIrtd/72xqoG+pM31Qtnfh1Ec8sWgGij8EPDxEelvvGkMHxGsBgo/0vehxKVDhO1kl2wfUzJqAMnhJ5SOGuirb3utatIhLTdZWD8V42dFj4orwadUUg1wo6hqAKgQ7FPST9pnZLZ56EFCMO0guzcJJ88nhBP7c30fxeAAXDuED9u4vIbm8HPA9guym8OgIhu2Dimy/9F/b6xqoA9pcz1LDXwZxSFfjKqBLwEfX5H+xpvG8BXhauArfR9KXDpE4AfJJtm+pmTUAJLDbygdNdBH3zY2NbBTjN8WPSquBDuppBrgRlHVAFAh2E7ST9q3ZLZ56EFCMH1Hdm8STp5vCCf29/o+isEBuL4TPmzj8hqaw+8B2x/Ibg6DimzYOqTI/qj/3ljVQG/S5vpc2d9PURzyxaAamPsT4GMX6W+8aQy7CFYDc3fp+1Di0iECP0g2yfYzJaMGkBz+Qumogd76tnNUkw5pucnCuluMvxY9Kq4Eu6mkGuBGUdUAUCHYbtJP2q9ktnnoQUIw/UZ2bxJOnl8IJ/bv+j6KwQG4fhM+bOPyGprD3wHbP8huDoOKbNg6pMj+V/+9saqBXqTN9Zmyvz+jOOSLQTUw80/ABwel815TNdBLLALVwEwZl14g+u/3iMAPkk2yMQbkQWooJiSHGQBTnGqgl77tDNWkQ1pusrCWEiBL+2/+UqykGuBGUdUAUCFYKSBppZnZ5qEHCcFUBjzc6IHh5MkwnNhlIxaOMHMed9kEcHkNzWFZIId7Wc5hUJENW4cU2XLAvsapBnqSNte3yv7KswgO+WJQDWwtDyS5AnB4TGOogKuBrRUsqwFOhHLMLtkqgmTzGooJyWGllNRAT33bLapJh7TcZGHdW4Dcx3/z761QA/vEoAaACsH2BpK2DzPbPPQgIZgqW75JOHkqMZzY+0YsHGHmPO59E8DlNTSH+wI5rGI5h0FFNmwdUmT3S0kN5JE219fL/vY3VQN5YjGoBtbvDyS5KrDxpjFUxdXA+qqW1QAnwn7MLtkOAMnmNRQTksMDU1IDefq261STDmm5ycJ6kABZzX/zH6RQA9ViUANAhWAHAUmrxsw2Dz1ICKbqlm8STp4DGU7sGhELR5g5j7tGAri8huawBpDDf1jOYVCRDVuHFNl/pqQGepA216vL/g42VQM9xGJQDVQ/GEjyIcDGm8ZwCK4Gqh9iWQ1wIvyT2SVbTZBsXkMxITl0UlIDPfRtq6kmHdJyk4X1UAHyMP/Nf6hCDRwWgxroQfpq4FAgaYcxs81DDxKC6XDLN8lf5GE4sY+IWDjCzHncRySAy2toDo8Acnik5RwGFdmwdUiRPSolNdCdtLm+UvZXy1QNdBeLQTWwshaQ5NrAxpvGUBtXAytrW1YDnAhHMbtkqwOSzWsoJiSHR6ekBrrr265QTTqk5SYLa10B8hj/zV9XoQaOiUENABWC1QWSdgwz2zz0ICGYjrV8k3DyHM1wYh8XsXCEmfO4j0sAl9fQHB4H5PB4yzkMKrJh65Aie0JKaqAbaXN9rOyvnqka6CYWg2pgbD0gyfWBjTeNoT6uBsbWt6wGOBFOYHbJ1gAkm9dQTEgOT0xJDXTTt71FNemQlpssrA0FyJP8N39DhRo4KQY1AFQI1hBI2knMbPPQg4RgOtnyTcLJcyLDiX1KxMIRZs7jPiUBXF5Dc3gKkMNTLecwqMiGrUOK7GkpqYGupM315rK/003VQFexGFQDzU8HktwI2HjTGBrhaqB5I8tqgBPhNGaXbGeAZPMaignJ4ZkpqYGu+rbNVJMOabnJwnqWAHm2/+Y/S6EGzo5BDQAVgp0FJO1sZrZ56EFCMJ1j+Sbh5DmT4cRuHLFwhJnzuBsngMtraA4bAzk813IOg4ps2DqkyJ6XkhroQtpcnyD7a2KqBrqIxaAamNAESHJTYONNY2iKq4EJTS2rAU6E85hdsjUDyeY1FBOSw+YpqYEu+rbjVZMOabnJwur9n0Rb+m/+Fgo10DIGNQBUCNYCSFpLZrZ56EFCMLWyfJNw8jRnOLHPj1g4wsx53OcngMtraA7PB3J4geUcBhXZsHVIkb0wJTXQmbS5PkT219pUDXQWi0E1MKQ1kOSLgI03jeEiXA0MuciyGuBEuJDZJdvFINm8hmJCcnhJSmqgs75tgWrSIS03WVjbCJBt/Td/G4UaaBuDGgAqBGsDJK0tM9s89CAhmC61fJNw8lzCcGK3i1g4wsx53O0SwOU1NIftgBy2t5zDoCIbtg4psh1SUgOdSJvra2R/HU3VQCexGFQDazoCSe4EbLxpDJ1wNbCmk2U1wInQgdklW2eQbF5DMSE57JKSGuikb7taNemQlpssrF0FyG7+m7+rQg10i0ENABWCdQWS1o2ZbR56kBBM3S3fJJw8XRhO7B4RC0eYOY+7RwK4vIbmsAeQwzzLOQwqsmHrkCLbMyU10JG0ue7I/nqZqoGOYjGoBpxeQJJ7AxtvGkNvXA04vS2rAU6Enswu2fqAZPMaignJYd+U1EBHfduaqkmHtNxkYe0nQPb33/z9FGqgfwxqAKgQrB+QtP7MbPPQg4RgGmD5JuHk6ctwYg+MWDjCzHncAxPA5TU0hwOBHF5mOYdBRTZsHVJkB6WkBjqQNtcryf4Gm6qBDmIxqAYqDQaSnA9svGkM+bgaqJRvWQ1wIgxidslWAJLNaygmJIdDUlIDHfRtK6omHdJyk4V1qAA5zH/zD1WogWExqAGgQrChQNKGMbPNQw8SgulyyzcJJ88QhhN7eMTCEWbO4x6eAC6voTkcDuRwhOUcBhXZsHVIkR2ZkhpoT9pcz5f9XWGqBtqLxaAayL8CSPIoYONNYxiFq4H8UZbVACfCSGaXbKNBsnkNxYTk8MqU1EB7fdvBqkmHtNxkYb1KgLzaf/NfpVADV8egBoAKwa4CknY1M9s89CAhmK6xfJNw8lzJcGKPiVg4wsx53GMSwOU1NIdjgBxeazmHQUU2bB1SZAtTUgPtSJvrVWR/15mqgXZiMagGqlwHJPl6YONNY7geVwNVrresBjgRCpldst0Aks1rKCYkhzempAba6dvuq5p0SMtNFtabBMib/Tf/TQo1cHMMagCoEOwmIGk3M7PNQw8SgukWyzcJJ8+NDCf22IiFI8ycxz02AVxeQ3M4FsjhrZZzGFRkw9YhRfa2lNTApfq2Wf5uN1UDl4rF6Lo7gM00xXWHFKFD+g0lET+wtzG7pLgTJIXXUExIXu6KSFSdmO8yyGGchGpLZoQaZ0qotmIxum68ZUJxXONjIlSYOU/8eGZ2YBw9H7EekjYARtnfBNND0kYsRtk9AWDsRMsHiscw0SDJE1m0w6dziCYyXB7cCezX3RFjCDNvI3wQti6roWfrbiD+eyLeHGFrgm7ksHXIjXyv5RzyPbrX4CJA8lCaigthVLyMzM4ZYX4c7ckSjZFcb70197kf7nf7A25/0O0PuX2S2ye7fYrbH3b7VLdPc/t0tz/i9hlu5/8P8EfdPsvts90+x+1z3T7P7fPd/pjbF7j9cbcvdPsity92+xK3L3X7MrcvZ5T9fZ+DKeebu18x94Bi7kHF3EOKuUmKucmKuSmKuYcVc1MVc9MUc9MVc48o5mYo5mYq5h5VzM1SzM1WzM1RzM1VzM1TzM1XzD2mmFugmHtcMbdQMbdIMbdYMbdEMbdUMbdMMbeclfzZ0qFidEirZZE+rNjws61jy38Odb+2LbEHdG1dvA/q2U508bKHtGx/5LGxSTq22//aBzZZw7Zx0Z6xKeG248X+sodDbQu8XLCpYbYr9uSNTQuxHVWcYzY9t20z6TywR3La7pDPDpuRy7Z+1jljM3PY1so+k+zRYNsuvvPLZgXatvefdTY7yLawBC/YnADbwpIcYnPVtssVfGPzlLbnqbjJ5qtsWyt5zB5T2D6p5jxbUNK2dkB9YI+XsJ0aVEvYQr/tCYF1hy3y2W4PrlFscbbt0Bz1jC3Jsr0gV+1jS2XbXjnrJFsm2R6fu6ay5UxfdMX5jXe5fi3fKPt7gkVwyBeDf+q48Qn9DWJPagZl+o2Xx8B9MDCGJ8Ekx/WnY8Dh2qCadEjLTRbWFQLkX/+nHFmtrBAbJ8+tZNH/dAw4yWwFcEBWgpuHJocfihXgYeK4VqRUMZbp7/MU2d9TphWDO3wKrxhTngIqxtOWKwaP4Wm8Ykx5OqWKsUzf72TVpENabrKwrhIgV/urwypFxVgdQ8UATjJbBRyQ1Yabh/6gDsG0BiDDnl8ALE+KA47+oA65qp8ByKCKIcyc79EzBpUYwRVnJV6qf36Xyv6eNa3E/C3P4pV46bPA4VtruRLzGNbilXjp2oiHT4dAz1gm0L/AGLyGFiYkh88BZyPOG26pvt8lqkmHtNxkYX1egHzBf5s9r7jhXojhhgMqBHseSNoLhpuHHiQE04sRb7iwNZw8zxncDi9FLBxh5jzulxLA5TU0hy8BOXzZcg6DiqxOcda1fQUsaHGpgSX6XB8n+3vVVA1wh6/iamDcq8AGvQZsvGkMr+FqYNxrltUAJ8IrzC7Z/g2SzWsoJiSH61JSA0v0/d6lmnRIy00W1vUC5Ov+m3+9Qg28HoMaACoEWw8k7XXDzUMPEoJpg+WbhJNnHcOJvTFi4Qgz53FvTACX19AcbgRy+IblHAYV2bB1SJHdBOxrnGpgsT7XHdnfm6ZqgDt8E1cDzptAkt8CNt40hrdwNeC8ZVkNcCJsYnbJ9jZINq+hmJAcbk5JDSzW9xvbf3duiwC51X/zb1Goga0xqAGgQrAtQNK2Gm4eepAQTO9Yvkk4eTYznNjvRiwcYeY87ncTwOU1NIfvAjl8z3IOg4ps2DqkyL6fkhpYpM/1DbK/D0zVAHf4Aa4GNnwAJHkbsPGmMWzD1cCGbZbVACfC+8wu2baDZPMaignJ4YcpqYFF+n5fV006pOUmC+tHAuTH/pv/I4Ua+DgGNQBUCPYRkLSPDTcPPUgIpk8s3yScPB8ynNifRiwcYeY87k8TwOU1NIefAjn8zHIOg4ps2DqkyO5ISQ0s1Od6nuzvc1M1wB1+jquBvM+BJH8BbLxpDF/gaiDvC8tqgBNhB7NLtv+AZPMaignJ4ZcpqYGF+n57qCYd0nKThfUrAfJr/83/lUINfB2DGgAqBPsKSNrXhpuHHiQE0zeWbxJOni8ZTuydEQtHmDmPe2cCuLyG5nAnkMNvLecwqMiGrUOK7HcpqYHH9bm+Rfb3vaka4A6/x9XAlu+BJP8AbLxpDD/gamDLD5bVACfCd8wu2X4EyeY1FBOSw59SUgOP6/vdrJp0SMtNFtZdAuTP/pt/l0IN/ByDGgAqBNsFJO1nw81DDxKC6RfLNwknz08MJ/buiIUjzJzHvTsBXF5Dc7gbyOGvlnMYVGTD1iFF9reU1MACfa63kP39bqoGuMPfcTXQ4ncgyX8AG28awx+4Gmjxh2U1wInwG7NLtv+CZPMaignJ4Z8pqYEF+n6bqyYd0nKTjVV8YBnKvvn5A78a4EZR1QBQIf5CqmP7rcCmiSFr89CDhGDKZLDDjR4YTp4/DW7dUvq4isGRPi4ed6mMfVxeQ3NYCshhacs5DCqyYeuQIlsG2Nc41cBj+lxfLPsrm4ngkC8G1cDiskCS9wIOj2kMe4Hk4THsFZHUOkQok7FLtnIg2byGYkJyWB7AFKcakMkT0hapJh3ScpOFtYL4UNGvBioo1EDFGNQAUCFYBSBpFTNmm4ceJARTJcs3CSdPeYNbd2/LaoDHvXcCuLyG5nBvIIf7WM5hUJENW4cU2copqYH5+lxfJfvb11QNcIf74mpg1b5AkqtYVgM8hiq4GlhVxbIa4ESonLFLtv0SUgNIDvdPSQ3I5AlpT6smHdJyk4W1qvhwgF8NVFWogQNiUANAhWBVgaQdkDHbPPQgIZgOtHyTcPLsb3DrHmRZDfC4D0oAl9fQHB4E5LCa5RwGFdmwdUiRrZ6SGpinz/VWsr8apmqAO6yBq4FWNYAk/8OyGuAx/ANXA63+YVkNcCJUz9gl2z8TUgNIDg9OSQ3I5AlpLVWTDmm5ycJ6iPhQ068GDlGogZoxqAGgQrBDgKTVzJhtHnqQEEyO5ZuEk+dgg1v3UMtqgMd9aAK4vIbm8FAgh4dZzmFQkQ1bhxTZw1NSA3P1uV4o+zvCVA1wh0fgaqDwCCDJR1pWAzyGI3E1UHikZTXAiXB4xi7ZjkpIDSA5rJWSGpDJE9KuVU06pOUmC2tt8aGOXw3UVqiBOjGoAaBCsNpA0upkzDYPPUgIpqMt3yScPLUMbt26ltUAj7tuAri8huawLpDDYyznMKjIhq1DiuyxKamBOYZq4DhTNcAdHmegBo4Dkny8ZTXAYzjeQA0cb1kNcCIcm7FLthMSUgNIDuulpAZk8oS02NRAffGhgV8N1FeogQYxqAGgQrD6QNIaJKQGEEwnWr5JOHnqGdy6DS2rAR53wwRweQ3NYUMghydZzmFQkQ1bhxTZk1NSA7P1uT5X9neKqRrgDk/B1cDcU4Akn2pZDfAYTsXVwNxTLasBToSTM3bJdlpCagDJ4ekpqQGZPCFtjmrSIS03WVgbiQ9n+NVAI4UaOCMGNQBUCNYISNoZGbPNQw8SgulMyzcJJ8/pBrfuWZbVAI/7rARweQ3N4VlADs+2nMOgIhu2Dimy56SkBmbpc32m7K+xqRrgDhvjamBmYyDJ51pWAzyGc3E1MPNcy2qAE+GcjF2ynZeQGkBy2CQlNSCTJ6TNUE06pOUmC2tT8aGZXw00VaiBZjGoAaBCsKZA0pplzDYPPUgIpuaWbxJOniYGt24Ly2qAx90iAVxeQ3PYAshhS8s5DCqyYeuQItsqJTXwqD7Xt8r+zjdVA9zh+bga2Ho+kOQLLKsBHsMFuBrYeoFlNcCJ0Cpjl2wXJqQGkBy2TkkNyOQJaVtUkw5pucnCepH4cLFfDVykUAMXx6AGgArBLgKSdnHGbPPQg4RgusTyTcLJ09rg1m1jWQ3wuNskgMtraA7bADlsazmHQUU2bB1SZC9NSQ3M1Of6etlfO1M1wB22w9XA+nZAkttbVgM8hva4Gljf3rIa4ES4NGOXbB0SUgNIDjumpAZk8oS0dapJh7TcZGHtJD509quBTgo10DkGNQBUCNYJSFrnjNnmoQcJwdTF8k3CydPR4NbtalkN8Li7JoDLa2gOuwI57GY5h0FFNmwdUmS7p6QGZuhzvbrsr4epGuAOe+BqoHoPIMl5ltUAjyEPVwPV8yyrAU6E7hm7ZOuZkBpActgrJTUgkyekVVNNOqTlJgtrb/Ghj18N9FaogT4xqAGgQrDeQNL6ZMw2Dz1ICKa+lm8STp5eBrduP8tqgMfdLwFcXkNz2A/IYX/LOQwqsmHrkCI7ICU18Ig+11fK/gaaqgHucCCuBlYOBJJ8mWU1wGO4DFcDKy+zrAY4EQZk7JJtUEJqAMnh4JTUgEyekLZCNemQlpssrPniQ4FfDeQr1EBBDGoAqBAsH0haQcZs89CDhGAaYvkm4eQZbHDrDrWsBnjcQxPA5TU0h0OBHA6znMOgIhu2Dimyl6ekBqbrc32s7G+4qRrgDofjamDscCDJIyyrAR7DCFwNjB1hWQ1wIlyesUu2kQmpASSHV6SkBmTyhLRbVJMOabnJwjpKfBjtVwOjFGpgdAxqAKgQbBSQtNEZs81DDxKC6UrLNwknzxUGt+5VltUAj/uqBHB5Dc3hVUAOr7acw6AiG7YOKbLXpKQGpulzvbnsb4ypGuAOx+BqoPkYIMnXWlYDPIZrcTXQ/FrLaoAT4ZqMXbIVJqQGkBxel5IakMkT0pqpJh3ScpOF9Xrx4Qa/GrheoQZuiEENABWCXQ8k7YaM2eahBwnBdKPlm4ST5zqDW/cmy2qAx31TAri8hubwJiCHN1vOYVCRDVuHFNlbUlIDU/W5PkH2N9ZUDXCHY3E1MGEskORbLasBHsOtuBqYcKtlNcCJcEvGLtluS0gNIDm8PSU1IJMnpI1XTTqk5SYL6x3iw51+NXCHQg3cGYMaACoEuwNI2p0Zs81DDxKC6S7LNwknz+0Gt+44y2qAxz0uAVxeQ3M4DsjheMs5DCqyYeuQIjshJTXwsD7Xh8j+JpqqAe5wIq4GhkwEkny3ZTXAY7gbVwND7rasBjgRJmTsku2ehNQAksN7U1IDMnlCWoFq0iEtN1lY7xMf7vergfsUauD+GNQAUCHYfUDS7s+YbR56kBBMD1i+STh57jW4dR+0rAZ43A8mgMtraA4fBHL4kOUcBhXZsHVIkZ2UkhqYos/1NbK/yaZqgDucjKuBNZOBJE+xrAZ4DFNwNbBmimU1wIkwKWOXbA8npAaQHE5NSQ3I5Alpq1WTDmm5ycI6TXyY7lcD0xRqYHoMagCoEGwakLTpGbPNQw8SgukRyzcJJ89Ug1t3hmU1wOOekQAur6E5nAHkcKblHAYV2bB1SJF9NCU1MFmf647sb5apGuAOZ+FqwJkFJHm2ZTXAY5iNqwFntmU1wInwaMYu2eYkpAaQHM5NSQ3I5AlpNVWTDmm5ycI6T3yY71cD8xRqYH4MagCoEGwekLT5GbPNQw8SgukxyzcJJ89cg1t3gWU1wONekAAur6E5XADk8HHLOQwqsmHrkCK7MCU1MEmf65Vkf4tM1QB3uAhXA5UWAUlebFkN8BgW42qg0mLLaoATYWHGLtmWJKQGkBwuTUkNyOQJaRVVkw5pucnCukx8WO5XA8sUamB5DGoAqBBsGZC05RmzzUMPEoLpCcs3CSfPUoNb90nLaoDH/WQCuLyG5vBJIIcrLOcwqMiGrUOK7MqU1MBD+lzPl/09ZaoGuMOncDWQ/xSQ5KctqwEew9O4Gsh/2rIa4ERYmbFLtlUJqQEkh6tTUgMyeULaYNWkQ1pusrCuER+e8auBNQo18EwMagCoEGwNkLRnMmabhx4kBNOzlm8STp7VBrfuWstqgMe9NgFcXkNzuBbI4b8s5zCoyIatQ4rscympgQf1uV5F9ve8qRrgDp/H1UCV54Ekv2BZDfAYXsDVQJUXLKsBToTnMnbJ9mJCagDJ4UspqQGZPCFtX9WkQ1pusrC+LD684lcDLyvUwCsxqAGgQrCXgaS9kjHbPPQgIZhetXyTcPK8ZHDrvmZZDfC4X0sAl9fQHL4G5PDflnMYVGTD1iFFdl1KauAB/YKW5W+9qRrgDtdn8HWvW77hOa7XpbLrkH5DScQP7LqMXVJsSOjWRvKyMSJRdWLeaJDDOAl1vyGh3jAlFHf4hgGhNlkmFMe1KSZChZnzxG/KmB0YR89HrIfkPqaPUfb3pukh4Q7fNKg4bwKMfcvygeIxvGWQ5Lcsfwfjh+gtA3mwAdivty3LQb63bxuS1Wvo2XobiH+zZYkXdCOHrUNu5C2Wc8j3aIvBRYDkgb+bf5c+W8I4TIxDxThEjAVizBfjYDEOEuNlYhwoxgFi7C/GfmLsK8Y+Yuwtxl5i7CnGPDH2EGN3MXYTY1cxdhFjZzF2EmNHMXYQY3sxthPjpWJsK8Y2YlzOisZlYlwqxiViXCzGRWJcKMbHxbhAjI+Jcb4Y54lxrhjniHG2GGeJ8VExzhTjDDE+IsbpYpwmxqlifFiMU8Q4WYyTxPiQGB8U4wNivF+MvGZsdc/OO25/1+3vuf19t3/g9m1u3+72D93+kds/dvsnbv/U7Z+5fYfbP3f7F27/j9u/dPtXbv/a7d+4fafbv3X7d27/3u0/uP1Ht//k9l1u/9ntv2Qoq6HcLU36535rTF97wzCVATC9kxCmsgCmdxPCtBeA6b2EMJUDML2fEKbyAKYPEsJUAcC0LSFMFQFM2xPCVAnA9GFCmPYGMH2UEKZ9AEwfJ4SpMoDpk4Qw7Qtg+jQhTFUATJ8lhGk/ANOOhDDtD2D6PCFMVQFMXySE6QAA038SwnQggOnLhDAdBGD6KiFM1QBMXyeEqTqA6ZuEMNUAMO1MCNM/AEzfJoTpnwCm7xLCdDCA6fuEMB0CYPohIUw1AUw/JoTJATD9lBCmQwFMuxLCdBiA6eeEMB0OYPoFwJSRxlKU/XeMmOTT+ztI/Gcp/GcX/GcF/Ls5/y7Mv3vy73r8uxX/LsO/O3CtzrUx16Jc+3GtxbUN1xL87uZ3Jb+b+F3Aay+vdby2cC573OFng+ficLHGa+XF2K3c1NWN36i4QHq059/kqJ7tn+PZATmeVcvxrEaOZ4fleHZEjmd1cjyrm+PZ8Tme1cvx7NQcz07P8ezMHM/OzvGseY5nLXM8a53j2cU5nl0ixl5bf9h1RPXGteVno8VYs2yTty+p+9y78rNTM+pnZcVYWYx9B/QZ1Lv7oD6XX959eP+8/Opi2vtbbB6lOJ04xRzSaqyctA5fX9jM/7foQP9/rffWGKzPeOtLm63fs83n+daT772VxGcmrT3P90wua03EyMvYPtLvK0treGsq+fLeXc73PjCmphH39K+v9ir/vFUQcewvL5Cel6XsWOT3VFI8k9/rnSWzXI5q5r3Xe2cZ6fdyK+0bPRuvBJeX/Huj/McgQe2dF356e1nL+oOr+Nbz5u0Bj9M7D7379CoYPKTg8j7d+w/IH36ImP2/wugo+COcXiWjVSc5F6PDWNtEeh/zPWuq8BsxpiYRq1xmPwqubB6jvdNfSmErn6Uyko1qX0kxxyi4KpSjknlwxLh/Pdpcc1vD0XUPPKmg9cgbt7VdMKbqjDo7Klf7ZkSjkbvfK/DHksmBvRKFV6ZMwP6kXZkOFqPtyuTFOWh4UU06Rnz+f5URiX//rzJKNi2VcZi8gIr3qQwFc7m0z/ZgaY2nWjzsZcywl/VyUVbx0Hu2l/Rufw0qp8DNFO9S1VQPM39/bem9fjs/Hvns7uV7pjqL8l+y8Ndob3RIqzGVH6bw83dXiLXEaLsOq85+HArb+wdDvQcM69Nr+ICRfboPyB/ZZ9hwLx5vfw/wrXdIq+2p81XN1iv5dID0e++9/vuIAB9ek8+Av8m1RLYt5xtVmiWksSAcKv7vJ8aq0twBvmfFuRxe0H1YXu8Bo6r4UBpWuT3ry5qt33Ma9jJbX0p1GvaSfu/FpdpBPwM8LOXNsFRgCv+lfO/0Y5BtSlPJlvF9Lu2bL6Vhqzo13rPKCnz+deUVWOU5Lwf+G0a2lxUFb2UC3rWXD4P/fETN0X4Knx4270eocuUb3qdfn2Hdh44oGD6gT/5wP7crmKHIeOsrmq1X1sAK0u/9/zUtf62SGwv4nPGNuWxZjveqToX3Ti8bMl4vjv8ByIFHNINQAgA=", debug_symbols: "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", file_map: { "17": { source: `use crate::field::field_less_than;
-use crate::runtime::is_unconstrained;
-
-// The low and high decomposition of the field modulus
-global PLO: Field = 53438638232309528389504892708671455233;
-global PHI: Field = 64323764613183177041862057485226039389;
-
-pub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;
-
-// Decomposes a single field into two 16 byte fields.
-fn compute_decomposition(x: Field) -> (Field, Field) {
-    // Here's we're taking advantage of truncating 128 bit limbs from the input field
-    // and then subtracting them from the input such the field division is equivalent to integer division.
-    let low = (x as u128) as Field;
-    let high = (x - low) / TWO_POW_128;
-
-    (low, high)
-}
-
-pub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {
-    compute_decomposition(x)
-}
-
-unconstrained fn lte_hint(x: Field, y: Field) -> bool {
-    if x == y {
-        true
-    } else {
-        field_less_than(x, y)
-    }
-}
-
-// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)
-fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
-    let (alo, ahi) = a;
-    let (blo, bhi) = b;
-    // Safety: borrow is enforced to be boolean due to its type.
-    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)
-    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)
-    unsafe {
-        let borrow = lte_hint(alo, blo);
-
-        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
-        let rhi = ahi - bhi - (borrow as Field);
-
-        rlo.assert_max_bit_size::<128>();
-        rhi.assert_max_bit_size::<128>();
-    }
-}
-
-/// Decompose a single field into two 16 byte fields.
-pub fn decompose(x: Field) -> (Field, Field) {
-    if is_unconstrained() {
-        compute_decomposition(x)
-    } else {
-        // Safety: decomposition is properly checked below
-        unsafe {
-            // Take hints of the decomposition
-            let (xlo, xhi) = decompose_hint(x);
-
-            // Range check the limbs
-            xlo.assert_max_bit_size::<128>();
-            xhi.assert_max_bit_size::<128>();
-
-            // Check that the decomposition is correct
-            assert_eq(x, xlo + TWO_POW_128 * xhi);
-
-            // Assert that the decomposition of P is greater than the decomposition of x
-            assert_gt_limbs((PLO, PHI), (xlo, xhi));
-            (xlo, xhi)
-        }
-    }
-}
-
-pub fn assert_gt(a: Field, b: Field) {
-    if is_unconstrained() {
-        assert(
-            // Safety: already unconstrained
-            unsafe { field_less_than(b, a) },
-        );
-    } else {
-        // Decompose a and b
-        let a_limbs = decompose(a);
-        let b_limbs = decompose(b);
-
-        // Assert that a_limbs is greater than b_limbs
-        assert_gt_limbs(a_limbs, b_limbs)
-    }
-}
-
-pub fn assert_lt(a: Field, b: Field) {
-    assert_gt(b, a);
-}
-
-pub fn gt(a: Field, b: Field) -> bool {
-    if is_unconstrained() {
-        // Safety: unsafe in unconstrained
-        unsafe {
-            field_less_than(b, a)
-        }
-    } else if a == b {
-        false
-    } else {
-        // Safety: Take a hint of the comparison and verify it
-        unsafe {
-            if field_less_than(a, b) {
-                assert_gt(b, a);
-                false
-            } else {
-                assert_gt(a, b);
-                true
-            }
-        }
-    }
-}
-
-pub fn lt(a: Field, b: Field) -> bool {
-    gt(b, a)
-}
-
-mod tests {
-    // TODO: Allow imports from "super"
-    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};
-
-    #[test]
-    fn check_decompose() {
-        assert_eq(decompose(TWO_POW_128), (0, 1));
-        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
-        assert_eq(decompose(0x1234567890), (0x1234567890, 0));
-    }
-
-    #[test]
-    unconstrained fn check_lte_hint() {
-        assert(lte_hint(0, 1));
-        assert(lte_hint(0, 0x100));
-        assert(lte_hint(0x100, TWO_POW_128 - 1));
-        assert(!lte_hint(0 - 1, 0));
-
-        assert(lte_hint(0, 0));
-        assert(lte_hint(0x100, 0x100));
-        assert(lte_hint(0 - 1, 0 - 1));
-    }
-
-    #[test]
-    fn check_gt() {
-        assert(gt(1, 0));
-        assert(gt(0x100, 0));
-        assert(gt((0 - 1), (0 - 2)));
-        assert(gt(TWO_POW_128, 0));
-        assert(!gt(0, 0));
-        assert(!gt(0, 0x100));
-        assert(gt(0 - 1, 0 - 2));
-        assert(!gt(0 - 2, 0 - 1));
-        assert_gt(0 - 1, 0);
-    }
-
-    #[test]
-    fn check_plo_phi() {
-        assert_eq(PLO + PHI * TWO_POW_128, 0);
-        let p_bytes = crate::field::modulus_le_bytes();
-        let mut p_low: Field = 0;
-        let mut p_high: Field = 0;
-
-        let mut offset = 1;
-        for i in 0..16 {
-            p_low += (p_bytes[i] as Field) * offset;
-            p_high += (p_bytes[i + 16] as Field) * offset;
-            offset *= 256;
-        }
-        assert_eq(p_low, PLO);
-        assert_eq(p_high, PHI);
-    }
-
-    #[test]
-    fn check_decompose_edge_cases() {
-        assert_eq(decompose(0), (0, 0));
-        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));
-        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));
-        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));
-        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));
-    }
-
-    #[test]
-    fn check_decompose_large_values() {
-        let large_field = 0xffffffffffffffff;
-        let (lo, hi) = decompose(large_field);
-        assert_eq(large_field, lo + TWO_POW_128 * hi);
-
-        let large_value = large_field - TWO_POW_128;
-        let (lo2, hi2) = decompose(large_value);
-        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);
-    }
-
-    #[test]
-    fn check_lt_comprehensive() {
-        assert(lt(0, 1));
-        assert(!lt(1, 0));
-        assert(!lt(0, 0));
-        assert(!lt(42, 42));
-
-        assert(lt(TWO_POW_128 - 1, TWO_POW_128));
-        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));
-    }
-}
-`, path: "std/field/bn254.nr" }, "18": { source: 'pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\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        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            "BIT_SIZE must be less than modulus_num_bits",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\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    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\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        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\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    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\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        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\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        static_assert(\n            N <= modulus_le_bytes().len(),\n            "N must be less than or equal to modulus_le_bytes().len()",\n        );\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        static_assert(\n            N <= modulus_le_bytes().len(),\n            "N must be less than or equal to modulus_le_bytes().len()",\n        );\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    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            static_assert(1 < radix, "radix must be greater than 1");\n            static_assert(radix <= 256, "radix must be less than or equal to 256");\n            static_assert(radix & (radix - 1) == 0, "radix must be a power of 2");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    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            static_assert(1 < radix, "radix must be greater than 1");\n            static_assert(radix <= 256, "radix must be less than or equal to 256");\n            static_assert(radix & (radix - 1) == 0, "radix must be a power of 2");\n        }\n        __to_be_radix(self, radix)\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        static_assert(\n            N <= modulus_le_bytes().len(),\n            "N must be less than or equal to modulus_le_bytes().len()",\n        );\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(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\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)]\nfn __to_le_bits<let N: u32>(value: Field) -> [u1; N] {}\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)]\nfn __to_be_bits<let N: u32>(value: Field) -> [u1; 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        // Safety: unconstrained context\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 crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\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        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\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        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 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(should_fail_with = "radix must be greater than 1")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f"radix must be greater than 1");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = "radix must be greater than 1")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f"radix must be greater than 1");\n        }\n    }\n\n    #[test(should_fail_with = "radix must be a power of 2")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f"radix must be a power of 2");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, "unexpected result");\n        }\n    }\n\n    #[test(should_fail_with = "radix must be less than or equal to 256")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f"radix must be less than or equal to 256")\n        }\n    }\n\n    #[test(should_fail_with = "Field failed to decompose into specified 16 limbs")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = "Field failed to decompose into specified 16 limbs")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\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    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [u1; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], 1);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [u1; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], 1);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [u1; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [0; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [u1; 8] = 1.to_le_bits();\n        let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [u1; 8] = 4.to_le_bits();\n        let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), 0);\n        assert_eq(2.sgn0(), 0);\n        assert_eq(4.sgn0(), 0);\n        assert_eq(100.sgn0(), 0);\n\n        assert_eq(1.sgn0(), 1);\n        assert_eq(3.sgn0(), 1);\n        assert_eq(5.sgn0(), 1);\n        assert_eq(101.sgn0(), 1);\n    }\n\n    #[test(should_fail_with = "Field failed to decompose into specified 8 limbs")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can\'t represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u1; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = "Field failed to decompose into specified 4 limbs")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can\'t represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [u1; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            "N must be less than or equal to modulus_le_bits().len()",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [u1; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [u1; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1] > 0);\n            p_minus_1_bits[254 - 1] -= 1;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [u1; 254] = modulus_be_bits().as_array();\n            assert(p_plus_4_bits[254 - 3] < 1);\n            p_plus_4_bits[254 - 3] += 1;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_be_bits();\n            assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n            p_plus_4_converted_bits[254 - 3] = 0;\n            assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bytes produces 254 zeroes\n            let p_bits: [u1; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [0; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [u1; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0] > 0);\n            p_minus_1_bits[0] -= 1;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [u1; 254] = modulus_le_bits().as_array();\n            assert(p_plus_4_bits[2] < 1);\n            p_plus_4_bits[2] += 1;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_le_bits();\n            assert_eq(p_plus_4_converted_bits[2], 1);\n            p_plus_4_converted_bits[2] = 0;\n            assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bytes produces 254 zeroes\n            let p_bits: [u1; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [0; 254]);\n        }\n    }\n}\n', path: "std/field/mod.nr" }, "19": { source: '// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated("This function has been moved to std::hash::keccakf1600")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you\'re working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            "Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators("pedersen_hash_length".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n    assert_eq(input.len(), state_len);\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n', path: "std/hash/mod.nr" }, "50": { source: '/// Funding Proof Circuit\n///\n/// Proves that a user has sufficient balance to cover a transaction\n/// without revealing the actual balance.\n///\n/// Public inputs:\n/// - commitment_hash: Hash of the Pedersen commitment to balance\n/// - minimum_required: Minimum balance required\n/// - asset_id: Asset identifier\n///\n/// Private inputs (witness):\n/// - balance: Actual user balance\n/// - blinding: Blinding factor for commitment\n///\n/// Constraints:\n/// 1. balance >= minimum_required\n/// 2. commitment = pedersen([balance, blinding])\n/// 3. commitment_hash = hash(commitment, asset_id)\n\nuse std::hash::pedersen_hash;\nuse std::hash::blake3;\n\n/// Main entry point for the funding proof circuit\n///\n/// Returns the commitment hash as a public output rather than taking it as input.\n/// This allows the SDK to verify the proof without needing to compute Pedersen hashes.\nfn main(\n    // Public inputs\n    minimum_required: pub Field,\n    asset_id: pub Field,\n\n    // Private inputs (witness)\n    balance: Field,\n    blinding: Field,\n) -> pub [u8; 32] {\n    // Constraint 1: Balance must be at least the minimum required\n    // Using Field comparison - works for values up to ~2^254\n    assert(balance.lt(minimum_required) == false, "Insufficient balance");\n\n    // Constraint 2: Compute the Pedersen commitment to (balance, blinding)\n    let commitment = pedersen_hash([balance, blinding]);\n\n    // Constraint 3: Compute and return the commitment hash\n    // We hash: commitment || asset_id to bind the commitment to the asset\n    let commitment_hash = compute_commitment_hash(commitment, asset_id);\n\n    commitment_hash\n}\n\n/// Compute the commitment hash from commitment and asset_id\n/// Uses BLAKE3 for efficiency (built-in to Noir)\nfn compute_commitment_hash(commitment: Field, asset_id: Field) -> [u8; 32] {\n    // Convert commitment to bytes (32 bytes, big-endian)\n    let commitment_bytes: [u8; 32] = commitment.to_be_bytes();\n\n    // Convert asset_id to bytes (32 bytes, big-endian)\n    let asset_bytes: [u8; 32] = asset_id.to_be_bytes();\n\n    // Create preimage: commitment || asset_id (64 bytes)\n    let mut preimage: [u8; 64] = [0; 64];\n    for i in 0..32 {\n        preimage[i] = commitment_bytes[i];\n        preimage[i + 32] = asset_bytes[i];\n    }\n\n    // Hash with BLAKE3\n    blake3(preimage)\n}\n\n// --- Tests ---\n\n#[test]\nfn test_valid_funding_proof() {\n    // Test case: balance = 100, minimum = 50\n    let balance: Field = 100;\n    let minimum_required: Field = 50;\n    let blinding: Field = 12345;\n    let asset_id: Field = 1;\n\n    // Execute the circuit - it should return the commitment hash\n    let commitment_hash = main(minimum_required, asset_id, balance, blinding);\n\n    // Verify it returned a hash (not all zeros)\n    let mut has_nonzero = false;\n    for i in 0..32 {\n        if commitment_hash[i] != 0 {\n            has_nonzero = true;\n        }\n    }\n    assert(has_nonzero, "Commitment hash should not be all zeros");\n}\n\n#[test]\nfn test_exact_balance_passes() {\n    // Test case: balance exactly equals minimum\n    let balance: Field = 50;\n    let minimum_required: Field = 50;\n    let blinding: Field = 67890;\n    let asset_id: Field = 2;\n\n    // Should succeed and return a hash\n    let _commitment_hash = main(minimum_required, asset_id, balance, blinding);\n}\n\n#[test(should_fail_with = "Insufficient balance")]\nfn test_insufficient_balance_fails() {\n    // Test case: balance < minimum should fail\n    let balance: Field = 40;\n    let minimum_required: Field = 50;\n    let blinding: Field = 11111;\n    let asset_id: Field = 1;\n\n    // Should fail because balance < minimum_required\n    let _commitment_hash = main(minimum_required, asset_id, balance, blinding);\n}\n\n#[test]\nfn test_different_blinding_produces_different_hash() {\n    // Test that different blinding factors produce different commitment hashes\n    let balance: Field = 100;\n    let minimum_required: Field = 50;\n    let blinding1: Field = 12345;\n    let blinding2: Field = 99999;\n    let asset_id: Field = 1;\n\n    let hash1 = main(minimum_required, asset_id, balance, blinding1);\n    let hash2 = main(minimum_required, asset_id, balance, blinding2);\n\n    // Hashes should be different\n    let mut hashes_differ = false;\n    for i in 0..32 {\n        if hash1[i] != hash2[i] {\n            hashes_differ = true;\n        }\n    }\n    assert(hashes_differ, "Different blindings should produce different hashes");\n}\n\n#[test]\nfn test_large_values_near_scale() {\n    // Test with NEAR-scale values (24 decimals)\n    // 1.5 NEAR = 1500000000000000000000000 yoctoNEAR\n    // This would overflow u64 but works with Field\n    let balance: Field = 1500000000000000000000000;\n    let minimum_required: Field = 1000000000000000000000000; // 1 NEAR\n    let blinding: Field = 999999999;\n    let asset_id: Field = 0x4e454152; // "NEAR" as hex\n\n    // Should succeed - balance > minimum\n    let commitment_hash = main(minimum_required, asset_id, balance, blinding);\n\n    // Verify hash is valid\n    let mut has_nonzero = false;\n    for i in 0..32 {\n        if commitment_hash[i] != 0 {\n            has_nonzero = true;\n        }\n    }\n    assert(has_nonzero, "Commitment hash should not be all zeros");\n}\n\n#[test(should_fail_with = "Insufficient balance")]\nfn test_large_values_insufficient() {\n    // Test insufficient balance with NEAR-scale values\n    let balance: Field = 500000000000000000000000; // 0.5 NEAR\n    let minimum_required: Field = 1000000000000000000000000; // 1 NEAR\n    let blinding: Field = 12345;\n    let asset_id: Field = 0x4e454152;\n\n    // Should fail - balance < minimum\n    let _hash = main(minimum_required, asset_id, balance, blinding);\n}\n', path: "/Users/rz/local-dev/circuits/funding_proof/src/main.nr" } }, expression_width: { Bounded: { width: 4 } } };
-
-// src/proofs/circuits/validity_proof.json
-var validity_proof_default = { noir_version: "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", hash: "17105369051450454041", abi: { parameters: [{ name: "intent_hash", type: { kind: "field" }, visibility: "public" }, { name: "sender_commitment_x", type: { kind: "field" }, visibility: "public" }, { name: "sender_commitment_y", type: { kind: "field" }, visibility: "public" }, { name: "nullifier", type: { kind: "field" }, visibility: "public" }, { name: "timestamp", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "expiry", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "sender_address", type: { kind: "field" }, visibility: "private" }, { name: "sender_blinding", type: { kind: "field" }, visibility: "private" }, { name: "sender_secret", type: { kind: "field" }, visibility: "private" }, { name: "pub_key_x", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "pub_key_y", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "signature", type: { kind: "array", length: 64, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "message_hash", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "nonce", type: { kind: "field" }, visibility: "private" }], return_type: null, error_types: { "4743545721632785176": { error_kind: "string", string: "Nullifier mismatch" }, "4924752953922582949": { error_kind: "string", string: "Invalid ECDSA signature" }, "5940733937471987676": { error_kind: "string", string: "Intent expired" }, "9872184990886929843": { error_kind: "string", string: "Sender commitment X mismatch" }, "14620555433709191364": { error_kind: "string", string: "Sender commitment Y mismatch" }, "15764276373176857197": { error_kind: "string", string: "Stack too deep" } } }, bytecode: "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", debug_symbols: "pZbNjuIwDIDfJeceYsf541VGI1SgM6pUFdSBlVaId9+YxaU9JMuGS+O69dfYsV1f1aHbXb63/fh1/FGbj6vaTf0w9N/b4bhvz/1xTNqr0nwBpzbYKPB/l6A2Ji1RbahRmN6g261RYrY9T13HVgtOop/aqRvPajNehqFRv9rhcn/p59SO9/XcTumpblQ3HtKagF/90LF0a57WOm8aND6MA7rZHPzKHvL2juhh76ypsQ8g9iFU2YvzXme/X/AfCCQAQO4ZAbuOoC0QHIgL4Kx97iGuCK5AiDE8CKgxS/B5AgHYB4HAhhoCGi8E9LaOAO8S0LxAKEYyODmLGGsIqK0kNAJCjgAmjzCWJBDGaV2zCUA/b8KZ7CYKWUk2ih/kaFHZrhIRc4hicfkox2GBcsVVIlinZ8LiQP+D4IOUBgQKOQKWENpJXgKYRSDo5U0EN/eI4HWFGykvYU4JDVk3CnmJGOY2Y5bNfp1VSAVEwLk6gs1WB9q3W1UR8Vqv+gcC3ka81K2K4Yxa6gMjxBqEAS0FYlJy1iGe/QqifxeB+ZZXym+AZ9+lmkJHREksRDIrwme6a/f9tJ7SwGEae9JM5gxXNgv0UFhROO53LHguXRYCu8VC5K3yfKdFAP40C4mLbOUNnywLJBorGicaLxqeEO/miWyIR0bNfxMWQAQUwbBw43BMfbsbOvaIfb6Me3Ew3Z5/n+SJDKqn6bjvDpep42AsptV0/UhnjPHzxgH7Aw==", file_map: { "14": { source: "// docs:start:ecdsa_secp256k1\n/// Verifies a ECDSA signature over the secp256k1 curve.\n/// - inputs:\n///     - x coordinate of public key as 32 bytes\n///     - y coordinate of public key as 32 bytes\n///     - the signature, as a 64 bytes array\n///       The signature internally will be represented as `(r, s)`,\n///       where `r` and `s` are fixed-sized big endian scalar values.\n///       As the `secp256k1` has a 256-bit modulus, we have a 64 byte signature\n///       while `r` and `s` will both be 32 bytes.\n///       We expect `s` to be normalized. This means given the curve's order,\n///       `s` should be less than or equal to `order / 2`.\n///       This is done to prevent malleability.\n///       For more context regarding malleability you can reference BIP 0062.\n///     - the hash of the message, as a vector of bytes\n/// - output: false for failure and true for success\npub fn verify_signature(\n    public_key_x: [u8; 32],\n    public_key_y: [u8; 32],\n    signature: [u8; 64],\n    message_hash: [u8; 32],\n) -> bool\n// docs:end:ecdsa_secp256k1\n{\n    _verify_signature(public_key_x, public_key_y, signature, message_hash, true)\n}\n\n#[foreign(ecdsa_secp256k1)]\npub fn _verify_signature(\n    public_key_x: [u8; 32],\n    public_key_y: [u8; 32],\n    signature: [u8; 64],\n    message_hash: [u8; 32],\n    predicate: bool,\n) -> bool {}\n", path: "std/ecdsa_secp256k1.nr" }, "16": { source: "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n            is_infinite: false,\n        }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        if self.is_infinite {\n            self.is_infinite.hash(state);\n        } else {\n            self.x.hash(state);\n            self.y.hash(state);\n        }\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n    predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    if crate::runtime::is_unconstrained() {\n        // `embedded_curve_add_unsafe` requires the inputs not to be the infinity point, so we check it here.\n        // This is because `embedded_curve_add_unsafe` uses the `embedded_curve_add` opcode.\n        // For efficiency, the backend does not check the inputs for the infinity point, but it assumes that they are not the infinity point\n        // so that it can apply the ec addition formula directly.\n        if point1.is_infinite {\n            point2\n        } else if point2.is_infinite {\n            point1\n        } else {\n            embedded_curve_add_unsafe(point1, point2)\n        }\n    } else {\n        // In a constrained context, we also need to check the inputs are not the infinity point because we also use `embedded_curve_add_unsafe`\n        // However we also need to identify the case where the two inputs are the same, because then\n        // the addition formula does not work and we need to use the doubling formula instead.\n        // In unconstrained context, we can check directly if the input values are the same when solving the opcode, so it is not an issue.\n\n        // x_coordinates_match is true if both abscissae are the same\n        let x_coordinates_match = point1.x == point2.x;\n        // y_coordinates_match is true if both ordinates are the same\n        let y_coordinates_match = point1.y == point2.y;\n        // double_predicate is true if both abscissae and ordinates are the same\n        let double_predicate = (x_coordinates_match & y_coordinates_match);\n        // If the abscissae are the same, but not the ordinates, then one point is the opposite of the other\n        let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n\n        // `embedded_curve_add_unsafe` would not perform doubling, even if the inputs point1 and point2 are the same, because it cannot know this without adding some logic (and some constraints)\n        // However we did this logic when we computed `double_predicate`, so we set the result to 2*point1 if point1 and point2 are the same\n        let mut result = if double_predicate {\n            // `embedded_curve_add_unsafe` is doing a doubling if the input is the same variable, because in this case it is guaranteed (at 'compile time') that the input is the same.\n            embedded_curve_add_unsafe(point1, point1)\n        } else {\n            let point1_1 = EmbeddedCurvePoint {\n                x: point1.x + (x_coordinates_match as Field),\n                y: point1.y,\n                is_infinite: false,\n            };\n            let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n            // point1_1 is guaranteed to have a different abscissa than point2:\n            // - if x_coordinates_match is 0, that means point1.x != point2.x, and point1_1.x = point1.x + 0\n            // - if x_coordinates_match is 1, that means point1.x = point2.x, but point1_1.x = point1.x + 1 in this case\n            // Because the abscissa is different, the addition formula is guaranteed to succeed, so we can safely use `embedded_curve_add_unsafe`\n            // Note that this computation may be garbage: if x_coordinates_match is 1, or if one of the input is the point at infinity.\n            // therefore we only want to do this if we need the result, otherwise it needs to be eliminated as a dead instruction, lest we want the circuit to fail.\n            embedded_curve_add_unsafe(point1_1, point2_1)\n        };\n\n        // Same logic as above for unconstrained context, we set the proper result when one of the inputs is the infinity point\n        if point1.is_infinite {\n            result = point2;\n        }\n        if point2.is_infinite {\n            result = point1;\n        }\n\n        // Finally, we set the is_infinity flag of the result:\n        // Opposite points should sum into the infinity point, however, if one of them is point at infinity, their coordinates are not meaningful\n        // so we should not use the fact that the inputs are opposite in this case:\n        let mut result_is_infinity =\n            infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n        // However, if both of them are at infinity, then the result is also at infinity\n        result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n        result\n    }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n    _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    // Ensure is_infinite is comptime\n    let point1_1 = EmbeddedCurvePoint { x: point1.x, y: point1.y, is_infinite: false };\n    let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n    embedded_curve_add_unsafe(point1_1, point2_1)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    embedded_curve_add_array_return(point1, point2, true)[0]\n}\n", path: "std/embedded_curve_ops.nr" }, "17": { source: `use crate::field::field_less_than;
-use crate::runtime::is_unconstrained;
-
-// The low and high decomposition of the field modulus
-global PLO: Field = 53438638232309528389504892708671455233;
-global PHI: Field = 64323764613183177041862057485226039389;
-
-pub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;
-
-// Decomposes a single field into two 16 byte fields.
-fn compute_decomposition(x: Field) -> (Field, Field) {
-    // Here's we're taking advantage of truncating 128 bit limbs from the input field
-    // and then subtracting them from the input such the field division is equivalent to integer division.
-    let low = (x as u128) as Field;
-    let high = (x - low) / TWO_POW_128;
-
-    (low, high)
-}
-
-pub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {
-    compute_decomposition(x)
-}
-
-unconstrained fn lte_hint(x: Field, y: Field) -> bool {
-    if x == y {
-        true
-    } else {
-        field_less_than(x, y)
-    }
-}
-
-// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)
-fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
-    let (alo, ahi) = a;
-    let (blo, bhi) = b;
-    // Safety: borrow is enforced to be boolean due to its type.
-    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)
-    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)
-    unsafe {
-        let borrow = lte_hint(alo, blo);
-
-        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
-        let rhi = ahi - bhi - (borrow as Field);
-
-        rlo.assert_max_bit_size::<128>();
-        rhi.assert_max_bit_size::<128>();
-    }
-}
-
-/// Decompose a single field into two 16 byte fields.
-pub fn decompose(x: Field) -> (Field, Field) {
-    if is_unconstrained() {
-        compute_decomposition(x)
-    } else {
-        // Safety: decomposition is properly checked below
-        unsafe {
-            // Take hints of the decomposition
-            let (xlo, xhi) = decompose_hint(x);
-
-            // Range check the limbs
-            xlo.assert_max_bit_size::<128>();
-            xhi.assert_max_bit_size::<128>();
-
-            // Check that the decomposition is correct
-            assert_eq(x, xlo + TWO_POW_128 * xhi);
-
-            // Assert that the decomposition of P is greater than the decomposition of x
-            assert_gt_limbs((PLO, PHI), (xlo, xhi));
-            (xlo, xhi)
-        }
-    }
-}
-
-pub fn assert_gt(a: Field, b: Field) {
-    if is_unconstrained() {
-        assert(
-            // Safety: already unconstrained
-            unsafe { field_less_than(b, a) },
-        );
-    } else {
-        // Decompose a and b
-        let a_limbs = decompose(a);
-        let b_limbs = decompose(b);
-
-        // Assert that a_limbs is greater than b_limbs
-        assert_gt_limbs(a_limbs, b_limbs)
-    }
-}
-
-pub fn assert_lt(a: Field, b: Field) {
-    assert_gt(b, a);
-}
-
-pub fn gt(a: Field, b: Field) -> bool {
-    if is_unconstrained() {
-        // Safety: unsafe in unconstrained
-        unsafe {
-            field_less_than(b, a)
-        }
-    } else if a == b {
-        false
-    } else {
-        // Safety: Take a hint of the comparison and verify it
-        unsafe {
-            if field_less_than(a, b) {
-                assert_gt(b, a);
-                false
-            } else {
-                assert_gt(a, b);
-                true
-            }
-        }
-    }
-}
-
-pub fn lt(a: Field, b: Field) -> bool {
-    gt(b, a)
-}
-
-mod tests {
-    // TODO: Allow imports from "super"
-    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};
-
-    #[test]
-    fn check_decompose() {
-        assert_eq(decompose(TWO_POW_128), (0, 1));
-        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
-        assert_eq(decompose(0x1234567890), (0x1234567890, 0));
-    }
-
-    #[test]
-    unconstrained fn check_lte_hint() {
-        assert(lte_hint(0, 1));
-        assert(lte_hint(0, 0x100));
-        assert(lte_hint(0x100, TWO_POW_128 - 1));
-        assert(!lte_hint(0 - 1, 0));
-
-        assert(lte_hint(0, 0));
-        assert(lte_hint(0x100, 0x100));
-        assert(lte_hint(0 - 1, 0 - 1));
-    }
-
-    #[test]
-    fn check_gt() {
-        assert(gt(1, 0));
-        assert(gt(0x100, 0));
-        assert(gt((0 - 1), (0 - 2)));
-        assert(gt(TWO_POW_128, 0));
-        assert(!gt(0, 0));
-        assert(!gt(0, 0x100));
-        assert(gt(0 - 1, 0 - 2));
-        assert(!gt(0 - 2, 0 - 1));
-        assert_gt(0 - 1, 0);
-    }
-
-    #[test]
-    fn check_plo_phi() {
-        assert_eq(PLO + PHI * TWO_POW_128, 0);
-        let p_bytes = crate::field::modulus_le_bytes();
-        let mut p_low: Field = 0;
-        let mut p_high: Field = 0;
-
-        let mut offset = 1;
-        for i in 0..16 {
-            p_low += (p_bytes[i] as Field) * offset;
-            p_high += (p_bytes[i + 16] as Field) * offset;
-            offset *= 256;
-        }
-        assert_eq(p_low, PLO);
-        assert_eq(p_high, PHI);
-    }
-
-    #[test]
-    fn check_decompose_edge_cases() {
-        assert_eq(decompose(0), (0, 0));
-        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));
-        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));
-        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));
-        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));
-    }
-
-    #[test]
-    fn check_decompose_large_values() {
-        let large_field = 0xffffffffffffffff;
-        let (lo, hi) = decompose(large_field);
-        assert_eq(large_field, lo + TWO_POW_128 * hi);
-
-        let large_value = large_field - TWO_POW_128;
-        let (lo2, hi2) = decompose(large_value);
-        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);
-    }
-
-    #[test]
-    fn check_lt_comprehensive() {
-        assert(lt(0, 1));
-        assert(!lt(1, 0));
-        assert(!lt(0, 0));
-        assert(!lt(42, 42));
-
-        assert(lt(TWO_POW_128 - 1, TWO_POW_128));
-        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));
-    }
-}
-`, path: "std/field/bn254.nr" }, "19": { source: '// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated("This function has been moved to std::hash::keccakf1600")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you\'re working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            "Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators("pedersen_hash_length".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n    assert_eq(input.len(), state_len);\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n', path: "std/hash/mod.nr" }, "50": { source: `/// Validity Proof Circuit
-///
-/// Proves: "This intent is authorized by the sender, without revealing
-/// the sender's identity, private key, or signature."
-///
-/// @see docs/specs/VALIDITY-PROOF.md
-
-use std::hash::pedersen_hash;
-use std::hash::pedersen_commitment;
-use std::ecdsa_secp256k1::verify_signature;
-
-// --- Main Circuit ---
-
-/// Main validity proof entry point
-///
-/// Public inputs: intent_hash, sender_commitment (x,y), nullifier, timestamp, expiry
-/// Private inputs: sender_address (Field), sender_blinding, sender_secret, 
-///                 pub_key_x, pub_key_y, signature, message_hash, nonce
-///
-/// Constraints:
-/// 1. sender_commitment = Pedersen(sender_address, sender_blinding)
-/// 2. signature is valid for message_hash using pub_key
-/// 3. nullifier = Pedersen_hash(sender_secret, intent_hash, nonce)
-/// 4. timestamp < expiry
-pub fn main(
-    // Public inputs
-    intent_hash: pub Field,
-    sender_commitment_x: pub Field,
-    sender_commitment_y: pub Field,
-    nullifier: pub Field,
-    timestamp: pub u64,
-    expiry: pub u64,
-    
-    // Private inputs
-    sender_address: Field,
-    sender_blinding: Field,
-    sender_secret: Field,
-    pub_key_x: [u8; 32],
-    pub_key_y: [u8; 32],
-    signature: [u8; 64],
-    message_hash: [u8; 32],
-    nonce: Field,
-) {
-    // Constraint 1: Verify Sender Commitment
-    // C = Pedersen(sender_address, sender_blinding)
-    let commitment = pedersen_commitment([sender_address, sender_blinding]);
-    assert(commitment.x == sender_commitment_x, "Sender commitment X mismatch");
-    assert(commitment.y == sender_commitment_y, "Sender commitment Y mismatch");
-    
-    // Constraint 2: Verify ECDSA Signature
-    // The signature must be valid for the message_hash using the provided public key
-    let valid_sig = verify_signature(pub_key_x, pub_key_y, signature, message_hash);
-    assert(valid_sig, "Invalid ECDSA signature");
-    
-    // Constraint 3: Verify Nullifier Derivation
-    // nullifier = Pedersen_hash(sender_secret, intent_hash, nonce)
-    let computed_nullifier = pedersen_hash([sender_secret, intent_hash, nonce]);
-    assert(computed_nullifier == nullifier, "Nullifier mismatch");
-    
-    // Constraint 4: Time Bounds Check
-    assert(timestamp < expiry, "Intent expired");
-}
-
-// --- Tests ---
-
-// NOTE: Full ECDSA integration test requires TypeScript to generate valid signatures
-// The NoirProofProvider in SDK will generate proper test vectors
-// Here we test the commitment and nullifier logic which are pure Noir
-
-#[test]
-fn test_commitment_and_nullifier() {
-    // Test just the commitment and nullifier computation (without ECDSA)
-    let sender_address: Field = 0x742d35Cc6634C0532925a3b844Bc9e7595f;
-    let sender_blinding: Field = 0xABCDEF123456;
-    let sender_secret: Field = 0x1234567890ABCDEF;
-    let intent_hash: Field = 0xDEADBEEF;
-    let nonce: Field = 0x99999;
-    
-    // Compute and verify commitment is consistent
-    let commitment1 = pedersen_commitment([sender_address, sender_blinding]);
-    let commitment2 = pedersen_commitment([sender_address, sender_blinding]);
-    assert(commitment1.x == commitment2.x, "Commitment X should be deterministic");
-    assert(commitment1.y == commitment2.y, "Commitment Y should be deterministic");
-    
-    // Compute and verify nullifier is consistent
-    let nullifier1 = pedersen_hash([sender_secret, intent_hash, nonce]);
-    let nullifier2 = pedersen_hash([sender_secret, intent_hash, nonce]);
-    assert(nullifier1 == nullifier2, "Nullifier should be deterministic");
-    
-    // Different nonce should give different nullifier
-    let different_nonce: Field = 0x88888;
-    let nullifier3 = pedersen_hash([sender_secret, intent_hash, different_nonce]);
-    assert(nullifier1 != nullifier3, "Different nonce should give different nullifier");
-}
-
-#[test]
-fn test_time_bounds() {
-    // Test timestamp < expiry constraint
-    let valid_timestamp: u64 = 1732600000;
-    let valid_expiry: u64 = 1732686400;
-    assert(valid_timestamp < valid_expiry, "Valid time bounds");
-}
-
-// NOTE: Full integration tests with ECDSA require TypeScript SDK
-// The NoirProofProvider will generate valid signature test vectors
-`, path: "/Users/rz/local-dev/sip-protocol/packages/circuits/validity_proof/src/main.nr" } }, expression_width: { Bounded: { width: 4 } } };
-
-// src/proofs/circuits/fulfillment_proof.json
-var fulfillment_proof_default = { noir_version: "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", hash: "13146944445132352806", abi: { parameters: [{ name: "intent_hash", type: { kind: "field" }, visibility: "public" }, { name: "output_commitment_x", type: { kind: "field" }, visibility: "public" }, { name: "output_commitment_y", type: { kind: "field" }, visibility: "public" }, { name: "recipient_stealth", type: { kind: "field" }, visibility: "public" }, { name: "min_output_amount", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "solver_id", type: { kind: "field" }, visibility: "public" }, { name: "fulfillment_time", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "expiry", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "output_amount", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "private" }, { name: "output_blinding", type: { kind: "field" }, visibility: "private" }, { name: "solver_secret", type: { kind: "field" }, visibility: "private" }, { name: "attestation_recipient", type: { kind: "field" }, visibility: "private" }, { name: "attestation_amount", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "private" }, { name: "attestation_tx_hash", type: { kind: "field" }, visibility: "private" }, { name: "attestation_block", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "private" }, { name: "oracle_signature", type: { kind: "array", length: 64, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "oracle_message_hash", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "oracle_pub_key_x", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "oracle_pub_key_y", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }], return_type: null, error_types: { "1811611355587044900": { error_kind: "string", string: "Unauthorized solver" }, "5682920188479059162": { error_kind: "string", string: "Amount mismatch in attestation" }, "9350488092177273812": { error_kind: "string", string: "Recipient mismatch in attestation" }, "10078784717933725989": { error_kind: "string", string: "Invalid oracle attestation signature" }, "10879340518732620616": { error_kind: "string", string: "Commitment X mismatch" }, "12297495446303487112": { error_kind: "string", string: "Output below minimum" }, "12394005467219657293": { error_kind: "string", string: "Commitment Y mismatch" }, "15764276373176857197": { error_kind: "string", string: "Stack too deep" }, "17406200060514520896": { error_kind: "string", string: "Fulfillment after expiry" } } }, bytecode: "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", debug_symbols: "pZbLjqswDIbfJWsWsXPvq4xGFW2ZERKiFdMe6ajqux+7QwJdJOoJG2Iu/oiN/eO7OHWH2/e+H7/OP2L3cReHqR+G/ns/nI/ttT+PdPUuJB/Aih02Atzv4sVO0RLETjcC6Qn9eDQiuu2vU9ex14pD9Es7deNV7MbbMDTiTzvcng/9XNrxuV7bie7KRnTjiVYCfvVDx9ajWbxl3tVLnJ092uQO7sUf8v5W69nfGlXj7yH6e1/lH4N3Mvv+QvzgpZoB4JVLBPN2BlFCDAGlUhUECEEmgsEcwRUINu0BrDFLHsILwRf34NMeMEsIeYIGMDNBg/E1BFQuEtCZOgJsJaB6g1DMpLfxW4RQQ6AiiE2FgJAjcLpzCGV0TISyUtZsAtClTViV3UShKrUJMQ5t9UpdbCUi5BDF9rQmxbHKxH80OKiQCE7XEKiSIkFBlcgom9pTyxqRQYNJpqzJ5gF1obKlTVpJOVk+hn57EzYRkJS7JgyvU1l6l00lutLX8CmXav3Te61sLDWHx9Sh3mQ7FLfLJW7XS9wumLhdMYvpDDJ1WIBQg1DU21HwqDjrEItmQnBbEZiX3WJ9L7NAWGn/+x2i5JIJuSpvJnzSWXvsp9dpFSxNqlSMYN28+nkNv6uT3PxsABk8xTqMV1S8onmCYsOw6LLB8y+wwRPwcxL23HJsBBYkHoplNIAlgQ3kfbNBZMUPe80/MTaIrPgVnsisyeBdNHw0AhsPTs/Ut4eh4wg5B7fxGAOm0+vfS7wTB/jLdD52p9vUcXJWUzwdP6jbMXw+OIH/AA==", file_map: { "14": { source: "// docs:start:ecdsa_secp256k1\n/// Verifies a ECDSA signature over the secp256k1 curve.\n/// - inputs:\n///     - x coordinate of public key as 32 bytes\n///     - y coordinate of public key as 32 bytes\n///     - the signature, as a 64 bytes array\n///       The signature internally will be represented as `(r, s)`,\n///       where `r` and `s` are fixed-sized big endian scalar values.\n///       As the `secp256k1` has a 256-bit modulus, we have a 64 byte signature\n///       while `r` and `s` will both be 32 bytes.\n///       We expect `s` to be normalized. This means given the curve's order,\n///       `s` should be less than or equal to `order / 2`.\n///       This is done to prevent malleability.\n///       For more context regarding malleability you can reference BIP 0062.\n///     - the hash of the message, as a vector of bytes\n/// - output: false for failure and true for success\npub fn verify_signature(\n    public_key_x: [u8; 32],\n    public_key_y: [u8; 32],\n    signature: [u8; 64],\n    message_hash: [u8; 32],\n) -> bool\n// docs:end:ecdsa_secp256k1\n{\n    _verify_signature(public_key_x, public_key_y, signature, message_hash, true)\n}\n\n#[foreign(ecdsa_secp256k1)]\npub fn _verify_signature(\n    public_key_x: [u8; 32],\n    public_key_y: [u8; 32],\n    signature: [u8; 64],\n    message_hash: [u8; 32],\n    predicate: bool,\n) -> bool {}\n", path: "std/ecdsa_secp256k1.nr" }, "16": { source: "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n            is_infinite: false,\n        }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        if self.is_infinite {\n            self.is_infinite.hash(state);\n        } else {\n            self.x.hash(state);\n            self.y.hash(state);\n        }\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n    predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    if crate::runtime::is_unconstrained() {\n        // `embedded_curve_add_unsafe` requires the inputs not to be the infinity point, so we check it here.\n        // This is because `embedded_curve_add_unsafe` uses the `embedded_curve_add` opcode.\n        // For efficiency, the backend does not check the inputs for the infinity point, but it assumes that they are not the infinity point\n        // so that it can apply the ec addition formula directly.\n        if point1.is_infinite {\n            point2\n        } else if point2.is_infinite {\n            point1\n        } else {\n            embedded_curve_add_unsafe(point1, point2)\n        }\n    } else {\n        // In a constrained context, we also need to check the inputs are not the infinity point because we also use `embedded_curve_add_unsafe`\n        // However we also need to identify the case where the two inputs are the same, because then\n        // the addition formula does not work and we need to use the doubling formula instead.\n        // In unconstrained context, we can check directly if the input values are the same when solving the opcode, so it is not an issue.\n\n        // x_coordinates_match is true if both abscissae are the same\n        let x_coordinates_match = point1.x == point2.x;\n        // y_coordinates_match is true if both ordinates are the same\n        let y_coordinates_match = point1.y == point2.y;\n        // double_predicate is true if both abscissae and ordinates are the same\n        let double_predicate = (x_coordinates_match & y_coordinates_match);\n        // If the abscissae are the same, but not the ordinates, then one point is the opposite of the other\n        let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n\n        // `embedded_curve_add_unsafe` would not perform doubling, even if the inputs point1 and point2 are the same, because it cannot know this without adding some logic (and some constraints)\n        // However we did this logic when we computed `double_predicate`, so we set the result to 2*point1 if point1 and point2 are the same\n        let mut result = if double_predicate {\n            // `embedded_curve_add_unsafe` is doing a doubling if the input is the same variable, because in this case it is guaranteed (at 'compile time') that the input is the same.\n            embedded_curve_add_unsafe(point1, point1)\n        } else {\n            let point1_1 = EmbeddedCurvePoint {\n                x: point1.x + (x_coordinates_match as Field),\n                y: point1.y,\n                is_infinite: false,\n            };\n            let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n            // point1_1 is guaranteed to have a different abscissa than point2:\n            // - if x_coordinates_match is 0, that means point1.x != point2.x, and point1_1.x = point1.x + 0\n            // - if x_coordinates_match is 1, that means point1.x = point2.x, but point1_1.x = point1.x + 1 in this case\n            // Because the abscissa is different, the addition formula is guaranteed to succeed, so we can safely use `embedded_curve_add_unsafe`\n            // Note that this computation may be garbage: if x_coordinates_match is 1, or if one of the input is the point at infinity.\n            // therefore we only want to do this if we need the result, otherwise it needs to be eliminated as a dead instruction, lest we want the circuit to fail.\n            embedded_curve_add_unsafe(point1_1, point2_1)\n        };\n\n        // Same logic as above for unconstrained context, we set the proper result when one of the inputs is the infinity point\n        if point1.is_infinite {\n            result = point2;\n        }\n        if point2.is_infinite {\n            result = point1;\n        }\n\n        // Finally, we set the is_infinity flag of the result:\n        // Opposite points should sum into the infinity point, however, if one of them is point at infinity, their coordinates are not meaningful\n        // so we should not use the fact that the inputs are opposite in this case:\n        let mut result_is_infinity =\n            infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n        // However, if both of them are at infinity, then the result is also at infinity\n        result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n        result\n    }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n    _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    // Ensure is_infinite is comptime\n    let point1_1 = EmbeddedCurvePoint { x: point1.x, y: point1.y, is_infinite: false };\n    let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n    embedded_curve_add_unsafe(point1_1, point2_1)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    embedded_curve_add_array_return(point1, point2, true)[0]\n}\n", path: "std/embedded_curve_ops.nr" }, "17": { source: `use crate::field::field_less_than;
-use crate::runtime::is_unconstrained;
-
-// The low and high decomposition of the field modulus
-global PLO: Field = 53438638232309528389504892708671455233;
-global PHI: Field = 64323764613183177041862057485226039389;
-
-pub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;
-
-// Decomposes a single field into two 16 byte fields.
-fn compute_decomposition(x: Field) -> (Field, Field) {
-    // Here's we're taking advantage of truncating 128 bit limbs from the input field
-    // and then subtracting them from the input such the field division is equivalent to integer division.
-    let low = (x as u128) as Field;
-    let high = (x - low) / TWO_POW_128;
-
-    (low, high)
-}
-
-pub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {
-    compute_decomposition(x)
-}
-
-unconstrained fn lte_hint(x: Field, y: Field) -> bool {
-    if x == y {
-        true
-    } else {
-        field_less_than(x, y)
-    }
-}
-
-// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)
-fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
-    let (alo, ahi) = a;
-    let (blo, bhi) = b;
-    // Safety: borrow is enforced to be boolean due to its type.
-    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)
-    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)
-    unsafe {
-        let borrow = lte_hint(alo, blo);
-
-        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
-        let rhi = ahi - bhi - (borrow as Field);
-
-        rlo.assert_max_bit_size::<128>();
-        rhi.assert_max_bit_size::<128>();
-    }
-}
-
-/// Decompose a single field into two 16 byte fields.
-pub fn decompose(x: Field) -> (Field, Field) {
-    if is_unconstrained() {
-        compute_decomposition(x)
-    } else {
-        // Safety: decomposition is properly checked below
-        unsafe {
-            // Take hints of the decomposition
-            let (xlo, xhi) = decompose_hint(x);
-
-            // Range check the limbs
-            xlo.assert_max_bit_size::<128>();
-            xhi.assert_max_bit_size::<128>();
-
-            // Check that the decomposition is correct
-            assert_eq(x, xlo + TWO_POW_128 * xhi);
-
-            // Assert that the decomposition of P is greater than the decomposition of x
-            assert_gt_limbs((PLO, PHI), (xlo, xhi));
-            (xlo, xhi)
-        }
-    }
-}
-
-pub fn assert_gt(a: Field, b: Field) {
-    if is_unconstrained() {
-        assert(
-            // Safety: already unconstrained
-            unsafe { field_less_than(b, a) },
-        );
-    } else {
-        // Decompose a and b
-        let a_limbs = decompose(a);
-        let b_limbs = decompose(b);
-
-        // Assert that a_limbs is greater than b_limbs
-        assert_gt_limbs(a_limbs, b_limbs)
-    }
-}
-
-pub fn assert_lt(a: Field, b: Field) {
-    assert_gt(b, a);
-}
-
-pub fn gt(a: Field, b: Field) -> bool {
-    if is_unconstrained() {
-        // Safety: unsafe in unconstrained
-        unsafe {
-            field_less_than(b, a)
-        }
-    } else if a == b {
-        false
-    } else {
-        // Safety: Take a hint of the comparison and verify it
-        unsafe {
-            if field_less_than(a, b) {
-                assert_gt(b, a);
-                false
-            } else {
-                assert_gt(a, b);
-                true
-            }
-        }
-    }
-}
-
-pub fn lt(a: Field, b: Field) -> bool {
-    gt(b, a)
-}
-
-mod tests {
-    // TODO: Allow imports from "super"
-    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};
-
-    #[test]
-    fn check_decompose() {
-        assert_eq(decompose(TWO_POW_128), (0, 1));
-        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));
-        assert_eq(decompose(0x1234567890), (0x1234567890, 0));
-    }
-
-    #[test]
-    unconstrained fn check_lte_hint() {
-        assert(lte_hint(0, 1));
-        assert(lte_hint(0, 0x100));
-        assert(lte_hint(0x100, TWO_POW_128 - 1));
-        assert(!lte_hint(0 - 1, 0));
-
-        assert(lte_hint(0, 0));
-        assert(lte_hint(0x100, 0x100));
-        assert(lte_hint(0 - 1, 0 - 1));
-    }
-
-    #[test]
-    fn check_gt() {
-        assert(gt(1, 0));
-        assert(gt(0x100, 0));
-        assert(gt((0 - 1), (0 - 2)));
-        assert(gt(TWO_POW_128, 0));
-        assert(!gt(0, 0));
-        assert(!gt(0, 0x100));
-        assert(gt(0 - 1, 0 - 2));
-        assert(!gt(0 - 2, 0 - 1));
-        assert_gt(0 - 1, 0);
-    }
-
-    #[test]
-    fn check_plo_phi() {
-        assert_eq(PLO + PHI * TWO_POW_128, 0);
-        let p_bytes = crate::field::modulus_le_bytes();
-        let mut p_low: Field = 0;
-        let mut p_high: Field = 0;
-
-        let mut offset = 1;
-        for i in 0..16 {
-            p_low += (p_bytes[i] as Field) * offset;
-            p_high += (p_bytes[i + 16] as Field) * offset;
-            offset *= 256;
-        }
-        assert_eq(p_low, PLO);
-        assert_eq(p_high, PHI);
-    }
-
-    #[test]
-    fn check_decompose_edge_cases() {
-        assert_eq(decompose(0), (0, 0));
-        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));
-        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));
-        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));
-        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));
-    }
-
-    #[test]
-    fn check_decompose_large_values() {
-        let large_field = 0xffffffffffffffff;
-        let (lo, hi) = decompose(large_field);
-        assert_eq(large_field, lo + TWO_POW_128 * hi);
-
-        let large_value = large_field - TWO_POW_128;
-        let (lo2, hi2) = decompose(large_value);
-        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);
-    }
-
-    #[test]
-    fn check_lt_comprehensive() {
-        assert(lt(0, 1));
-        assert(!lt(1, 0));
-        assert(!lt(0, 0));
-        assert(!lt(42, 42));
-
-        assert(lt(TWO_POW_128 - 1, TWO_POW_128));
-        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));
-    }
-}
-`, path: "std/field/bn254.nr" }, "19": { source: '// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated("This function has been moved to std::hash::keccakf1600")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you\'re working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            "Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators("pedersen_hash_length".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n    assert_eq(input.len(), state_len);\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n', path: "std/hash/mod.nr" }, "50": { source: `/// Fulfillment Proof Circuit
-///
-/// Proves: "The solver correctly executed the intent and delivered
-/// the required output to the recipient, without revealing execution
-/// path, liquidity sources, or intermediate transactions."
-///
-/// @see docs/specs/FULFILLMENT-PROOF.md
-
-use std::hash::pedersen_hash;
-use std::hash::pedersen_commitment;
-use std::ecdsa_secp256k1::verify_signature;
-
-// --- Main Circuit ---
-
-/// Main fulfillment proof entry point
-///
-/// Public inputs: intent_hash, output_commitment, recipient_stealth,
-///                min_output_amount, solver_id, fulfillment_time, expiry
-/// Private inputs: output_amount, output_blinding, attestation data, solver_secret
-///
-/// Constraints:
-/// 1. output_amount >= min_output_amount (range proof via u64)
-/// 2. output_commitment = Pedersen(output_amount, output_blinding)
-/// 3. Oracle attestation is valid and matches claimed values
-/// 4. Solver is authorized (solver_id derived from solver_secret)
-/// 5. fulfillment_time <= expiry
-pub fn main(
-    // Public inputs
-    intent_hash: pub Field,
-    output_commitment_x: pub Field,
-    output_commitment_y: pub Field,
-    recipient_stealth: pub Field,
-    min_output_amount: pub u64,
-    solver_id: pub Field,
-    fulfillment_time: pub u64,
-    expiry: pub u64,
-    
-    // Private inputs
-    output_amount: u64,
-    output_blinding: Field,
-    solver_secret: Field,
-    
-    // Oracle attestation (private)
-    attestation_recipient: Field,
-    attestation_amount: u64,
-    attestation_tx_hash: Field,
-    attestation_block: u64,
-    oracle_signature: [u8; 64],
-    oracle_message_hash: [u8; 32],
-    oracle_pub_key_x: [u8; 32],
-    oracle_pub_key_y: [u8; 32],
-) {
-    // Constraint 1: Output meets minimum requirement
-    // Range proof is implicit via u64 type comparison
-    assert(output_amount >= min_output_amount, "Output below minimum");
-    
-    // Constraint 2: Output commitment is valid
-    // C = Pedersen(output_amount, output_blinding)
-    let commitment = pedersen_commitment([output_amount as Field, output_blinding]);
-    assert(commitment.x == output_commitment_x, "Commitment X mismatch");
-    assert(commitment.y == output_commitment_y, "Commitment Y mismatch");
-    
-    // Constraint 3a: Attestation matches claimed values
-    assert(attestation_recipient == recipient_stealth, "Recipient mismatch in attestation");
-    assert(attestation_amount == output_amount, "Amount mismatch in attestation");
-    
-    // Constraint 3b: Oracle signature is valid
-    let valid_attestation = verify_signature(
-        oracle_pub_key_x,
-        oracle_pub_key_y,
-        oracle_signature,
-        oracle_message_hash
-    );
-    assert(valid_attestation, "Invalid oracle attestation signature");
-    
-    // Constraint 4: Solver authorization
-    // solver_id = pedersen_hash(solver_secret)
-    let computed_solver_id = pedersen_hash([solver_secret]);
-    assert(computed_solver_id == solver_id, "Unauthorized solver");
-    
-    // Constraint 5: Time constraint
-    assert(fulfillment_time <= expiry, "Fulfillment after expiry");
-    
-    // Intent hash binding (ensures this proof is for this specific intent)
-    // The intent_hash is a public input, binding this proof to the intent
-    // No additional constraint needed - it's enforced by the verifier checking public inputs
-    let _ = intent_hash;
-
-    // Attestation metadata (tx_hash and block) are included for auditability
-    // but not strictly constrained in circuit (oracle signature covers them)
-    let _ = attestation_tx_hash;
-    let _ = attestation_block;
-}
-
-// --- Tests ---
-
-#[test]
-fn test_output_commitment() {
-    // Test that commitment is correctly computed
-    let output_amount: u64 = 1000000;
-    let output_blinding: Field = 0x123456789;
-    
-    let commitment1 = pedersen_commitment([output_amount as Field, output_blinding]);
-    let commitment2 = pedersen_commitment([output_amount as Field, output_blinding]);
-    
-    // Commitment should be deterministic
-    assert(commitment1.x == commitment2.x, "Commitment X should be deterministic");
-    assert(commitment1.y == commitment2.y, "Commitment Y should be deterministic");
-}
-
-#[test]
-fn test_solver_authorization() {
-    // Test solver_id derivation
-    let solver_secret: Field = 0x1234567890ABCDEF;
-
-    let solver_id1 = pedersen_hash([solver_secret]);
-    let solver_id2 = pedersen_hash([solver_secret]);
-
-    // Solver ID should be deterministic
-    assert(solver_id1 == solver_id2, "Solver ID should be deterministic");
-
-    // Different secret should give different solver_id
-    let different_secret: Field = 0xFEDCBA0987654321;
-    let different_id = pedersen_hash([different_secret]);
-    assert(solver_id1 != different_id, "Different secrets should give different solver IDs");
-}
-
-#[test]
-fn test_range_proof_passes() {
-    // Test that output >= min passes
-    let output_amount: u64 = 1050000;
-    let min_output_amount: u64 = 1000000;
-    
-    assert(output_amount >= min_output_amount, "Output should be >= minimum");
-}
-
-#[test]
-fn test_time_constraint_valid() {
-    // Test valid time constraint
-    let fulfillment_time: u64 = 1732650000;
-    let expiry: u64 = 1732686400;
-    
-    assert(fulfillment_time <= expiry, "Fulfillment time should be <= expiry");
-}
-
-#[test]
-fn test_time_constraint_edge_case() {
-    // Edge case: exactly at expiry should be valid
-    let fulfillment_time: u64 = 1732686400;
-    let expiry: u64 = 1732686400;
-    
-    assert(fulfillment_time <= expiry, "Fulfillment at exactly expiry should be valid");
-}
-
-// NOTE: Full integration tests with ECDSA oracle signatures require TypeScript SDK
-// The NoirProofProvider will generate valid oracle signature test vectors
-`, path: "/Users/rz/local-dev/sip-protocol/packages/circuits/fulfillment_proof/src/main.nr" } }, expression_width: { Bounded: { width: 4 } } };
-
-export {
-  funding_proof_default,
-  validity_proof_default,
-  fulfillment_proof_default
-};