@aztec/protocol-contracts 4.0.0-spartan.20260218 → 4.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/artifacts/AuthRegistry.json +23 -23
- package/artifacts/ContractClassRegistry.json +13 -13
- package/artifacts/ContractInstanceRegistry.json +26 -26
- package/artifacts/FeeJuice.json +25 -25
- package/artifacts/MultiCallEntrypoint.json +53 -53
- package/artifacts/PublicChecks.json +53 -53
- package/dest/auth-registry/index.d.ts +1 -1
- package/dest/auth-registry/index.d.ts.map +1 -1
- package/dest/auth-registry/index.js +3 -3
- package/dest/auth-registry/lazy.js +1 -1
- package/dest/class-registry/index.d.ts +1 -1
- package/dest/class-registry/index.d.ts.map +1 -1
- package/dest/class-registry/index.js +3 -3
- package/dest/class-registry/lazy.js +1 -1
- package/dest/fee-juice/index.d.ts +1 -1
- package/dest/fee-juice/index.d.ts.map +1 -1
- package/dest/fee-juice/index.js +3 -3
- package/dest/fee-juice/lazy.js +1 -1
- package/dest/instance-registry/index.d.ts +1 -1
- package/dest/instance-registry/index.d.ts.map +1 -1
- package/dest/instance-registry/index.js +3 -3
- package/dest/instance-registry/lazy.js +1 -1
- package/dest/make_protocol_contract.d.ts +4 -4
- package/dest/make_protocol_contract.d.ts.map +1 -1
- package/dest/make_protocol_contract.js +27 -14
- package/dest/multi-call-entrypoint/index.d.ts +1 -1
- package/dest/multi-call-entrypoint/index.d.ts.map +1 -1
- package/dest/multi-call-entrypoint/index.js +3 -3
- package/dest/multi-call-entrypoint/lazy.js +1 -1
- package/dest/protocol_contract_data.d.ts +13 -1
- package/dest/protocol_contract_data.d.ts.map +1 -1
- package/dest/protocol_contract_data.js +86 -0
- package/dest/provider/bundle.js +1 -1
- package/dest/public-checks/index.d.ts +1 -1
- package/dest/public-checks/index.d.ts.map +1 -1
- package/dest/public-checks/index.js +3 -3
- package/dest/public-checks/lazy.js +1 -1
- package/dest/scripts/generate_data.js +66 -15
- package/package.json +4 -4
- package/src/auth-registry/index.ts +3 -3
- package/src/auth-registry/lazy.ts +1 -1
- package/src/class-registry/index.ts +3 -3
- package/src/class-registry/lazy.ts +1 -1
- package/src/fee-juice/index.ts +3 -3
- package/src/fee-juice/lazy.ts +1 -1
- package/src/instance-registry/index.ts +3 -3
- package/src/instance-registry/lazy.ts +1 -1
- package/src/make_protocol_contract.ts +37 -15
- package/src/multi-call-entrypoint/index.ts +3 -3
- package/src/multi-call-entrypoint/lazy.ts +1 -1
- package/src/protocol_contract_data.ts +63 -0
- package/src/provider/bundle.ts +1 -1
- package/src/public-checks/index.ts +3 -3
- package/src/public-checks/lazy.ts +1 -1
|
@@ -76,7 +76,7 @@
|
|
|
76
76
|
}
|
|
77
77
|
},
|
|
78
78
|
"bytecode": "JwACBAEoAAABBIBIJwAABEglAAAATicCBAQDJwIFBAAfCgAEAAUARRwAR0cBLQhFAS0IRgItCEcDJQAAAFknAgEESCcCAgQAOw4AAgABJwBDBAMnAEQAACYlAAABcR4CAAQBHgIABQAKKgQFBiQCAAYAAAB6JQAAAZcnAgQAAikCAAUA71JTTS0IAQYnAgcEBAAIAQcBJwMGBAEAIgYCBy0KBwgtDgUIACIIAggtDgQIACIIAggtDgEIJwIEBActCAAHLQoGCC0IQwkACAAEACUAAAGpLQIAAC0KCAEKIgFEBCcCBgEACioEBgckAgAHAAAA+SUAAAUiLQgBBCcCBwQEAAgBBwEnAwQEAQAiBAIHLQoHCC0OBQgAIggCCC0OAQgAIggCCC0OAggnAgIEBy0IAActCgQILQhDCQAIAAIAJQAAAaktAgAALQoIAQoiAUQCCioCBgQkAgAEAAABZSUAAAUiHAoDAgAwCgACAAEmKAAABAR4SAwAAAQDJAAAAwAAAZYqAQABBdrF9da0SjJtPAQCASYqAQABBcFQNKwlSLxRPAQCASYlAAABcRwKAgQAKwIABQAAAAAAAAAAAQAAAAAAAAAABCoEBQYtCAEEAAABAgEtCAEFJwIHBAUACAEHAScDBQQBACIFAgctCgcILQxECAAiCAIILQxECAAiCAIILQxECAAiCAIILQ4GCC0OBQQGIgJDBScCBgQAJwIHAQEnAggEAScCCQQCLQoGAyMAAAI3DCoDBQokAgAKAAADtyMAAAJJBiICQwUEIgVDCgIqAgoDCioDBgUWCgUKJAIABQAAA1EjAAACbgIqAgMFDioDAgskAgALAAAChSUAAAU0LQsECwAqCwgNLQsNDAwiBUMNJAIADQAAAqQlAAAFRgAiAQIOACoOBQ8tCw8NACoMDQ4tAgsDJwAEBAUlAAAFWC0IBQwAKgwIDS0ODg0tDgwEDCoIAwskAgALAAAC6CMAAANRACoMCQstCwsDACoFCAsOKgULDSQCAA0AAAMIJQAABbcMIgtDBSQCAAUAAAMaJQAABUYAIgECBwAqBwsNLQsNBQAqAwUBLQIMAycABAQFJQAABVgtCAUDACoDCQUtDgEFLQ4DBCMAAANRCioCBgESKgEKAiQCAAIAAANoIwAAA6UtCwQBLQsBAgAiAgICLQ4CAS0IAQInAgMEBQAIAQMBJwMCBAEAIgECAwAiAgIFPw8AAwAFLQ4CBCMAAAOlLQsEAQAqAQgDLQsDAi0KAgEmLQsECgAqCggMLQsMCwQiA0MMBiIMQw4KKg4DDSQCAA0AAAPgJQAABckMIgxDDSQCAA0AAAPyJQAABUYAIgECDgAqDgwPLQsPDQAqCw0OLQIKAycABAQFJQAABVgtCAULACoLCA0tDg4NACoLCQ0tCw0KACoMCA0OKgwNDiQCAA4AAARAJQAABbcMIg1DDiQCAA4AAARSJQAABUYAIgECDwAqDw0QLQsQDgAqCg4NLQILAycABAQFJQAABVgtCAUKACoKCQ4tDg0OACIKQw0tCw0LACoMCQ0OKgwNDiQCAA4AAASgJQAABbcMIg1DDCQCAAwAAASyJQAABUYAIgECDgAqDg0PLQsPDAAqCwwNLQIKAycABAQFJQAABVgtCAULACILQwwtDg0MLQsLCgAiCgIKLQ4KCy0IAQonAgwEBQAIAQwBJwMKBAEAIgsCDAAiCgINPw8ADAANLQ4KBAAqAwgKLQoKAyMAAAI3KgEAAQW6uyHXgjMYZDwEAgEmKgEAAQUbvGXQP9zq3DwEAgEmKgEAAQXkCFBFArWMHzwEAgEmLQEDBgoABgIHJAAABwAABW4jAAAFdy0AAwUjAAAFti0AAQUAAAEEAQAAAwQJLQADCi0ABQsKAAoJDCQAAAwAAAWxLQEKCC0ECAsAAAoCCgAACwILIwAABY0nAQUEASYqAQABBdAH6/TLxmeQPAQCASYqAQABBQUEG5kgr2BMPAQCASY=",
|
|
79
|
-
"debug_symbols": "
|
|
79
|
+
"debug_symbols": "rZnRbts6DIbfxde5ECmJIvsqwzBkXToECNIiaw9wUPTdR8qi3Ayw0Sq9ab78iX5RFC067uv06/Dz5feP4/nh8c909+11+nk5nk7H3z9Oj/f75+PjWdXXKdgfSdMd7iaR6S7vJgj6luxV5lco8yvidAdgUBpEapCCQ26QXcmukCuUHLhBiQ7uzD4X2xRJQcAhO8gMGKIDNwBXLPYKaMPJgBpEV6IrKTmoM+rsmKMDNyBXyJXiigVfgcGBGkhwyA42hQYWLdszcANAB2pgwc/gSgwONpwMpEFyJaODBhaDAqkS425KNjwmA40n6qanTA1I54pkkBsU+3IxSA7SgF1hV8QV4RlyQIfSAMCBGmBwyA7NMEdNb2QFKg3YviMKltUZmkJBlRQMcgMr2gQGpUF0xYp2BvsyGuikSfNDOTlwA9v3CgUcNPikOSTb7hlcscBSNsjty9KcS0gOrkB0aHOVGnMFM9QtKLanqRhIA6vMxAbcgFypEVagBuyKbVMF26YkBjIDh+SghllTxzWwYlAa1MAquGIX0QzUoGa1gh0nml62ZGZNLxd0oAYcHLKDjdIcskQHnkFCdHAFXAFX0ObS1ImVTc4GGmrWHErCBlljzsXAJtVsiB1NM9hwMZAGxZXiCpcGgg5NgWBlNxOoJYVK2Qm7ZmESVJJ5agg14pnYKXUtFSe7rBtpGgmN7KJtZLNFI7tsG3WNYyd2Etc01E7mbGcs2LXaqGt1HblSbvOCrWMmO5Eadc3W0YidbB1U+4udTzPVdZRK5FS6Zlswk507jbpmu1AJ7cQhrlScoGt1HVL7GbR5sa6jkp2MjRZNnOw6bMROfR3Y14G2jlJbpe3HTLYfjbrGXeOuSddEIy1WL9HOtRLe3naTd+8fz5fDwZr3u3auTf5pfzmcn6e788vptJv+259e6pf+PO3P9fV5f9FP1fNw/qWvavhwPB2M3nbL6LA+VKvTrq86XJmoW2S48oB1j2jnTHWIlPr4gp+IoYQlBglrMcR1DwLmZkFaMIuDXDmkdQcsboAyuIr3mRRcW8Wmh7bO7pFTWfMoGx5orWq20PuT7sDpyoE3MsEeQxTu4xNcp1LWDQSsD1cHgbJsp23tVU1tpIJC9GxSSEtZxo8HwcmD0KNhPQhc92Ad2TxYe8i6x0Zlxow9m8t+xvDxDdU7Y9/QGGhtQyFvJLOnogRYM/h4XdLqFQq3FybcXJnwBaWJN5cmfEFt4hfUJt5cm3B7ceJGcWZesrlsCNNgcfJqceLmOkIvToiwFgbyVhwcU4+DU1prQrhRGRk8jIzvKjx+JowiZQkDZC2MCJs5Jewm2lxXTTYqNFLxfMQCeaSnSug7K+8c/q3QLQteClRQhizEfmc0i1zGLAp0C8YRCwzkFnofnIYsUvBcYMKxKFJcLN71gc9Y5NAXkpHGLHLoFhnGLFJaLHAwCuoWhW+OYtSiF7j+ThkqcKSE3SKPbSpR3xEqg1HkngvicPNCxiwiF29HkTkNWixtNQxtapQI3YLW05k3mrs+1vNekjguFf7P3dJmFEI9CiljC5Hllk3GChx6E1Acu9iDpMVi7GIH6KWlDyIGF0KLxe0LGbSA5QSHVMYscukWJIMWvQlc3YcPLmTUoj81QJCxVoTLpiLwoEVYLOTWhYxaLD/PEDmu/1INY0fOd323vz9erv5h9WZel+P+5+nQ3j68nO/fffr8/5N/4v/wero83h9+vVwO5rT810v/fEO9y9IHbt/tOai+LbRjsDdgn+kjTm1N398slL8="
|
|
80
80
|
},
|
|
81
81
|
{
|
|
82
82
|
"name": "consume",
|
|
@@ -152,7 +152,7 @@
|
|
|
152
152
|
}
|
|
153
153
|
},
|
|
154
154
|
"bytecode": "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",
|
|
155
|
-
"debug_symbols": "
|
|
155
|
+
"debug_symbols": "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"
|
|
156
156
|
},
|
|
157
157
|
{
|
|
158
158
|
"name": "is_consumable",
|
|
@@ -225,7 +225,7 @@
|
|
|
225
225
|
}
|
|
226
226
|
},
|
|
227
227
|
"bytecode": "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",
|
|
228
|
-
"debug_symbols": "
|
|
228
|
+
"debug_symbols": "rZnbbuM4DIbfJde9ECmJEvsqg8Eg06aDAEFaZNoFFkXffUmJlJsFbBRKb+rPTP2bJ4mO8757PPx++/PreH56/ru7//G++305nk7HP79Ozw/71+PzWazvu6B/OO3u492OeXef7nYQSj8C7u5Zj6UfkfoxBjvmfkx2nuw823lOdqz9SNGOpldMv4guoEAFh+zABhwdagcM0aEYgF6eFMgA3YJuiclBleXumKJDNchuyW4ht6jrDQo4kEENDtlBboHqmOa3Q+0QAzqQgTrfwS0YHPTypMAG0S0JHcSxGASyWKJeRXJ51I8oGxSzpCT3illB7hVJQONqoDWJRYEMtCixKmQDDg5mySE4DAsbQHSoBogOxSCCAxkkF0zampLMXKIByz+noEAdKICDWkBAk9kA5aZJskExOrhFY2+Q9Z+jgjifJD+kqeuQHNigFIMqUaSsUAzYLc0xSWZpjiUFUy4QHIbFlAsmh2oQVVBKUHRBpaqQHfQqyUZpHjZwS/NQoXnYwC1aL4Wq9cpBIRuAW0AEMyhwv1fF6FANoltiMdA+7EAG6mqW9FZNZpb01lIN1LEOZKA17aBXZQXuwCE5uAXcAm5Bt+jOlJOCfiQlYF3duShUgyw+Z/GQSW/KCmSgC4SCQjaobqlu0Y2oQ+0AIUQn7Tsj0SRQ0j3IaNjUT8JGud9biJ20542GTfcko+pEkkeKjYqT7kvUN3FyqsOmO1In3ZKM3Nb2/U6681NuVJxw2FocpKQLt923zYJOunSNFhs76Uww0vwVJd1djfRutY0cHDRsrQaNdAcyclubB0aq3AaWbj5Gw6ZxlNCo2H2xxdGJnNKwtTga6UI0SoM8DhxxtDFRtL5tThiRUx22Omw8bOy2NiQKNFIbfHzc7Xx4/3q9HA46uz9Nc5nxL/vL4fy6uz+/nU53u3/2p7f2T39f9ud2fN1f5FOJ/nB+lKMIPh1PB6WPu+XqsH6pZEgnR7tcOJchkeFKA9Y1mJBMgil9UuArBdzwItTkTkjbDoWCs3HwWhybGkk3LdNINaxp5G2NIcF5KNR0pUDrCvLgYQKR67g+wXUyy0Y5QEdlLweUJYjI111R1yUoRE8EhUSLxNd9GAVleWpb9QE2ylFZn5aaRmXidY2N1owZRzKXtorh6/UEZq+nLNu1ekLcSOZIhTxArAl8vS15fYne3pdwc2PCN3Qm3Nya8A29id/Qm3hzb8LtzYkbzZnrks2lIJXmmjMDrTUnbsTB+lTcCyI7/ooTSFvzA7OPIOGyPoPKlkiAMkRCTKsiW+0JtXpCMeCqBG+ss+IK8kVzbRRuBcJccIkj1TUn4mZzJi+rDNN1N7aLkj4VhVeTEbc2z1ESiotAil9vUA6+bQFDXl1nWxJ1WWaMPCXBS39yLnMSBYZExRkJDOQS8pYlTUmk4LnAhHNepLhIUJiSyGEEkpHmJHIYEhnmJFJaJHDSCxoSpd7sxazEaHAkmGpwpIRDIs8VlWhUhMqkF3nkgmq4OZA5iVjL2DtrTZMSy8NBmCpq5AhDgtbTqRlb00jyisk0Uv20//7vmW/TC6bhBZe5QHh58OS5BocxBATnFru8Ylkk5hY7wGgteasxGQgtErcHMikByw4OqcxJ5DIkiCclxhC4+jYxGcisxHjgQ+C5UYRLUUVuUiIsEnxrILMSy5dMxBpXJQrMbTk/5Wz/cLxc/eT1oVqX4/736WCnT2/nh0+fvv774p/4T2Yvl+eHw+Pb5aBKy+9m8ucHysYrb+9+6qtUOZVn8Rr1BPQzeUsqQ+Hnh7ryHw=="
|
|
229
229
|
},
|
|
230
230
|
{
|
|
231
231
|
"name": "is_reject_all",
|
|
@@ -275,7 +275,7 @@
|
|
|
275
275
|
}
|
|
276
276
|
},
|
|
277
277
|
"bytecode": "JwACBAEoAAABBIBGJwAABEYlAAAARScCAgQBJwIDBAAfCgACAAMARC0IRAElAAAARi0CAUUnAgIERScCAwQBOw4AAwACJiUAAAFAHgIAAgknAgMBASQCAAIAAABiJQAAAWYpAgACAO9SU00nAgMAASsCAAQAAAAAAAAAAAMAAAAAAAAAAC0IAQUnAgYEBQAIAQYBJwMFBAEAIgUCBi0KBgctDgIHACIHAgctDgMHACIHAgctDgEHACIHAgctDgQHLQsFAQAiAQIBLQ4BBS0IAQEnAgIEBQAIAQIBJwMBBAEAIgUCAgAiAQIDPw8AAgADJwICBAEAKgECBC0LBAMnAgEAAAoqAwECJwIBAQAKKgIBBCQCAAQAAAEfJQAAAXgeAgABAC8qAAMAAQACHAoCAwEcCgMBABwKAQIBLQoCASYoAAAEBHhGDAAABAMkAAADAAABZSoBAAEF2sX11rRKMm08BAIBJioBAAEFoj+MFkXsKv88BAIBJioBAAEFursh14IzGGQ8BAIBJg==",
|
|
278
|
-
"debug_symbols": "
|
|
278
|
+
"debug_symbols": "nZbRrvIgDMffhetdQCmF+ionxkydJ0uWaXb0S74Y3/2Ah27OBC68kf/K+K2lpXJXx25/+9714+n8ozZfd7Wf+mHov3fD+dBe+/MYrXel0493amMbFeIDxsE9B7Z/Q1AbYxpltM/CQBbWipAplCkUixOLEwsZES4Lr0WgCM4iyCeCuMECZPoToI2IBLRJcBYGRYgFxAJisWLB5AYm4bJwYnHpHUqCsyCxkFi8WAKIiCEDRJF8hsixOgKBknBZmKfl8WiUpGV3nbouZeUlTzF7l3bqxqvajLdhaNS/drg9X/q5tONzvLZTnNWN6sZjHCPw1A9dUo9mWa3LS42xGvLyqAFnhDMrhikzmFJQTwQT+oXAKwJUvNABZyf0QvDwaRxUiqPKQNAzA9GUGK7CiHUkCGA3EwKuCFQmQBAfLId5PZr1ZvpKOsy8mQywBGF5XRWhjAgMspmBiYsILiOsgzmMJaFWv1VVJR0Qj39GxJNMnzGWdAAEW2ZUihM9CwODhZnxlpGaG5Z5SepLVt/dqBWWYZbCsppKhWUqCBdsJpBeWkWgD88H6WKvqFUneilODyUnTKj1CnDSbqL2xX5juAbRxs8QbbHYtCr7QUuBEmgoIiqtE/xc4oyltlcLhOMuLnFgKDpha0cVpTCsq7hRTwq+JIXLm+Fq+ykpoZdjhjbWxjY+tod+Wl1jHgk19e1+6PLj6TYeXmav/y8yI9egy3Q+dMfb1CXSchdKf8hfZBqibbrrxAevGw/bR/r0Lw=="
|
|
279
279
|
},
|
|
280
280
|
{
|
|
281
281
|
"name": "public_dispatch",
|
|
@@ -351,7 +351,7 @@
|
|
|
351
351
|
}
|
|
352
352
|
},
|
|
353
353
|
"bytecode": "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",
|
|
354
|
-
"debug_symbols": "
|
|
354
|
+
"debug_symbols": "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"
|
|
355
355
|
},
|
|
356
356
|
{
|
|
357
357
|
"name": "set_authorized",
|
|
@@ -405,7 +405,7 @@
|
|
|
405
405
|
}
|
|
406
406
|
},
|
|
407
407
|
"bytecode": "JwACBAEoAAABBIBHJwAABEclAAAASicCAwQCJwIEBAAfCgADAAQARRwARkYBLQhFAS0IRgIlAAAAVScCAQRHJwICBAA7DgACAAEnAEMEAycARAAAJiUAAAFWHgIAAwEnAgQAAikCAAUA71JTTS0IAQYnAgcEBAAIAQcBJwMGBAEAIgYCBy0KBwgtDgUIACIIAggtDgQIACIIAggtDgMIJwIEBActCAAHLQoGCC0IQwkACAAEACUAAAF8LQIAAC0KCAMKIgNEBCcCBgEACioEBgckAgAHAAAA3iUAAAT1LQgBBCcCBwQEAAgBBwEnAwQEAQAiBAIHLQoHCC0OBQgAIggCCC0OAwgAIggCCC0OAQgnAgMEBy0IAActCgQILQhDCQAIAAMAJQAAAXwtAgAALQoIAQoiAUQDCioDBgQkAgAEAAABSiUAAAT1HAoCAwAwCgADAAEmKAAABAR4RwwAAAQDJAAAAwAAAXsqAQABBdrF9da0SjJtPAQCASYlAAABVhwKAgQAKwIABQAAAAAAAAAAAQAAAAAAAAAABCoEBQYtCAEEAAABAgEtCAEFJwIHBAUACAEHAScDBQQBACIFAgctCgcILQxECAAiCAIILQxECAAiCAIILQxECAAiCAIILQ4GCC0OBQQGIgJDBScCBgQAJwIHAQEnAggEAScCCQQCLQoGAyMAAAIKDCoDBQokAgAKAAADiiMAAAIcBiICQwUEIgVDCgIqAgoDCioDBgUWCgUKJAIABQAAAyQjAAACQQIqAgMFDioDAgskAgALAAACWCUAAAUHLQsECwAqCwgNLQsNDAwiBUMNJAIADQAAAnclAAAFGQAiAQIOACoOBQ8tCw8NACoMDQ4tAgsDJwAEBAUlAAAFKy0IBQwAKgwIDS0ODg0tDgwEDCoIAwskAgALAAACuyMAAAMkACoMCQstCwsDACoFCAsOKgULDSQCAA0AAALbJQAABYoMIgtDBSQCAAUAAALtJQAABRkAIgECBwAqBwsNLQsNBQAqAwUBLQIMAycABAQFJQAABSstCAUDACoDCQUtDgEFLQ4DBCMAAAMkCioCBgESKgEKAiQCAAIAAAM7IwAAA3gtCwQBLQsBAgAiAgICLQ4CAS0IAQInAgMEBQAIAQMBJwMCBAEAIgECAwAiAgIFPw8AAwAFLQ4CBCMAAAN4LQsEAQAqAQgDLQsDAi0KAgEmLQsECgAqCggMLQsMCwQiA0MMBiIMQw4KKg4DDSQCAA0AAAOzJQAABZwMIgxDDSQCAA0AAAPFJQAABRkAIgECDgAqDgwPLQsPDQAqCw0OLQIKAycABAQFJQAABSstCAULACoLCA0tDg4NACoLCQ0tCw0KACoMCA0OKgwNDiQCAA4AAAQTJQAABYoMIg1DDiQCAA4AAAQlJQAABRkAIgECDwAqDw0QLQsQDgAqCg4NLQILAycABAQFJQAABSstCAUKACoKCQ4tDg0OACIKQw0tCw0LACoMCQ0OKgwNDiQCAA4AAARzJQAABYoMIg1DDCQCAAwAAASFJQAABRkAIgECDgAqDg0PLQsPDAAqCwwNLQIKAycABAQFJQAABSstCAULACILQwwtDg0MLQsLCgAiCgIKLQ4KCy0IAQonAgwEBQAIAQwBJwMKBAEAIgsCDAAiCgINPw8ADAANLQ4KBAAqAwgKLQoKAyMAAAIKKgEAAQW6uyHXgjMYZDwEAgEmKgEAAQUbvGXQP9zq3DwEAgEmKgEAAQXkCFBFArWMHzwEAgEmLQEDBgoABgIHJAAABwAABUEjAAAFSi0AAwUjAAAFiS0AAQUAAAEEAQAAAwQJLQADCi0ABQsKAAoJDCQAAAwAAAWELQEKCC0ECAsAAAoCCgAACwILIwAABWAnAQUEASYqAQABBdAH6/TLxmeQPAQCASYqAQABBQUEG5kgr2BMPAQCASY=",
|
|
408
|
-
"debug_symbols": "rZnRbhs5DEX/xc9+
|
|
408
|
+
"debug_symbols": "rZnRbhs5DEX/xc9+ECmRkvorRVGkqVsYMJzATRZYFPn35dWImrjAGFm5L54z19YVSXFGY/v37vvh2+vPr8fzj6dfu0+ff+++XY6n0/Hn19PT48PL8els6u9dwEu1V97vquw+5f2OQujHuhwp9mNZjtzPuZ/Hfh7zckzUj7ocpftJ9xfzpWCgyaF0yOygHQo5uIJoF8BwBtQFOCQHVyh3YDhngHaI5OBKciW5gtAXSA61g0aH0gHBcwDkDgh+AXGoHRD8Al2JITpguMUciR1cYekQsWQKgFINMEXEcNQn0n6XiBwsnWijEgcHfDgCaoeYHFxJriRXJDrkDsoO2iGTg09RgoMbFqtYTPudYFEaJHxGANJBXEHXRMtUNHRAeaMVXAo7uIIWBih6OBYAJq2A2gHtvEDpgJZogJZIAaAdkisILFkxtQWGD4s7izurK+rO2edqMQPQEsmWQLHuyaqREeECNipZNTIiXMAVRNigRdjAFSzTAjC0imUEtoAr6NWkgNLnQq8ukDsUV3ChNajkIAuUFmoGwNnKWzh3aIE1kA5Y0wVslARA6YBGWsAVdUVdya5kzGWlK2gbsSUo1UIVBuQFarCYxSKsZJNKAoiDDRcrQuXk4Ep0JbFD7iCuoOsWgKHVsObgMBQYWlkqOrxN2kIF1OjQFbu78qDshEtVSiN1wsUqtZE4xaHF4pTioKGJOqk5a2ikTnloSEEJhKt0mbclsVB1qkNreYAI96tOlofiRky4Y3XCbBHENGhoqHyn6pSGhuJ3gjMqRLjTdBpay0Maqc+LPDqJUx0a8uhUOzHy6OR58MiDWx5tt8N6dBKnOLQ4tDS0NDRBpNoImr697Xe+D399uRwO2Ibfbcy2XT8/XA7nl92n8+vptN/983B6bR/69fxwbseXh4u9a6t4OH+3oxn+OJ4OoLf9OjpsD40Ru1YbHW0/GQZCVw50wwGX5WKgaYzP/OEIbDscEZBuRRC3HVDj7kBcZTiUdOWQth24eAljLWN8onplINsGlbAtNIdKeS2j7cNXFrptoQHbYrOw/WqtQ/x4DCV5DMy0GUPZtrCbKneLUrVuWtQbyyk8SplXg/Dx1bSr0lczBt1aTbrRkjoKkQNtGXy0JWPavCju70m6uynpL3Ql3d2W9Bf6kv5CY9LdnUn3tybfaE0pazXXBSk61Zqy2Zp8M4swWpMibQXBN1rTngqirymeFd7Fcd2dfKMvhDwM4Xf9Hf9PGLnmNQyqm2HkWyaiPEzs+8CmyY3+jJq9HjGTTGyD9nzilzvVdw5/9ucti7K2pz3fTllUPMt2C8lzFpmGReEZCw7qFvY4lqYsUvBacOK5KFJcLTRMWUgYiQjrnIWEYSE0Z5HSasGTUeiwyOXuKGYtRoOz0lSDsyYeFjK3qKpjRTRPRiGjFlrC3YnMWUT7eu03rVLSpMW6qYapRY010rDQ7XKmG1t7sl8nukcqce3wP56VbkZRdURR81widX1gq3MNTmMTMJy72O1r+moxd7ETjday78OTiehqcX8ikxa03sEp5TkLycNC66TF2ASunsInE5m1KGVY1LmtiNdFZSqTFmG1qPcmMmuxfjljLnHTQnXulvPFzh4ej5erf1ne4HU5Pnw7Hfrpj9fz47t3X/599nf8X5rny9Pj4fvr5QCn9a8ae/lsfz3sufAX/Bxnp/bMlRUnhPesZ22v/PKGUP4D"
|
|
409
409
|
},
|
|
410
410
|
{
|
|
411
411
|
"name": "set_authorized_private",
|
|
@@ -2227,7 +2227,7 @@
|
|
|
2227
2227
|
}
|
|
2228
2228
|
},
|
|
2229
2229
|
"bytecode": "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",
|
|
2230
|
-
"debug_symbols": "tVpbbhs7DN2Lv/
|
|
2230
|
+
"debug_symbols": "tVpbbhs7DN2Lv/0hiqQkZitFUbipWxgwnMBNClwU3fulPCPNOK1YxXJ/cuSZ8AxF8aHXz82X/efXb58Op69P3zcPH35uPp8Px+Ph26fj0+Pu5fB00qc/Ny7/Ado8gP+13UD+hXHz4LcbTAr6zOdnHjcPpG2agCcIE8QJ0gSyeYgq7SaACZQkKeAENIGygFMMM8aM+kW8fFElAZTPz4gz0ow8Y5YGlaLSE9Qf/IeOhMs/qHrwS38VK3x6Oe/3+c3KLGqs5915f3rZPJxej8ft5sfu+Hr5p+/Pu9MFX3Znfata709fFJXw6+G4z61f20XatUUp8iwcfKzikXvlOfoiDyv52Cs/oHqg8unk0vJp7JVPKc7y4nxLntvyGIrpMFKVJ5IrgtAm8FQIfIhNgj4NEjYJDBOIl2ICci0TyGgPrDEUnAkiwg3uAw6KE4BbqeCx2w2iiFQ/wsWMDFcMgIYn1V4I8i06JPCp6AAUmjoYvkDkYKYggpU/IvdrkWpEeXBNLaLhEBBKR7xfJZTgrymS4ZOQqFjT+8UpUK4zA4g1IL72RII0ObxhDeRCgbJ0BN21MTwYDA7LkGhTbuMAKNZAYN/mQCvHSwlTSrhwgPSrEUJxcQwRbuvKmiPxbRyymPRqYN9yxH9rDhFX1ZDUVMMKNs9Ug018K9jQ8lCkULTAtKJI/RTMy5hgaFFY/dDEU/rBrt0Pwz8FS86QsCK4ThlIxoiyqyPKHJuGsEpprWQEvEp9t3RiFR9vO2G4ZazREeMyEOT7NRCqpdC3VTDSJoUylBoji1P7dwxlLULg1ma81oHMLOEWj2y7Q577jVYQwvEKQjRaQYjHK4jJ0VlBaDxlmmp0VpBuDqOCmBydFYTh35qjs4JYwaYhVlYwAB5bocKGi0J0ZfILMcWbKIKveSesDPqWwlgIAUKoPUFolzIen3ryHaaefIepZxieeoY7zNfCHeZaYXzqGe4w1/qLg0ldJ6JfLTXfOFgIpj3qAiu01qq2Fp5g0aLt5sHwUdB1XiWhtaO/iyTWqaO2IzYDrjPw03rReh1wEUyLYDUILwk9uHdQpFR74mKTAoczRyQrc9SRFc2pzaiPRkkIjkouDo5Xjv4OLfryV4zj+Sum0fwVZTx/mRyd+SuNV3pbjb78ZTt5jB1ObkZrCjVtpJRuqfTe1am5d0wtimTm0FR3qcA1Fwgpjjt5SuNOnmTUycWNz+5Njs7ZvfhhJzfV6IxXm6NugmJYbUf/VuhNF61LWO9Sc/UohouqP9RN8YjUqoxiuCjXkrTeU0nQr0OCUp4lYbM6i+GewKnmHWABuWVvJ8W6t5NWqevthrADq6oh1qq2miX0740Lc43VRG0lrAqPS4WnlT3fbku7OxRXcDyeePQwYzTzgIvjqccm6cw94GQ4+diKdGaffhJjc8Em6ZxzAOA/NskddqhVrh6QEjcDD0bXTNYBpeOajDUm2jpYix2GZZ+EITZTOsA98ulfdPGxbrgwYXMJCNbxg9RzX/WjdMOpvfjl7Dt7xNqsH/XX7vFwvr6gAfl+g0Y75MsMGdOMMqF3itrxfF/igj4nhem+BM73JdBP9yUuGHKYTbc2LphmVL68k54vblwQchBMVzdovrtB8+WNnAbz7Y0LhnwhYLq9ccE0o/LlvSVy+bBZEWZUvlzcCGdUvnyVgTifxyiGfLShGPO5hmLKplKUCdnNCLlEK+b7IU6JGEuD8vDkBpdGKI1YGik39DMscyO40rhcPFHNQ2bOB5UBSyMz++w6P3bnw+7zcZ+HKA/i6+mxjJj+fPnvubwpl26ez0+P+y+v530e3dXNG/37QePYQx796fqNPvG8Rf64nV7rMQ9xfu2rhK55KeRHWCVki/KbBP3+Dba/EaqExoHXb2S//B8=",
|
|
2231
2231
|
"verification_key": "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"
|
|
2232
2232
|
},
|
|
2233
2233
|
{
|
|
@@ -2259,7 +2259,7 @@
|
|
|
2259
2259
|
}
|
|
2260
2260
|
},
|
|
2261
2261
|
"bytecode": "JwACBAEoAAABBIBFJwAABEUlAAAARicCAgQBJwIDBAAfCgACAAMARBwAREQBLQhEASUAAABHJwIBBEUnAgIEADsOAAIAASYlAAABGh4CAAIBKQIAAwDvUlNNJwIEAAErAgAFAAAAAAAAAAADAAAAAAAAAAAtCAEGJwIHBAUACAEHAScDBgQBACIGAgctCgcILQ4DCAAiCAIILQ4ECAAiCAIILQ4CCAAiCAIILQ4FCC0LBgIAIgICAi0OAgYtCAECJwIDBAUACAEDAScDAgQBACIGAgMAIgICBD8PAAMABCcCAwQBACoCAwUtCwUEJwICAAAKKgQCAycCAgEACioDAgUkAgAFAAABDiUAAAFAHAoBAgAwCgACAAQmKAAABAR4RQwAAAQDJAAAAwAAAT8qAQABBdrF9da0SjJtPAQCASYqAQABBbq7IdeCMxhkPAQCASY=",
|
|
2262
|
-
"debug_symbols": "
|
|
2262
|
+
"debug_symbols": "nZXbiuMwDIbfxde5sOSj+irDUNI2HQIhLZl2YSl991UaOYeCzc7c5JeV+IssyfZDnZrD/Wvf9ufLt9p9PNRhaLuu/dp3l2N9ay89ex9Kj4/g1Q4rFUHtqFKkJ3EvAfCTohYVv5GxkbGVsbWicVJnRMOkHkWFG0BUOIEmjcKJzAFggzAZYTJQYzKSB5IHkgf594CjEcUwyWPGbywbFpORPC55XPJ4J0bgdUIcDfYgPJ+VShnd34amGRO6SjEn/loPTX9Tu/7edZX6U3f310ff17p/6a0e+K2uVNOfWBl4brtmtJ7VMlvnp1rQILMtgJ0BDjYEyBOMJQEYv8wP+N8R6EBzBFrnIjB5AqB1QgAkNxOi3RBsnoAxpdBQnOdboA3A5QHEPScEQq5sQhjaVsLnEZEnCiKSpywiFErhcF5GWAB6m8lYyANvGSEgkP8VYikG7xuTRUCpJQIlho0GZ8ZbPQpRGKKloquSvkdR6iqg1Jd8YPlcV0EB4aIRgl81dvS/2hqrrnrfnK60Cj3vDTCQCwIKjQk6mtTcbNvVIbGtBxRa00EKw+Fqh5mfhBEoLGEAZcOgEsR5nCEeYg6ChbIYH1I+TAC3OfM+eVQf22FzVT5H1tDWh66R4fneH1dvb3+v6U26aq/D5dic7kMzkpb7Fvj54Wzl6HO8YHngdeXx8zn++h8="
|
|
2263
2263
|
},
|
|
2264
2264
|
{
|
|
2265
2265
|
"name": "utility_is_consumable",
|
|
@@ -2327,7 +2327,7 @@
|
|
|
2327
2327
|
}
|
|
2328
2328
|
},
|
|
2329
2329
|
"bytecode": "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",
|
|
2330
|
-
"debug_symbols": "
|
|
2330
|
+
"debug_symbols": "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"
|
|
2331
2331
|
}
|
|
2332
2332
|
],
|
|
2333
2333
|
"outputs": {
|
|
@@ -2640,27 +2640,27 @@
|
|
|
2640
2640
|
"path": "std/hash/mod.nr",
|
|
2641
2641
|
"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 crate::assert_constant(separator);\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 crate::assert_constant(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// Decompose the input 'bn254 scalar' into two 128 bits limbs.\n// It is called 'unsafe' because it does not assert the limbs are 128 bits\n// Assuming the limbs are 128 bits:\n// Assert the decomposition does not overflow the field size.\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 // Check that the decomposition does not overflow the field size\n let (a, b) = if xhi == crate::field::bn254::PHI {\n (xlo, crate::field::bn254::PLO)\n } else {\n (xhi, crate::field::bn254::PHI)\n };\n crate::field::bn254::assert_lt(a, b);\n\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"
|
|
2642
2642
|
},
|
|
2643
|
-
"
|
|
2643
|
+
"233": {
|
|
2644
2644
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
|
|
2645
2645
|
"source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field = 12;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n // compatible. It is therefore always safe to call.\n unsafe {\n assert_compatible_oracle_version_wrapper();\n }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n}\n\n#[oracle(utilityAssertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(version: Field) {}\n\nmod test {\n use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION};\n\n #[test]\n unconstrained fn compatible_oracle_version() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n }\n\n #[test(should_fail_with = \"Incompatible oracle version. TXE is using version\")]\n unconstrained fn incompatible_oracle_version() {\n let arbitrary_incorrect_version = 318183437;\n assert_compatible_oracle_version_oracle(arbitrary_incorrect_version);\n }\n}\n"
|
|
2646
2646
|
},
|
|
2647
|
-
"298": {
|
|
2648
|
-
"path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.2.3/src/poseidon2.nr",
|
|
2649
|
-
"source": "use std::default::Default;\nuse std::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n self.state[0] += self.cache[0];\n self.state[1] += self.cache[1];\n self.state[2] += self.cache[2];\n self.state = crate::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut state = [0; 4];\n state[RATE] = iv;\n\n if std::runtime::is_unconstrained() {\n for i in 0..(in_len / RATE) {\n state[0] += input[i * RATE];\n state[1] += input[i * RATE + 1];\n state[2] += input[i * RATE + 2];\n state = crate::poseidon2_permutation(state, 4);\n }\n\n // handle remaining elements after last full RATE-sized chunk\n let num_extra_fields = in_len % RATE;\n if num_extra_fields != 0 {\n let remainder_start = in_len - num_extra_fields;\n state[0] += input[remainder_start];\n if num_extra_fields > 1 {\n state[1] += input[remainder_start + 1]\n }\n }\n } else {\n let mut states: [[Field; 4]; N / RATE + 1] = [[0; 4]; N / RATE + 1];\n states[0] = state;\n\n // process all full RATE-sized chunks, storing state after each permutation\n for chunk_idx in 0..(N / RATE) {\n for i in 0..RATE {\n state[i] += input[chunk_idx * RATE + i];\n }\n state = crate::poseidon2_permutation(state, 4);\n states[chunk_idx + 1] = state;\n }\n\n // get state at the last full block before in_len\n let first_partially_filled_chunk = in_len / RATE;\n state = states[first_partially_filled_chunk];\n\n // handle remaining elements after last full RATE-sized chunk\n let remainder_start = (in_len / RATE) * RATE;\n for j in 0..RATE {\n let idx = remainder_start + j;\n if idx < in_len {\n state[j] += input[idx];\n }\n }\n }\n\n // always run final permutation unless we just completed a full chunk\n // still need to permute once if in_len is 0\n if (in_len == 0) | (in_len % RATE != 0) {\n state = crate::poseidon2_permutation(state, 4)\n };\n\n state[0]\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n"
|
|
2650
|
-
},
|
|
2651
2647
|
"3": {
|
|
2652
2648
|
"path": "std/array/mod.nr",
|
|
2653
2649
|
"source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a vector.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let vector = array.as_vector();\n /// assert_eq(vector, [1, 2].as_vector());\n /// ```\n #[builtin(as_vector)]\n pub fn as_vector(self) -> [T] {}\n\n /// Returns this array as a vector.\n /// This method is deprecated in favor of `as_vector`.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let vector = array.as_slice();\n /// assert_eq(vector, [1, 2].as_vector());\n /// ```\n #[builtin(as_vector)]\n #[deprecated(\"This method has been renamed to `as_vector`\")]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the [`Self::sort_via`] function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl<let N: u32> [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str<N>) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n"
|
|
2654
2650
|
},
|
|
2655
|
-
"
|
|
2651
|
+
"301": {
|
|
2652
|
+
"path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.2.3/src/poseidon2.nr",
|
|
2653
|
+
"source": "use std::default::Default;\nuse std::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n self.state[0] += self.cache[0];\n self.state[1] += self.cache[1];\n self.state[2] += self.cache[2];\n self.state = crate::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut state = [0; 4];\n state[RATE] = iv;\n\n if std::runtime::is_unconstrained() {\n for i in 0..(in_len / RATE) {\n state[0] += input[i * RATE];\n state[1] += input[i * RATE + 1];\n state[2] += input[i * RATE + 2];\n state = crate::poseidon2_permutation(state, 4);\n }\n\n // handle remaining elements after last full RATE-sized chunk\n let num_extra_fields = in_len % RATE;\n if num_extra_fields != 0 {\n let remainder_start = in_len - num_extra_fields;\n state[0] += input[remainder_start];\n if num_extra_fields > 1 {\n state[1] += input[remainder_start + 1]\n }\n }\n } else {\n let mut states: [[Field; 4]; N / RATE + 1] = [[0; 4]; N / RATE + 1];\n states[0] = state;\n\n // process all full RATE-sized chunks, storing state after each permutation\n for chunk_idx in 0..(N / RATE) {\n for i in 0..RATE {\n state[i] += input[chunk_idx * RATE + i];\n }\n state = crate::poseidon2_permutation(state, 4);\n states[chunk_idx + 1] = state;\n }\n\n // get state at the last full block before in_len\n let first_partially_filled_chunk = in_len / RATE;\n state = states[first_partially_filled_chunk];\n\n // handle remaining elements after last full RATE-sized chunk\n let remainder_start = (in_len / RATE) * RATE;\n for j in 0..RATE {\n let idx = remainder_start + j;\n if idx < in_len {\n state[j] += input[idx];\n }\n }\n }\n\n // always run final permutation unless we just completed a full chunk\n // still need to permute once if in_len is 0\n if (in_len == 0) | (in_len % RATE != 0) {\n state = crate::poseidon2_permutation(state, 4)\n };\n\n state[0]\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n"
|
|
2654
|
+
},
|
|
2655
|
+
"312": {
|
|
2656
2656
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/block_header.nr",
|
|
2657
|
-
"source": "use crate::{\n abis::{\n append_only_tree_snapshot::AppendOnlyTreeSnapshot, global_variables::GlobalVariables,\n state_reference::StateReference,\n },\n constants::{BLOCK_HEADER_LENGTH, DOM_SEP__BLOCK_HEADER_HASH, GENESIS_BLOCK_HEADER_HASH},\n hash::poseidon2_hash_with_separator,\n traits::{Deserialize, Empty, Hash, Serialize},\n};\nuse std::meta::derive;\n\n// docs:start:block-header\n#[derive(Deserialize, Eq, Serialize)]\npub struct BlockHeader {\n pub last_archive: AppendOnlyTreeSnapshot,\n pub state: StateReference,\n\n // The hash of the sponge blob for this block, which commits to the tx effects added in this block.\n // Note: it may also include tx effects from previous blocks within the same checkpoint.\n // When proving tx effects from this block only, we must refer to the `sponge_blob_hash` in the previous block\n // header to show that the effect was added after the previous block.\n // The previous block header can be validated using a membership proof of the last leaf in `last_archive`.\n pub sponge_blob_hash: Field,\n\n pub global_variables: GlobalVariables,\n pub total_fees: Field,\n pub total_mana_used: Field,\n}\n// docs:end:block-header\n\nimpl Empty for BlockHeader {\n fn empty() -> Self {\n Self {\n last_archive: AppendOnlyTreeSnapshot::empty(),\n state: StateReference::empty(),\n sponge_blob_hash: 0,\n global_variables: GlobalVariables::empty(),\n total_fees: 0,\n total_mana_used: 0,\n }\n }\n}\n\nimpl Hash for BlockHeader {\n fn hash(self) -> Field {\n poseidon2_hash_with_separator(self.serialize(), DOM_SEP__BLOCK_HEADER_HASH)\n }\n}\n\n#[test]\nfn serialization_of_empty() {\n let header = BlockHeader::empty();\n // We use the BLOCK_HEADER_LENGTH constant to ensure that there is a match\n // between the derived trait implementation and the constant.\n let serialized: [Field; BLOCK_HEADER_LENGTH] = header.serialize();\n let deserialized = BlockHeader::deserialize(serialized);\n assert(header.eq(deserialized));\n}\n\n#[test]\nfn hash_of_genesis_block_header() {\n let mut header = BlockHeader::empty();\n // The following values are taken from world_state.test.cpp > WorldStateTest.GetInitialTreeInfoForAllTrees.\n header.state.l1_to_l2_message_tree.root =\n 0x0d582c10ff8115413aa5b70564fdd2f3cefe1f33a1e43a47bc495081e91e73e5;\n header.state.partial.note_hash_tree.root =\n 0x2ac5dda169f6bb3b9ca09bbac34e14c94d1654597db740153a1288d859a8a30a;\n header.state.partial.nullifier_tree.root =\n 0x1ec3788cd1c32e54d889d67fe29e481114f9d4afe9b44b229aa29d8ad528dd31;\n header.state.partial.nullifier_tree.next_available_leaf_index = 128;\n header.state.partial.public_data_tree.root =\n 0x23c08a6b1297210c5e24c76b9a936250a1ce2721576c26ea797c7ec35f9e46a9;\n header.state.partial.public_data_tree.next_available_leaf_index = 128;\n\n let hash = header.hash();\n assert_eq(hash, GENESIS_BLOCK_HEADER_HASH);\n}\n\n#[test]\nfn hash_of_empty_block_header_match_typescript() {\n let header = BlockHeader::empty();\n let hash = header.hash();\n\n // Value from block_header.test.ts \"computes empty hash\" test\n let test_data_empty_hash = 0x0bdc537052dea0f80db9698585dff9f32063b86b6d4934ac17c30c81e8e416d3;\n assert_eq(hash, test_data_empty_hash);\n}\n"
|
|
2657
|
+
"source": "use crate::{\n abis::{\n append_only_tree_snapshot::AppendOnlyTreeSnapshot, global_variables::GlobalVariables,\n state_reference::StateReference,\n },\n constants::{BLOCK_HEADER_LENGTH, DOM_SEP__BLOCK_HEADER_HASH, GENESIS_BLOCK_HEADER_HASH},\n hash::poseidon2_hash_with_separator,\n traits::{Deserialize, Empty, Hash, Serialize},\n};\nuse std::meta::derive;\n\n// docs:start:block-header\n#[derive(Deserialize, Eq, Serialize)]\npub struct BlockHeader {\n pub last_archive: AppendOnlyTreeSnapshot,\n pub state: StateReference,\n\n // The hash of the sponge blob for this block, which commits to the tx effects added in this block.\n // Note: it may also include tx effects from previous blocks within the same checkpoint.\n // When proving tx effects from this block only, we must refer to the `sponge_blob_hash` in the previous block\n // header to show that the effect was added after the previous block.\n // The previous block header can be validated using a membership proof of the last leaf in `last_archive`.\n pub sponge_blob_hash: Field,\n\n pub global_variables: GlobalVariables,\n pub total_fees: Field,\n pub total_mana_used: Field,\n}\n// docs:end:block-header\n\nimpl BlockHeader {\n pub fn chain_id(self) -> Field {\n self.global_variables.chain_id\n }\n\n pub fn version(self) -> Field {\n self.global_variables.version\n }\n\n pub fn block_number(self) -> u32 {\n self.global_variables.block_number\n }\n\n pub fn timestamp(self) -> u64 {\n self.global_variables.timestamp\n }\n}\n\nimpl Empty for BlockHeader {\n fn empty() -> Self {\n Self {\n last_archive: AppendOnlyTreeSnapshot::empty(),\n state: StateReference::empty(),\n sponge_blob_hash: 0,\n global_variables: GlobalVariables::empty(),\n total_fees: 0,\n total_mana_used: 0,\n }\n }\n}\n\nimpl Hash for BlockHeader {\n fn hash(self) -> Field {\n poseidon2_hash_with_separator(self.serialize(), DOM_SEP__BLOCK_HEADER_HASH)\n }\n}\n\n#[test]\nfn serialization_of_empty() {\n let header = BlockHeader::empty();\n // We use the BLOCK_HEADER_LENGTH constant to ensure that there is a match\n // between the derived trait implementation and the constant.\n let serialized: [Field; BLOCK_HEADER_LENGTH] = header.serialize();\n let deserialized = BlockHeader::deserialize(serialized);\n assert(header.eq(deserialized));\n}\n\n#[test]\nfn hash_of_genesis_block_header() {\n let mut header = BlockHeader::empty();\n // The following values are taken from world_state.test.cpp > WorldStateTest.GetInitialTreeInfoForAllTrees.\n header.state.l1_to_l2_message_tree.root =\n 0x0d582c10ff8115413aa5b70564fdd2f3cefe1f33a1e43a47bc495081e91e73e5;\n header.state.partial.note_hash_tree.root =\n 0x2ac5dda169f6bb3b9ca09bbac34e14c94d1654597db740153a1288d859a8a30a;\n header.state.partial.nullifier_tree.root =\n 0x1ec3788cd1c32e54d889d67fe29e481114f9d4afe9b44b229aa29d8ad528dd31;\n header.state.partial.nullifier_tree.next_available_leaf_index = 128;\n header.state.partial.public_data_tree.root =\n 0x23c08a6b1297210c5e24c76b9a936250a1ce2721576c26ea797c7ec35f9e46a9;\n header.state.partial.public_data_tree.next_available_leaf_index = 128;\n\n let hash = header.hash();\n assert_eq(hash, GENESIS_BLOCK_HEADER_HASH);\n}\n\n#[test]\nfn hash_of_empty_block_header_match_typescript() {\n let header = BlockHeader::empty();\n let hash = header.hash();\n\n // Value from block_header.test.ts \"computes empty hash\" test\n let test_data_empty_hash = 0x0bdc537052dea0f80db9698585dff9f32063b86b6d4934ac17c30c81e8e416d3;\n assert_eq(hash, test_data_empty_hash);\n}\n"
|
|
2658
2658
|
},
|
|
2659
|
-
"
|
|
2659
|
+
"390": {
|
|
2660
2660
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
|
|
2661
2661
|
"source": "mod poseidon2_chunks;\n\nuse crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n transaction::tx_request::TxRequest,\n },\n address::{AztecAddress, EthAddress},\n constants::{\n CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n TWO_POW_64,\n },\n merkle_tree::root_from_sibling_path,\n messaging::l2_to_l1_message::L2ToL1Message,\n poseidon2::Poseidon2Sponge,\n side_effect::{Counted, Scoped},\n traits::{FromField, Hash, ToField},\n utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), note_hash],\n DOM_SEP__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n/// Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n/// before they send it to the network. If a tx makes public function calls, then _revertible_\n/// note_hashes that are created in private will not be made unique in private by the Reset circuit,\n/// but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n/// until the AVM has executed the public functions of the tx. (See an explanation in\n/// reset_output_composer.nr for why).\n/// For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n/// for txs whose public functions create a varying number of non-revertible notes (determined at\n/// runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n/// tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [note_nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n DOM_SEP__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), nullifier],\n DOM_SEP__SILOED_NULLIFIER,\n )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n // can have counter 1 (see `validate_as_first_call` for that assertion).\n Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n NULL_MSG_SENDER_CONTRACT_ADDRESS,\n )\n}\n\npub fn compute_siloed_private_log_first_field(\n contract_address: AztecAddress,\n field: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), field],\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n let mut fields = log.fields;\n fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n master_secret_key: EmbeddedCurveScalar,\n app_address: AztecAddress,\n key_type_domain_separator: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n key_type_domain_separator,\n )\n}\n\npub fn compute_l2_to_l1_message_hash(\n message: Scoped<L2ToL1Message>,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n let mut bytes: [u8; 148] = std::mem::zeroed();\n for i in 0..32 {\n bytes[i] = contract_address_bytes[i];\n bytes[i + 32] = rollup_version_id_bytes[i];\n // 64 - 84 are for recipient.\n bytes[i + 84] = chain_id_bytes[i];\n bytes[i + 116] = content_bytes[i];\n }\n\n for i in 0..20 {\n bytes[64 + i] = recipient_bytes[i];\n }\n\n sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n // Concatenate two fields into 32 x 2 = 64 bytes\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n// This function is unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n inputs: BoundedVec<Field, N>,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs.get(i));\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n let mut values_to_hash = [3; 17];\n let mut padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash the entire values_to_hash.\n let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n let mut values_to_hash = [3; 17];\n let mut padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash up to values_to_hash.len() fields of the padded array.\n let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n let inner_note_hash = 1;\n let contract_address = AztecAddress::from_field(2);\n let first_nullifier = 3;\n let note_index_in_tx = 4;\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n let siloed_note_hash_from_ts =\n 0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n let note_hash_nonce_from_ts =\n 0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n assert_eq(nonce, note_hash_nonce_from_ts);\n\n let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n siloed_note_hash,\n first_nullifier,\n note_index_in_tx,\n );\n assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n let unique_siloed_note_hash_from_ts =\n 0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let nullifier = 456;\n\n let res = compute_siloed_nullifier(contract_address, nullifier);\n\n let siloed_nullifier_from_ts =\n 0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let field = 456;\n let res = compute_siloed_private_log_first_field(contract_address, field);\n\n let siloed_private_log_first_field_from_ts =\n 0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n // All zeroes\n let res = compute_l2_to_l1_message_hash(\n L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n 0,\n )),\n 0,\n 0,\n );\n\n let empty_l2_to_l1_msg_hash_from_ts =\n 0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n AztecAddress::from_field(3),\n );\n let version = 4;\n let chainId = 5;\n\n let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n let l2_to_l1_message_hash_from_ts =\n 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n let separator = 42;\n\n // Hash using bounded vec version\n let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n // Hash using regular version\n let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n // Results should match\n assert_eq(bounded_result, regular_result);\n}\n"
|
|
2662
2662
|
},
|
|
2663
|
-
"
|
|
2663
|
+
"419": {
|
|
2664
2664
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
|
|
2665
2665
|
"source": "use crate::{\n constants::DOM_SEP__PUBLIC_STORAGE_MAP_SLOT, hash::poseidon2_hash_with_separator,\n traits::ToField,\n};\n\n// TODO: Move this to src/public_data/storage/map.nr\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash_with_separator(\n [storage_slot, key.to_field()],\n DOM_SEP__PUBLIC_STORAGE_MAP_SLOT,\n )\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x2d225f361108379adc2da91378b9702675c5546b57e78bafc1e74ec7fec55967;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n"
|
|
2666
2666
|
},
|
|
@@ -2672,23 +2672,23 @@
|
|
|
2672
2672
|
"path": "std/panic.nr",
|
|
2673
2673
|
"source": "pub fn panic<T, U>(message: T) -> U\nwhere\n T: StringLike,\n{\n assert(false, message);\n crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n"
|
|
2674
2674
|
},
|
|
2675
|
-
"
|
|
2675
|
+
"436": {
|
|
2676
2676
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
|
|
2677
2677
|
"source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n let N: u32 = BOOL_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> bool {\n (fields[0] as u1) != 0\n }\n}\n\nimpl Packable for u8 {\n let N: u32 = U8_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n let N: u32 = U16_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n let N: u32 = U32_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n let N: u32 = U64_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n let N: u32 = U128_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n let N: u32 = FIELD_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n let N: u32 = I8_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u8 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u8 as i8\n }\n}\n\nimpl Packable for i16 {\n let N: u32 = I16_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u16 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u16 as i16\n }\n}\n\nimpl Packable for i32 {\n let N: u32 = I32_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u32 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u32 as i32\n }\n}\n\nimpl Packable for i64 {\n let N: u32 = I64_PACKED_LEN;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n [self as u64 as Field]\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n fields[0] as u64 as i64\n }\n}\n\nimpl<T, let M: u32> Packable for [T; M]\nwhere\n T: Packable,\n{\n let N: u32 = M * <T as Packable>::N;\n\n #[inline_always]\n fn pack(self) -> [Field; Self::N] {\n let mut result: [Field; Self::N] = std::mem::zeroed();\n for i in 0..M {\n let serialized = self[i].pack();\n for j in 0..<T as Packable>::N {\n result[i * <T as Packable>::N + j] = serialized[j];\n }\n }\n result\n }\n\n #[inline_always]\n fn unpack(fields: [Field; Self::N]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; M] = std::mem::zeroed();\n reader.read_struct_array::<T, <T as Packable>::N, M>(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n"
|
|
2678
2678
|
},
|
|
2679
|
-
"
|
|
2679
|
+
"449": {
|
|
2680
2680
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
|
|
2681
2681
|
"source": "pub struct Reader<let N: u32> {\n data: [Field; N],\n offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_u64(&mut self) -> u64 {\n self.read() as u64\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() != 0\n }\n\n pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n let mut result = [0; K];\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array<T, let K: u32, let C: u32>(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn peek_offset(&mut self, offset: u32) -> Field {\n self.data[self.offset + offset]\n }\n\n pub fn advance_offset(&mut self, offset: u32) {\n self.offset += offset;\n }\n\n pub fn finish(self) {\n assert_eq(self.offset, self.data.len(), \"Reader did not read all data\");\n }\n}\n"
|
|
2682
2682
|
},
|
|
2683
|
-
"
|
|
2683
|
+
"450": {
|
|
2684
2684
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/serialization.nr",
|
|
2685
2685
|
"source": "use crate::{reader::Reader, writer::Writer};\n\n// docs:start:serialize\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Associated Constants\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize for str<N> {\n/// let N: u32 = N;\n///\n/// fn serialize(self) -> [Field; Self::N] {\n/// let mut writer: Writer<Self::N> = Writer::new();\n/// self.stream_serialize(&mut writer);\n/// writer.finish()\n/// }\n///\n/// fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n/// let bytes = self.as_bytes();\n/// for i in 0..bytes.len() {\n/// writer.write(bytes[i] as Field);\n/// }\n/// }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n let N: u32;\n\n fn serialize(self) -> [Field; Self::N];\n\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>);\n}\n\n/// Generates a `Serialize` trait implementation for a struct type.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A quoted code block containing the trait implementation\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Log<N> {\n/// fields: [Field; N],\n/// length: u32\n/// }\n/// ```\n///\n/// This function generates code equivalent to:\n/// ```\n/// impl<let N: u32> Serialize for Log<N> {\n/// let N: u32 = <[Field; N] as Serialize>::N + <u32 as Serialize>::N;\n///\n/// fn serialize(self) -> [Field; Self::N] {\n/// let mut writer: Writer<Self::N> = Writer::new();\n/// self.stream_serialize(&mut writer);\n/// writer.finish()\n/// }\n///\n/// #[inline_always]\n/// fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n/// Serialize::stream_serialize(self.fields, writer);\n/// Serialize::stream_serialize(self.length, writer);\n/// }\n/// }\n/// ```\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let nested_struct = typ.as_data_type().unwrap();\n\n // We care only about the name and type so we drop the last item of the tuple\n let params = nested_struct.0.fields(nested_struct.1).map(|(name, typ, _)| (name, typ));\n\n // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n // for the `Serialize` trait.\n let generics_declarations = get_generics_declarations(s);\n let where_serialize_clause = get_where_trait_clause(s, quote {Serialize});\n\n let params_len_quote = get_params_len_quote(params);\n\n let function_body = params\n .map(|(name, _typ): (Quoted, Type)| {\n quote {\n $crate::serialization::Serialize::stream_serialize(self.$name, writer);\n }\n })\n .join(quote {});\n\n quote {\n impl$generics_declarations $crate::serialization::Serialize for $typ\n $where_serialize_clause\n {\n let N: u32 = $params_len_quote;\n\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n $crate::serialization::Serialize::stream_serialize(self, &mut writer);\n writer.finish()\n }\n\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n $function_body\n }\n }\n }\n}\n\n// docs:start:deserialize\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Associated Constants\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let M: u32> Deserialize for str<M> {\n/// let N: u32 = M;\n///\n/// fn deserialize(fields: [Field; Self::N]) -> Self {\n/// let mut reader = Reader::new(fields);\n/// let result = Self::stream_deserialize(&mut reader);\n/// reader.finish();\n/// result\n/// }\n///\n/// fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n/// let mut bytes = [0 as u8; M];\n/// for i in 0..M {\n/// bytes[i] = reader.read() as u8;\n/// }\n/// str::<M>::from(bytes)\n/// }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n let N: u32;\n\n fn deserialize(fields: [Field; Self::N]) -> Self;\n\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self;\n}\n\n/// Generates a `Deserialize` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Deserialize` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n/// x: AztecAddress,\n/// y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Deserialize for MyStruct {\n/// let N: u32 = <AztecAddress as Deserialize>::N + <Field as Deserialize>::N;\n///\n/// fn deserialize(fields: [Field; Self::N]) -> Self {\n/// let mut reader = Reader::new(fields);\n/// let result = Self::stream_deserialize(&mut reader);\n/// reader.finish();\n/// result\n/// }\n///\n/// #[inline_always]\n/// fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n/// let x = <AztecAddress as Deserialize>::stream_deserialize(reader);\n/// let y = <Field as Deserialize>::stream_deserialize(reader);\n/// Self { x, y }\n/// }\n/// }\n/// ```\npub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n\n // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n // for the `Deserialize` trait.\n let generics_declarations = get_generics_declarations(s);\n let where_deserialize_clause = get_where_trait_clause(s, quote {Deserialize});\n\n // The following will give us:\n // <type_of_struct_member_1 as Deserialize>::N + <type_of_struct_member_2 as Deserialize>::N + ...\n // (or 0 if the struct has no members)\n let right_hand_side_of_definition_of_n = if params.len() > 0 {\n params\n .map(|(_, param_type, _): (Quoted, Type, Quoted)| {\n quote {\n <$param_type as $crate::serialization::Deserialize>::N\n }\n })\n .join(quote {+})\n } else {\n quote {0}\n };\n\n // For structs containing a single member, we can enhance performance by directly deserializing the input array,\n // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n // expected to be optimized away.\n let function_body = if params.len() > 1 {\n // This generates deserialization code for each struct member and concatenates them together.\n let deserialization_of_struct_members = params\n .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n quote {\n let $param_name = <$param_type as Deserialize>::stream_deserialize(reader);\n }\n })\n .join(quote {});\n\n // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n // This will give us e.g. `a, b, c` for a struct with three fields named `a`, `b`, and `c`.\n let struct_members = params\n .map(|(param_name, _, _): (Quoted, Type, Quoted)| quote { $param_name })\n .join(quote {,});\n\n quote {\n $deserialization_of_struct_members\n\n Self { $struct_members }\n }\n } else if params.len() == 1 {\n let param_name = params[0].0;\n quote {\n Self { $param_name: $crate::serialization::Deserialize::stream_deserialize(reader) }\n }\n } else {\n quote {\n Self {}\n }\n };\n\n quote {\n impl$generics_declarations $crate::serialization::Deserialize for $typ\n $where_deserialize_clause\n {\n let N: u32 = $right_hand_side_of_definition_of_n;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = $crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n $function_body\n }\n }\n }\n}\n\n/// Generates a quoted expression that computes the total serialized length of function parameters.\n///\n/// # Parameters\n/// * `params` - An array of tuples where each tuple contains a quoted parameter name and its Type. The type needs\n/// to implement the Serialize trait.\n///\n/// # Returns\n/// A quoted expression that evaluates to:\n/// * `0` if there are no parameters\n/// * `(<type1 as Serialize>::N + <type2 as Serialize>::N + ...)` for one or more parameters\ncomptime fn get_params_len_quote(params: [(Quoted, Type)]) -> Quoted {\n if params.len() == 0 {\n quote { 0 }\n } else {\n let params_quote_without_parentheses = params\n .map(|(_, param_type): (Quoted, Type)| {\n quote {\n <$param_type as $crate::serialization::Serialize>::N\n }\n })\n .join(quote {+});\n quote { ($params_quote_without_parentheses) }\n }\n}\n\ncomptime fn get_generics_declarations(s: TypeDefinition) -> Quoted {\n let generics = s.generics();\n\n if generics.len() > 0 {\n let generics_declarations_items = generics\n .map(|(name, maybe_integer_typ)| {\n // The second item in the generics tuple is an Option of an integer type that is Some only if\n // the generic is numeric.\n if maybe_integer_typ.is_some() {\n // The generic is numeric, so we return a quote defined as e.g. \"let N: u32\"\n let integer_type = maybe_integer_typ.unwrap();\n quote {let $name: $integer_type}\n } else {\n // The generic is not numeric, so we return a quote containing the name of the generic (e.g. \"T\")\n quote {$name}\n }\n })\n .join(quote {,});\n quote {<$generics_declarations_items>}\n } else {\n // The struct doesn't have any generics defined, so we just return an empty quote.\n quote {}\n }\n}\n\ncomptime fn get_where_trait_clause(s: TypeDefinition, trait_name: Quoted) -> Quoted {\n let generics = s.generics();\n\n // The second item in the generics tuple is an Option of an integer type that is Some only if the generic is\n // numeric.\n let non_numeric_generics =\n generics.filter(|(_, maybe_integer_typ)| maybe_integer_typ.is_none());\n\n if non_numeric_generics.len() > 0 {\n let non_numeric_generics_declarations =\n non_numeric_generics.map(|(name, _)| quote {$name: $trait_name}).join(quote {,});\n quote {where $non_numeric_generics_declarations}\n } else {\n // There are no non-numeric generics, so we return an empty quote.\n quote {}\n }\n}\n"
|
|
2686
2686
|
},
|
|
2687
|
-
"
|
|
2687
|
+
"452": {
|
|
2688
2688
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
|
|
2689
2689
|
"source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal U1_SERIALIZED_LEN: u32 = 1;\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> bool {\n reader.read() != 0\n }\n}\n\nimpl Serialize for u1 {\n let N: u32 = U1_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u1 {\n let N: u32 = U1_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u1\n }\n}\n\nimpl Serialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8\n }\n}\n\nimpl Serialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16\n }\n}\n\nimpl Serialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32\n }\n}\n\nimpl Serialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64\n }\n}\n\nimpl Serialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u128\n }\n}\n\nimpl Serialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self);\n }\n}\n\nimpl Deserialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read()\n }\n}\n\nimpl Serialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u8 as Field);\n }\n}\n\nimpl Deserialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8 as i8\n }\n}\n\nimpl Serialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u16 as Field);\n }\n}\n\nimpl Deserialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16 as i16\n }\n}\n\nimpl Serialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u32 as Field);\n }\n}\n\nimpl Deserialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32 as i32\n }\n}\n\nimpl Serialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u64 as Field);\n }\n}\n\nimpl Deserialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64 as i64\n }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n for i in 0..M {\n self[i].stream_serialize(writer);\n }\n }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut result: [T; M] = std::mem::zeroed();\n for i in 0..M {\n result[i] = T::stream_deserialize(reader);\n }\n result\n }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N + 1;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write_bool(self.is_some());\n if self.is_some() {\n self.unwrap_unchecked().stream_serialize(writer);\n } else {\n writer.advance_offset(<T as Serialize>::N);\n }\n }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n if reader.read_bool() {\n Option::some(<T as Deserialize>::stream_deserialize(reader))\n } else {\n reader.advance_offset(<T as Deserialize>::N);\n Option::none()\n }\n }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n let N: u32 = SCALAR_SIZE;\n\n fn serialize(self) -> [Field; SCALAR_SIZE] {\n [self.lo, self.hi]\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.lo);\n writer.write(self.hi);\n }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n let N: u32 = SCALAR_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { lo: fields[0], hi: fields[1] }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { lo: reader.read(), hi: reader.read() }\n }\n}\n\nglobal POINT_SIZE: u32 = 3;\n\nimpl Serialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn serialize(self) -> [Field; Self::N] {\n [self.x, self.y, self.is_infinite as Field]\n }\n\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.x);\n writer.write(self.y);\n writer.write(self.is_infinite as Field);\n }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { x: fields[0], y: fields[1], is_infinite: fields[2] != 0 }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { x: reader.read(), y: reader.read(), is_infinite: reader.read_bool() }\n }\n}\n\nimpl<let M: u32> Deserialize for str<M> {\n let N: u32 = M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n str::<Self::N>::from(u8_arr)\n }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n let N: u32 = M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.as_bytes().stream_serialize(writer);\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n let payload_len = Self::N - 1;\n\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n let len = reader.peek_offset(payload_len) as u32;\n\n for i in 0..M {\n if i < len {\n new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n }\n }\n\n // +1 for the length of the BoundedVec\n reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n new_bounded_vec\n }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n let N: u32 = 0;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(_reader: &mut Reader<K>) -> Self {\n ()\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.storage().stream_serialize(writer);\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n writer.write_u32(self.len() as u32);\n }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n let mut slice = @[];\n for i in 0..length {\n slice = slice.push_back(f(i));\n }\n slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n // `T0`, `T1`, `T2`\n let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n // `result0`, `result1`, `result2`\n let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n // `T0, T1, T2`\n let field_generics = type_names.join(quote [,]);\n\n // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n let full_size_serialize = type_names\n .map(|type_name| quote {\n <$type_name as Serialize>::N\n })\n .join(quote [+]);\n\n // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n let full_size_deserialize = type_names\n .map(|type_name| quote {\n <$type_name as Deserialize>::N\n })\n .join(quote [+]);\n\n // `T0: Serialize, T1: Serialize, T2: Serialize,`\n let serialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Serialize,\n })\n .join(quote []);\n\n // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n let deserialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Deserialize,\n })\n .join(quote []);\n\n // Statements to serialize each field\n let serialized_fields = type_names\n .mapi(|i, _type_name| quote {\n $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n })\n .join(quote []);\n\n // Statements to deserialize each field\n let deserialized_fields = type_names\n .mapi(|i, type_name| {\n let result_name = result_names[i];\n quote {\n let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n }\n })\n .join(quote []);\n let deserialize_results = result_names.join(quote [,]);\n\n quote {\n impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n let N: u32 = $full_size_serialize;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n\n $serialized_fields\n }\n }\n\n impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n let N: u32 = $full_size_deserialize;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = $crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n \n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n $deserialized_fields\n ($deserialize_results)\n }\n }\n }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n T1: Serialize,\n{\n let N: u32 = <T1 as Serialize>::N;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: crate::writer::Writer<Self::N> = crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.0.stream_serialize(writer);\n }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n T1: Deserialize,\n{\n let N: u32 = <T1 as Deserialize>::N;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n (<T1 as Deserialize>::stream_deserialize(reader),)\n }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n use crate::serialization::{Deserialize, Serialize};\n}\n"
|
|
2690
2690
|
},
|
|
2691
|
-
"
|
|
2691
|
+
"453": {
|
|
2692
2692
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/writer.nr",
|
|
2693
2693
|
"source": "pub struct Writer<let N: u32> {\n data: [Field; N],\n offset: u32,\n}\n\nimpl<let N: u32> Writer<N> {\n pub fn new() -> Self {\n Self { data: [0; N], offset: 0 }\n }\n\n pub fn write(&mut self, value: Field) {\n self.data[self.offset] = value;\n self.offset += 1;\n }\n\n pub fn write_u32(&mut self, value: u32) {\n self.write(value as Field);\n }\n\n pub fn write_u64(&mut self, value: u64) {\n self.write(value as Field);\n }\n\n pub fn write_bool(&mut self, value: bool) {\n self.write(value as Field);\n }\n\n pub fn write_array<let K: u32>(&mut self, value: [Field; K]) {\n for i in 0..K {\n self.data[i + self.offset] = value[i];\n }\n self.offset += K;\n }\n\n pub fn write_struct<T, let K: u32>(&mut self, value: T, serialize: fn(T) -> [Field; K]) {\n self.write_array(serialize(value));\n }\n\n pub fn write_struct_array<T, let K: u32, let C: u32>(\n &mut self,\n value: [T; C],\n serialize: fn(T) -> [Field; K],\n ) {\n for i in 0..C {\n self.write_struct(value[i], serialize);\n }\n }\n\n pub fn advance_offset(&mut self, offset: u32) {\n self.offset += offset;\n }\n\n pub fn finish(self) -> [Field; N] {\n assert_eq(self.offset, self.data.len(), \"Writer did not write all data\");\n self.data\n }\n}\n"
|
|
2694
2694
|
},
|