npm - @aztec/protocol-contracts - Versions diffs - 3.0.0-nightly.20251213 → 3.0.0-nightly.20251216 - Mend

@aztec/protocol-contracts 3.0.0-nightly.20251213 → 3.0.0-nightly.20251216

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.

Files changed (8) hide show

package/artifacts/AuthRegistry.json +10 -14
package/artifacts/ContractClassRegistry.json +1 -1
package/artifacts/ContractInstanceRegistry.json +5 -5
package/artifacts/FeeJuice.json +10 -14
package/artifacts/Router.json +4 -4
package/dest/protocol_contract_data.js +5 -5
package/package.json +4 -4
package/src/protocol_contract_data.ts +5 -5

package/artifacts/ContractInstanceRegistry.json CHANGED Viewed

@@ -36,7 +36,7 @@
         }
       },
       "bytecode": "JwACBAEoAAABBIBGJwAABEYnAgEEACcCAgQAHwoAAQACAEUlAAAAQSUAAABsLQIBRScCAgRFJwIDBAE7DgADAAIsAABDADBkTnLhMaApuFBFtoGBWF0oM+hIeblwkUPh9ZPwAAAAJwBEBAMmJQAAA/QeAgACAB4CAAMAHgIABAknAgUBASQCAAQAAACSJQAABBoeAgAEAQoiBEMGFgoGBxwKBwgABCoIBAcnAgQBAAoqBgQIJAIACAAAAMUnAgkEADwGCQEnAgYAACsCAAgAAAAAAAAAAAIAAAAAAAAAAC0IAQknAgoEBQAIAQoBJwMJBAEAIgkCCi0KCgstDgYLACILAgstDgYLACILAgstDgYLACILAgstDggLLQgBCAAAAQIBLQgBCgAAAQIBLQgBCwAAAQIBLQgBDAAAAQIBJwINAAEtCAEOJwIPBAQACAEPAScDDgQBACIOAg8tCg8QLQ4NEAAiEAIQLQ4HEAAiEAIQLQ4GEC0ODggtDgkKJwIHBAItDgcLLQ4EDCcCBwQAJwIJBAEtCgcBIwAAAZ0MIgFEAiQCAAIAAANuIwAAAa8tCwoCLQsCAwAiAwIDLQ4DAi0IAQMnAgcEBQAIAQcBJwMDBAEAIgICBycCDQQEACIDAg4/DwAHAA4tCwgCLQsLBy0OAggtDgMKLQ4HCy0OBQwAKgMJBS0LBQIKKgIGAwoqAwQFJAIABQAAAiAlAAAELB4CAAMGLwoAAgAEHAoEBQQcCgUCAAIqBAIFLAIAAgAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBQIEHAoEBgQcCgYFAAIqBAUGBCoGAgQcCgQHARwKBwYAHAoGBwECKgQGCCwCAAQAMDPqJG5QbomOl/Vwyv/XBMsLtGAxP7cgsp4TnlwQAAEEKggECRwKCQoEHAoKCAACKgkICgQqCgIJHAoJCgEcCgoCABwKAgoBAioJAgsEKgsECRwKCQsEHAoLBAAcCgQJBRYKCgQcCgIKBRwKBAIFBCoKCQQcCggJBRYKBwgcCgYHBRwKCAYFBCoHCQgcCgUJBQwqAwkFKQIAAwUAAVGAJAIABQAAA1UjAAADPQQqBwgCBCoGAwQAKgIEAy0KAwEjAAADbQQqCgQFBCoCAwQAKgUEAi0KAgEjAAADbSYtCwsCDCoBAgMkAgADAAADhCMAAAPmLQsKAwAiAwINACoNAQ4tCw4HLQsIDQAiDQIPACoPARAtCxAOACoHDg8tCwwHLQIDAycABAQFJQAABD4tCAUOACIOAhAAKhABES0ODxEtDg0ILQ4OCi0OAgstDgcMIwAAA+YAKgEJAi0KAgEjAAABnSgAAAQEeEYMAAAEAyQAAAMAAAQZKgEAAQXaxfXWtEoybTwEAgEmKgEAAQVP30qK18/w0zwEAgEmKgEAAQW6uyHXgjMYZDwEAgEmLQEDBgoABgIHJAAABwAABFQjAAAEXS0AAwUjAAAEnC0AAQUAAAEEAQAAAwQJLQADCi0ABQsKAAoJDCQAAAwAAASXLQEKCC0ECAsAAAoCCgAACwILIwAABHMnAQUEASY=",
-      "debug_symbols": "tZnRbts6DIbfJde5kERRJPsqwzBkXTYECNIiaw9wUPTdD2mLstNCQuud3TSf6fgPSVGk0rzsfhy/P//6drr8fPi9u/vysvt+PZ3Pp1/fzg/3h6fTw0WtL7tgf2KE3R3s9ZV3d6SvSa9jMFBDjAoAFXJ0KAqogGaxp7BUKKHeKliBzCIGWIHdwlxBwIF2d6nsdymkCubPDH4L/Ba4Jbslu8UcmwErmGMzZAepQP4RxBXYBNGgVJDogDNACA7ZQSpYTmcwQVaYopiAKkxRTOCW7JbslimKCbDCFMUE2UEqTFGIAVXg6FAqSJghT6ueFEDfA2CADlIhZweNAjScjMmBKhS3FLeQW8gt7BZbbsgKkhzUMdCKQkvmDNmBK0R7czGgCsl8ZoNSAdwyOW9gzudkoJaslYmWw6yxo+VwBrWgljpaiaJ+VglUwT4UkwFVSGYBA7Oo88VWENGAKmS32AqiulosY6ifXlgqiDqGbCAzkIWMYqCWov5QVEuJBlIhuSWZRf0hMAsYmEX9IQt5BrOoG4T+FHK1FHBwi5VNKQY8O0+2XpOFqYK4xbZn0SjYtmdRn9meskJie4rUebGlnKHWj4RaURLdYvtiAssqRQOqAG4BXVxSZbG2M0MtUckuiC6IbrEAZ/CPILdMBWnA0cEF2R+X6anX1/3OW+W3p+vxaJ1y1Tu1oz4ersfL0+7u8nw+73f/HM7P05t+Px4u0+vT4ap3NQ3Hyw99VcGfp/PR6HW/PB36jyZgqU+nHKQJxIg3ErEvoY22cNVQJmoidOtG6muAdlCsGsoUexqjUDi6G0lS7IaSBxI5Ymjp0JmyuAE3Gvg/pKP83XQAWn3PEijcTQcP0iEALR0CufTckIEbOoKaHwA5/2EoJYRuKAMJbW25SlDCpc4x3pb5oEYT5lg8G9r5S684IgyqQ2ipDu0V3ZTGPCoPnROtPHQwdEXG4ZTYwsEI3XBGhZq9THNMSyzblqVwd1kGRUo2nmaFVTZz+rgLMTQXMvRcSAMJPSp4JvWwsOo8cutFGnVRbLUVUlOAQrcKgwWlpbKIdWc0DZBbDRjttNTWc0lmwjeNfNRCo7SqSquB8k5j0EJRqEqUVRyf8iItYw1W+XynQaMVSV4YETNt1CjSNFi2xUJL2yEIXQ0YVGjUA5j7oeesvsagQil7bVAumxSkdQtB3qQQQ2t8MZR+bcAgn5lja1qMabVbP55OPWy2Jp4G5TVqGrFgaxqUuk0DRuWl5+F21JDV6U3ipvbH3cEIoxHPxQsUmLnrRR4d3lCkHTV0xndPPDmO5qLgMhdlfXwLH49Gv1q4xnpt30UzaKOIoQ0EXM3FdxqjIR8EfDYqI3YzgiORlLmJJO6eFPJoyGNZPMFS+iLDlLQTLd4cR9+mZHQezcuQzEVWE+4zGst8QkhbNcJyECzbNLBtXa39jX6U0PJRVifrT2pg01h15c9pcPvmVYS2aVCkNuUyb9VYJuXqHPY5jSUWko1+cGxryzlu1Wh1yogbNTg3DYFtGhKhfQXMmzVaPgQ37hdZ9ots3C/6XWn5Vs3bcgo5eD70X6nb9pz+x7WNGMyhq/HhMQX9EVN4dIyRVh8B1rWeP36mC75tJW08FRZfWCH803PlW4Wvenm4P11vfpN4Nanr6fD9fKyXP58v96u7T/8++h3/TePx+nB//PF8PZrS8sOG/vkShfcp0lf9YWG65LLXVbDLON1FvaSvr+bMfw=="
+      "debug_symbols": "tZndTiM7DMffpddc5MOObV5ltVp1oawqVQV14UhHiHc/9kycmYISwezZG/qrh/nXdhw7077u7g8/X379OJ4fHn/vbr+97n5ejqfT8deP0+Pd/vn4eFbr6y7Ynxjz7jbf6Cvvbklfk76PwUANMSrkXAGiQ1FABTSL3YWlQgn1UsEKZBYxwArsFuYKkh1od5vKzS6FVMH8mcEvZb+U3QJuAbeYYzNgBXNsBnCQCuQfQVyBTRANSgWJDjhDDsEBHKSC5XQGE2SFKYoJqMIUxQRuAbeAW6YoJsAKUxQTgINUmKIQA6rA0aFUkDADTKueFLL+T84G6CAVABw0iqzhACYHqlDcUtxCbiG3sFtsuTMoSHJQx7JWFFoyZwAHrhDtn4sBVUjmMxuUCtktk/MG5jwkA7WAViZaDkFjR8vhDGpBLXW0EkX9rBKogn0oJgOqkMySDcyizhdbQUQDqgBusRVEdbVYxlA/vbBUEHUM2UBmIAsZxUAtRf2hqJYSDaRCcksyi/pD2SzZwCzqD1nIM5hF3SD0u5CrpWQHt1jZlGLAs/Nk6zVZmCqIW2x7Fo2CbXsW9ZntLisktrtInRdbyhlq/UioFSXRLbYvJrCsUjSgCtktWReXVFms7cxQS1TABdEF0S0W4Az+EeSWqSANODq4IPvtMt319naz81b54/lyOFinXPVO7ahP+8vh/Ly7Pb+cTje7f/anl+mffj/tz9Pr8/6iVzUNh/O9vqrgw/F0MHq7We4O/VtTZql3JwjSBGLEK4nYl9BGW7hqKBM1Ebp2I/U1snZQrBrKFHsao1A4uhtJUuyGAgOJxNI0tBnz4ka+0sD/IR3l76Yjo9X3LIHC3XTwIB2Sc2gpzVB6bsjADR1BzY+cAf4wlBJCN5SBhLY2qBKUcKlzjNdlPqjRBLFA2ytRoFccMQ+qQ2ipDu0V3ZRGGJWHzolWHjoYuiLDcFJYtn4qsRvOqFDByxRiWmLZtiyFu8syKFKy8TQrrLIJ6fMuxNBcgNxzIQ0k9Kjg9YnrREa59iKNuqgN8nkxQmoKudC1wmBBaaksYt0ZTSPLtUYe7bTU1nNJZsJ3jXzUQqPE1kFXA+WDxqCFolCVKKs4vuRFWsZaXuXzgwaNViR5YUQE2qhRpGmwbIuFYisNyqGrkQcVGvUA5n7oOauvMahQAq8NgrJJQVq3EORNCjG0xhdD6ddGHuQTOLamxZhWu/Xz6ZTWOnWPD8pr1DRiwdY0KHWbRh6Vl56H21FDVqc3iZvaH3cHYx6NeC5eoJmZu17A6PCGIu2ooTO+e+KBOJqLgstcFAo9kWE0+mjhGuu1/RDNoI0ihjYQcDUXP2iMhnyQ7LNRGbGbERyJJOAmkrh7UoDRkMeyeIKl9EWGKWknWrw6jr5Pyeg8CsuQhCKrCfcVjWU+YU5bNVqt4qoXfkkD29bV2t/oRwktH2V1sv6iBjaNVVf+mga3p6YitE2DIrUpB7xVY5mUq3PY1zSWWEg2+sGxrS1D3KrR6pQRN2pwe2Bhyds0JOb2CAibNVo+BDfuF1n2i2zcL/qstDxV87acZgieD/0qddue029c24hBCF2NT4+p3B8xhUfHGGn1EfK61uHzZ7rg21bSxlNh8YUVwj89V75X+K5v93fHy9VvEm8mdTnuf54O9e3Dy/ludfX53ye/4r9pPF0e7w73L5eDKS0/bOifb1G/M0qRvusPC9NbLje6CvY2TldR39L3N3PmPw=="
     },
     {
       "name": "publish_for_public_execution",
@@ -2074,7 +2074,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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"
+      "debug_symbols": "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"
     },
     {
       "name": "update",
@@ -2134,7 +2134,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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"
+      "debug_symbols": "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"
     },
     {
       "name": "process_message",
@@ -2453,7 +2453,7 @@
         }
       },
       "bytecode": "JwACBAEoAAABBIBSJwAABFInAgIEAScCAwQAHwoAAgADAFEtCFEBJQAAAEElAAAA2icCAQRSJwICBAA7DgACAAEnAEMAAywAAEQAAAAAAA6S+filNOhY/Pd32iBuCLDGIOz53rIdE0eYE/YoAABFBQJYLAAARgAwZE5y4TGgKbhQRbaBgVhdKDPoSHm5cJFD4fWT8AAAACcARwQDJwBIAQAnAEkEACcASgAAJwBLAQEnAEwEAScATQABJwBOBAInAE8AMSsAAFAAAAAAAAAAAAEAAAAAAAAAACYlAAAMTykCAAIA+pECywoqAQIDJwIEBAAnAgYEAwAqBAYFLQgBAgAIAQUBJwMCBAEAIgICBS0OBAUAIgUCBS0OBAUnAgUEAwAqAgUEJAIAAwAAATMjAAAFMS0IAQMnAgQEAgAIAQQBJwMDBAEAIgMCBB8wAEwATAAELQgBBAAAAQIBLQ4DBC0IAQMAAAECAS0MSQMnAgYEBy0IAActCgQILQoDCQAIAAYAJQAADHUtAgAALQoIBQAiBUwELQsEAx4CAAQAHgIABQAeAgAGAQoiBkYHFgoHCBwKCAkABCoJBggKIgdIBiQCAAYAAAHRJwIJBAA8BgkBMyoACAAFAAYkAgAGAAAB5iUAAAzKMyIAAwBDAAUkAgAFAAAB+yUAAAzcLQgBBScCBgQDAAgBBgEnAwUEAQAiBQIGLQoGBy0MTQcAIgcCBy0OCAcnAgcECS0IAAktCgUKLQhOCy0ISAwACAAHACUAAAzuLQIAAC0KCgYKIgZKBQoiBUgHJAIABwAAAmIlAAAOgCcCBwQJLQgACS0KBgoACAAHACUAAA6SLQIAAC0KCgUtCAEHAAABAgEtDgUHLQgBBQAAAQIBLQxJBS0IAQknAgoEBAAIAQoBJwMJBAEAIgkCCi0KCgstDEoLACILAgstDEoLACILAgstDEoLJwILBAwtCAAMLQoHDS0KBQ4tCE8PLQoJEAAIAAsAJQAADzwtAgAALQoNCicCCwQMLQgADC0KCg0ACAALACUAABAqLQIAAC0KDQUtCg4HLQoPCS8KAAYACicCEAQRLQgAES0KChIACAAQACUAABCALQIAAC0KEgstChMMLQoUDS0KFQ4tChYPHgIACgYnAhEEEi0IABItCgsTLQoMFC0KDRUtCg4WLQoPFy0KChgACAARACUAABF7LQIAAC0KExAAKgoQEQ4qChESJAIAEgAAA6MlAAAR7AwqCgkQFgoQCRwKEAoAHAoJEAAEKgoFCQQqEAcFACoJBQcnAgkEEi0IABItCgcTLQoDFC0KERUtCgsWLQoMFy0KDRgtCg4ZLQoPGgAIAAkAJQAAEf4tAgAALQoTBS0LBQkAIgkCCS0OCQUnAgoEEi0IABItCgUTLQhHFC0ISBUACAAKACUAABNXLQIAAC0KEwknAgsEEi0IABItCgUTLQoJFAAIAAsAJQAAFOktAgAALQoTCicCBQQSLQgAEi0KBhMtCgoUAAgABQAlAAAVRS0CAAAcChEFACcCCQQFJwILBAMAKgkLCi0IAQYACAEKAScDBgQBACIGAgotDgkKACIKAgotDgkKJwIKBAMAKgYKCS0KCQotDEQKACIKAgotDggKACIKAgotDgcKACIKAgotDgMKACIKAgotDgUKJwIDBAUAIgYCCC0LCAgtCggHJwIJBAMAKgYJBTcOAAcABS0LAgMAIgMCAy0OAwIAIgICBi0LBgYtCgYFJwIHBAMAKgIHAzsOAAUAAyMAAAUxKQIAAwDAe14ZCioBAwQkAgAEAAAFTCMAAAjtLQgBBCcCBQQCAAgBBQEnAwQEAQAiBAIFHzAATABMAAUtCAEFAAABAgEtDgQFLQgBBAAAAQIBLQxJBCcCBwQILQgACC0KBQktCgQKAAgABwAlAAAMdS0CAAAtCgkGACIGTAUtCwUEHAoEBgUcCgYFABwKBQQFHgIABQAeAgAGAB4CAAcBCiIHRggWCggJHAoJCgAEKgoHCQoiCEgHJAIABwAABfknAgoEADwGCgEzKgAJAAYAByQCAAcAAAYOJQAADMoMIgRFBgoiBkgHJAIABwAABiUlAAAVly0IAQYnAgcEAwAIAQcBJwMGBAEAIgYCBy0KBwgtDE0IACIIAggtDgkIJwIIBAktCAAJLQoGCi0ITgstCEgMAAgACAAlAAAM7i0CAAAtCgoHCiIHSgYKIgZICCQCAAgAAAaMJQAADoAvCgAHAAYnAg0EDi0IAA4tCgYPAAgADQAlAAAQgC0CAAAtCg8ILQoQCS0KEQotChILLQoTDB4CAAYGJwIOBA8tCAAPLQoIEC0KCREtCgoSLQoLEy0KDBQtCgYVAAgADgAlAAARey0CAAAtChANDCoNBAgkAgAIAAAHKyMAAAcLAioNBAUOKgQNCCQCAAgAAAciJQAAFaktCgUDIwAABzknAgUFAC0KBQMjAAAHOQAqBgMFDioGBQgkAgAIAAAHUCUAABHsJwIGBA4tCAAOLQoHDwAIAAYAJQAADpItAgAALQoPAy0IAQYAAAECAS0OAwYtCAEDAAABAgEtDEkDLQgBCCcCCQQEAAgBCQEnAwgEAQAiCAIJLQoJCi0MSgoAIgoCCi0MSgoAIgoCCi0MSgonAgoEDi0IAA4tCgYPLQoDEC0ITxEtCggSAAgACgAlAAAPPC0CAAAtCg8JJwIKBA4tCAAOLQoJDwAIAAoAJQAAECotAgAALQoPAy0KEAYtChEIJwIKBA4tCAAOLQoDDy0KBhAtCggRLQhLEi0KDRMtCEsULQoEFS0KBRYACAAKACUAABH+LQIAAC0KDwktCwkDACIDAgMtDgMJJwIEBAotCAAKLQoJCy0IRwwtCEgNAAgABAAlAAATVy0CAAAtCgsDJwIFBAotCAAKLQoJCy0KAwwACAAFACUAABTpLQIAAC0KCwQnAgMECC0IAAgtCgcJLQoECgAIAAMAJQAAFUUtAgAALQsCAwAiAwIDLQ4DAgAiAgIFLQsFBS0KBQQnAgYEAwAqAgYDOw4ABAADIwAACO0pAgACAAVVe/oKKgECAyQCAAMAAAkIIwAACo4eAgACAB4CAAMAHgIABAkkAgAEAAAJJCUAABW7HgIABAEKIgRGBRYKBQYcCgYHAAQqBwQGCiIFSAQkAgAEAAAJUicCBwQAPAYHAS0IAQQnAgUEAwAIAQUBJwMEBAEAIgQCBS0KBQctDE0HACIHAgctDgYHJwIGBActCAAHLQoECC0ITgktCEgKAAgABgAlAAAM7i0CAAAtCggFCiIFSgQKIgRIBiQCAAYAAAm5JQAADoAeAgAEBi8KAAUABicCCwQMLQgADC0KBg0ACAALACUAABCALQIAAC0KDQUtCg4HLQoPCC0KEAktChEKJwILBAwtCAAMLQoFDS0KBw4tCggPLQoJEC0KChEtCgQSAAgACwAlAAARey0CAAAtCg0GHAoGBAAnAgYEAScCCAQDACoGCActCAEFAAgBBwEnAwUEAQAiBQIHLQ4GBwAiBwIHLQ4GBycCBwQDACoFBwYtCgYHLQ4EBwAiBQIHLQsHBy0KBwYnAggEAwAqBQgEOw4ABgAEIwAACo4nAgICVScCAwJuJwIEAmsnAgUCbycCBgJ3JwIHAiAnAggCcycCCQJlJwIKAmwnAgsCYycCDAJ0JwINAnInAg4CeycCDwJ9LQgBECcCEQQcAAgBEQEnAxAEAQAiEAIRLQoREi0OAhIAIhICEi0OAxIAIhICEi0OBBIAIhICEi0OAxIAIhICEi0OBRIAIhICEi0OBhIAIhICEi0OAxIAIhICEi0OBxIAIhICEi0OCBIAIhICEi0OCRIAIhICEi0OChIAIhICEi0OCRIAIhICEi0OCxIAIhICEi0ODBIAIhICEi0OBRIAIhICEi0ODRIAIhICEi0OBxIAIhICEi0ODhIAIhICEi0OCBIAIhICEi0OCRIAIhICEi0OChIAIhICEi0OCRIAIhICEi0OCxIAIhICEi0ODBIAIhICEi0OBRIAIhICEi0ODRIAIhICEi0ODxIKIEhLAiQCAAIAAAxPJwIDBB4tCAEEJwIFBB4ACAEFAS0KBAUqAwAFBelJQ+ibN90sACIFAgUAIhACBicCBwQbLQIGAy0CBQQtAgcFJQAAFc0nAgYEGwAqBQYFLQxNBQAiBQIFLQ4BBQAiBQIFPA4DBCgAAAQEeFIMAAAEAyQAAAMAAAx0KgEAAQXaxfXWtEoybTwEAgEmJQAADE8tCwIDLQsBBAoiA0kFJAIABQAADJQlAAAV/wAiBEwFLQsFAy0IAQUnAgYEAgAIAQYBJwMFBAEAIgUCBi0KBgctDgMHLQ4EAS0MTAItCgUBJioBAAEF1RJ9KcLS6O08BAIBJioBAAEFrpKPa6mOkow8BAIBJiUAAAxPHAoCBQAEIgVQBi0IAQUnAgcEBAAIAQcBJwMFBAEAIgUCBy0KBwgtDEoIACIIAggtDEoIACIIAggtDEoILQgBBycCCAQFAAgBCAEnAwcEAQAiBwIILQoICS0MSgkAIgkCCS0MSgkAIgkCCS0MSgkAIgkCCS0OBgktCAEGAAABAgEtDgUGLQgBBQAAAQIBLQ4HBS0IAQcAAAECAS0MSQctCAEIAAABAgEtDEgILQhJBCMAAA2nDCIETgkkAgAJAAAOIiMAAA25JAIAAwAADcYjAAAN9icCAQQJLQgACS0KBgotCgULLQoHDC0KCA0tCE0OAAgAAQAlAAAWES0CAAAjAAAN9icCAgQJLQgACS0KBgotCgULLQoHDC0KCA0ACAACACUAABcQLQIAAC0KCgEmDCoEAgkkAgAJAAAONCMAAA5yACIBAgoAKgoECy0LCwknAgoECy0IAAstCgYMLQoFDS0KBw4tCggPLQoJEAAIAAoAJQAAFhEtAgAAIwAADnIAIgRMCS0KCQQjAAANpyoBAAEFursh14IzGGQ8BAIBJiUAAAxPLQgBAycCBAQEAAgBBAEnAwMEAQAiAwIELQoEBS0MSgUAIgUCBS0MSgUAIgUCBS0MSgUtCAEEAAABAgEtDgMELQhJAiMAAA7fDCICRwMkAgADAAAO9iMAAA7xLQsEASYcCgIDAAAqAQMFLwoABQADLQsEBS0CBQMnAAQEBCUAABd8LQgFBgAiBgIHACoHAggtDgMILQ4GBAAiAkwDLQoDAiMAAA7fJQAADE8tCAEGAAABAgEtDgQGJwIEAAUKKgMEBy0ISQUjAAAPYQwiBUcEJAIABAAAD3gjAAAPcy0LBgEmLQsBCC0LAgkMIglHCiQCAAoAAA+SJQAAFf8AIggCCwAqCwkMLQsMCgAiCUwLDioJCwwkAgAMAAAPtyUAABHsLQ4IAS0OCwIkAgAHAAAP6yMAAA/MCiIDTwgkAgAIAAAP4icCCQQAPAYJAS0KCgQjAAAP9C0KCgQjAAAP9C0LBggtAggDJwAEBAQlAAAXfC0IBQkAIgkCCgAqCgULLQ4ECy0OCQYAIgVMBC0KBAUjAAAPYSUAAAxPLQsBAgAiAgICLQ4CAQAiAU4DLQsDAi0LAQMAIgMCAy0OAwEAIgFHBC0LBAMAIgFMBS0LBQQcCgQFBBwKBQEAHAoBBAUtCgIBLQoDAi0KBAMmJQAADE8cCgEDBBwKAwIAAioBAgMsAgABAC1eCYuCuje0O5mhMWEY/SDUL1FmyenxP7XqZaltHgptBCoDAQIcCgIEBBwKBAMAAioCAwQEKgQBAhwKAgUBHAoFBAAcCgQFAQIqAgQGLAIAAgAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqBgIHHAoHCAQcCggGAAIqBwYIBCoIAQccCgcIARwKCAEAHAoBCAECKgcBCQQqCQIHHAoHCQQcCgkCABwKAgcFHAoBAgUEKgIHARwKBgIFHAoEBgUEKgYCBBwKAwIFLQoFAy0KAgUtCgECLQoIASYlAAAMTwwqBgUIKQIABQUAAVGAJAIACAAAEcEjAAARmxYKAwEcCgMCBRwKAQMFBCoCBAEEKgMFAgAqAQIDLQoDByMAABHnFgoBAxwKAQQFHAoDAQUEKgQCAwQqAQUCACoDAgEtCgEHIwAAEectCgcBJioBAAEF0Afr9MvGZ5A8BAIBJiUAAAxPHAoDCQAcCggDACcCCAACJwIKACAnAgwEDS0IAA0tCggOLQoKDwAIAAwAJQAAF9stAgAALQoOCwQqAwsKACoJCgMcCgYJACcCBgBAJwILBAwtCAAMLQoIDS0KBg4ACAALACUAABfbLQIAAC0KDQoEKgkKBgAqAwYJHAoHAwAnAgYASCcCCgQLLQgACy0KCAwtCgYNAAgACgAlAAAX2y0CAAAtCgwHBCoDBwYAKgkGAxwKBAYAJwIEAGgnAgkECi0IAAotCggLLQoEDAAIAAkAJQAAF9stAgAALQoLBwQqBgcEACoDBAYcCgUDACcCBABwJwIHBAktCAAJLQoICi0KBAsACAAHACUAABfbLQIAAC0KCgUEKgMFBAAqBgQDLQgBBCcCBQQEAAgBBQEnAwQEAQAiBAIFLQoFBi0OAwYAIgYCBi0OAQYAIgYCBi0OAgYtCgQBJiUAAAxPHAoCBQAEIgVQBi0IAQUnAgcEBAAIAQcBJwMFBAEAIgUCBy0KBwgtDEoIACIIAggtDEoIACIIAggtDEoILQgBBycCCAQFAAgBCAEnAwcEAQAiBwIILQoICS0MSgkAIgkCCS0MSgkAIgkCCS0MSgkAIgkCCS0OBgktCAEGAAABAgEtDgUGLQgBBQAAAQIBLQ4HBS0IAQcAAAECAS0MSQctCAEIAAABAgEtDEgILQhJBCMAABQQDCIERwkkAgAJAAAUiyMAABQiJAIAAwAAFC8jAAAUXycCAQQJLQgACS0KBgotCgULLQoHDC0KCA0tCE0OAAgAAQAlAAAWES0CAAAjAAAUXycCAgQJLQgACS0KBgotCgULLQoHDC0KCA0ACAACACUAABcQLQIAAC0KCgEmDCoEAgkkAgAJAAAUnSMAABTbACIBAgoAKgoECy0LCwknAgoECy0IAAstCgYMLQoFDS0KBw4tCggPLQoJEAAIAAoAJQAAFhEtAgAAIwAAFNsAIgRMCS0KCQQjAAAUECUAAAxPACIBTAQtCwQDACIBTgUtCwUEACIBRwYtCwYFLQgBAScCBgQFAAgBBgEnAwEEAQAiAQIGLQoGBy0OAwcAIgcCBy0OBAcAIgcCBy0OBQcAIgcCBy0OAgcmJQAADE8nAgQEBC0ISQMjAAAVWAwqAwQFJAIABQAAFWsjAAAVaiYcCgMFAAAqAQUGACICAgcAKgcDCC0LCAUwCgAFAAYAIgNMBS0KBQMjAAAVWCoBAAEFXm0/LtzNhwk8BAIBJioBAAEFG7xl0D/c6tw8BAIBJioBAAEFT99KitfP8NM8BAIBJgAAAwUHLQADCC0ABAkKAAgHCiQAAAoAABX+LQEIBi0EBgkAAAgCCAAACQIJIwAAFdomKgEAAQXkCFBFArWMHzwEAgEmJQAADE8tCwQGCiIGSAckAgAHAAAWMCcCCAQAPAYIAS0LAwYKIgZHByQCAAcAABasIwAAFkYtCwEHLQsCCAwiBkcJJAIACQAAFmAlAAAV/y0CBwMnAAQEBCUAABd8LQgFCQAiCQIKACoKBgstDgULACIGTAUOKgYFByQCAAcAABaXJQAAEewtDgkBLQ4IAi0OBQMtDEgEIwAAFw8nAgYEBy0IAActCgEILQoCCS0KAwotCgQLAAgABgAlAAAYyC0CAAAtCwEGLQsCBy0LBAgtAgYDJwAEBAQlAAAXfC0IBQkAIglMCi0OBQotDgkBLQ4HAi0MTAMtDggEIwAAFw8mJQAADE8tCwQFCiIFSAYkAgAGAAAXLycCBwQAPAYHAScCBQQGLQgABi0KAQctCgIILQoDCS0KBAoACAAFACUAABjILQIAAC0LAQUtCwIGLQsDBy0OBQEtDgYCLQ4HAy0MSwQAIgZMAi0LAgEmLQEDBgoABgIHJAAABwAAF5IjAAAXmy0AAwUjAAAX2i0AAQUAAAEEAQAAAwQJLQADCi0ABQsKAAoJDCQAAAwAABfVLQEKCC0ECAsAAAoCCgAACwILIwAAF7EnAQUEASYlAAAMTy0IAQQAAAECAS0MTQQnAgYEAicCBwEBLQgBBScCCAQhAAgBCAEnAwUEAQAiBQIIJwIJBCBDA6oAAgAGAAkABwAILQIIAy0CCQQlAAAZxCcCAgQhJwIGBCAtCEwDIwAAGEEMKgMCByQCAAcAABhYIwAAGFMtCwQBJi0LBAcEKgcHCAIqBgMHDioDBgkkAgAJAAAYeCUAABWpDCoHBgkkAgAJAAAYiiUAABX/ACIFAgoAKgoHCy0LCwkcCgkHAAQqCAEJBCoHCQoCKE0HCQQqCQgHACoKBwgtDggEACIDTActCgcDIwAAGEElAAAMTy0ISQUjAAAY1gwiBUcGJAIABgAAGT4jAAAY6C0LAgUtCwUGACIGAgYtDgYFLQgBBicCBwQFAAgBBwEnAwYEAQAiBQIHJwIIBAQAIgYCCT8PAAcACS0LAQUtCwMHLQsECC0OBQEtDgYCLQ4HAy0OCAQmLQsDBgwqBQYHJAIABwAAGVQjAAAZti0LAgcAIgcCCQAqCQUKLQsKCC0LAQkAIgkCCwAqCwUMLQsMCgAqCAoLLQsECC0CBwMnAAQEBSUAABd8LQgFCgAiCgIMACoMBQ0tDgsNLQ4JAS0OCgItDgYDLQ4IBCMAABm2ACIFTAYtCgYFIwAAGNYnAAYEAgYABAYFLQAECCcACQQADgAFCQokAAAKAAAaFwIACAIIAAADCQstAQsGAAADCAstAQsHAAADCQstBAcLAAADCAstBAYLAAAJAgkjAAAZ1yY=",
-      "debug_symbols": "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"
+      "debug_symbols": "tZ3dbh23zobvxcc50B8lqrdSFEXaphsBgrTIbj/gQ5F73+IrihynGGU8yz7JPKaXqD9KIqlZzj9Pv3345e///Pzx8+9//Pfphx//efrly8dPnz7+5+dPf/z6/q+Pf3we0n+egvyTUn76Ib57Sjnpsz39kMazJH3qz6Q/U53PGvWpPzf9udF8ctBn0WfHM4ehr4xnjPqs85n056Q/Z/05j3I0niXrk+dT2oNnnU9pD56j/jaeLeiz6JPnk5M+23x2/blXPEsY5WIQoAWjBXE0pcShKrKA9GV0piTpnPwqdYWc9VeZFaThqQqwAoZQAGMIkEHrA9r4cJZKOS4YH855QB915VEFhbRgdCGPNpOM5YSqkJYkLUlekkwLukIpC0YLy6iUKC9oCtLUCbSgK8gIT1gSXsVlkMsYBJJRnqCSKsMLiGPASxWgBV1BbHMCK+QlETMFFGkYC5AChQVlASvUvECKjwGvYrYTqgIvCS9JX5JOC/qEFsoCVoh5waiCxiC0lBZUhRwWlAWsUNaHyypOS0KreJXiUYAWdAWxnwmswEsicwGQ7kxYxaU7NAaTZVJoWALLpEwoC1hBJmXCksjWMaEqlFW8rOJlfVi6U4PAaE8dtXNNC6qCrN0JZQEr8Powrw/39WHpjkAPYUFZIMWHsXWZnQlLIpMCkAVSSaAqFB3nXnSgOi0JLcmaiy5zUYdpdTQeUBawAhoPqAp9fbivD3f9cAwhGdVFstKVTJaCUTEyLbJilGTHi0JiZEp1kXRNqRjxIlk4SiZrpkXWTstCsniUyKgv6tmIlUazjNoi6WUroLpIeqlUjHiR9FLJZOglg0RzFxLrUzJZNZkY4CTZFpRMxiZD30Ayf0rFqCulUIx4UUxGqwUpRaNVW8rBiIxMczHNsrBYZiHJpq1kMumbUl0kfVMyGc/TfUBV6HHBqJ5lWrKsK6VixItkaSmZTI5F0Z9lVgA0j/eYZeFMIIW2JG1JeEl4HvoRp/WENqGEuIAUsHcB5tEfcV4DZO+a0BRk1U+oCmVJCi0YxVnaUWRpKEkfUYssDSWTyTYc8TlZ++IzxCIbMXfQkHUZjSILQqnpb3G8Kw1Zl3EkMZpJsgyUyGi0r1chWeJd2kzS+EmysDuDaFE1mbR5EtocIrAZimEsdGl3aTdplalYSIYxOIoDFQqwG8IDVWyGOTqSYQmOB6krIyirQDasLm3RcUz52EQE0c2Ygc1Q1sBCWtjgISoepN1QVsJCU9ZSdPRiWCFRmgNnIMJWWu6GJTs2Q4qO5OjFqherXqwlR5eyK2MoE+tj2ZjHxgVkw+hSdGgiJiDJHLMskYUuRRsmog3iKw9shmiDIhnK9rrwIO0L+2xkBTbDmByrYQqO5AhlslJ6zo5sWFxaXEoupWZYo2M1bMGRHFGxjHrn4siGWGSKVTEFWJ9iceyG0aWRDROUdWAzxCJTJEMsMsWDtBvOzk90Zeh8TsBqiM4rFkc2xNJT9GLdi3Uv1q1YDMmxGUaXRlMG32FhceyGmPlMQDYsybEaUnAsjt2wurS6Mpi9RFkDmyHMXpEcu+Hs/ESTJpi9IpTJHKfZ+YnVcHZ+YnHshtmlCFoFVvRv4X+SHUcO9YQMwKQajIpRX9RMhq4JoDeSZEBTC0jaz0hAQDZzESKU6DBl2OVE2KUEfQMhRTHMh2KxD2A+JmI+JHAa2A0xCRNhgYoybiSNzrBARVo40wOKLo0uxfJTZEOccYqoWFpWkHNRrIbopmJxZEMsP0WXVleG5UeM7E10dCk2HEUZkopMD2anilURuilhw0By7IY4BxTZMLkU3ZyIXUbRlWVXVrwYzrgq+wmJr76wGtbgWBzZsHmx5sXYi8EaJ3aXdleGXUYim2Hg0rKGPBcOwYnRpdGlsF/FZphdml0qTubCaghTViTD6lL0WBEVyxKq8NwUmyG2FsVq2E3asINKwDWwGUaXRpcmlyaXZpdmlxaXFpeSS8ml1aXVpc2lmMKJs0MTXdpd2k3KsF/F4tgN5xROZEPvJns3OUdHr6J4FdiNFL0K8orJq6hesfeYvcfsPWbv8XSKJnavuHsV3SqeTpGiVdx9YrtPbE/R0SruOTiSo1dRiqNXQV6xz3H3OZ5O0cTmFTevgr1i9irYK+5eRV8V52CmPLAZxuhYDVNwJMdumIsjqqiC2KMmwvlWrIZzmU4kw+ZSuD8TEWNMhJenaNLp3ShaFTEGx+LYDZNLk0tzdrQOTe9G0SsWixpzChRnoEtOPUlzFjbDSIYyqEli0IHkKFlxiUJzQl5ckQ2LS4tLyaXUDJEsl1B1IC3MEUMtH8hzYiHFxHIAdkNMrKJLi0uLS2HKis0QpqxYDWHKiqg4ArshTFnRpd2l3aQFi1exGWLxKlZDLF5Fq7hg8SrCHjqQDacpT2yG06onVsNp1RNdGfyoic2VNVcGl2oinCdOuLJB02VlTZ9AkRy7IRqp2AzJi5EXQyMVXYr1JtmaTHMugJwdmyFOEUVytGI1FEeXxuyIRA9uoHBIsKyAec4ruhTnPDcgOXZDHBKKzXDa2UQv1rzYtLOJLsU+CWwy1EnujjJSDIqyAha6lFxKLpWWLWyGcnwtrIZyfC30itmVdauCsa1IpDS8cXxWBorFlFPGdd1suqxunLxJ7pcGojaxM6ZgxWbTJ3bD6lJxnhRbdnQp8qGKdWEXVzhJhDKwG8biKBqKWF8XV1gRV6pFuol7g+G1C1b0Yl49FkdokG52tGwiRlJRmiMXTGPTiI5LWpAgSISLS7R3YnQpGjkRjVRshrAHaXpB0K+IrXiibIOKuN6V8Gwga98KDrWFbSEOtYXVMEZHl+JAUSyGOC9wY4ozSxFX04qiIeGOFueFooyDZF0GdkPZHxZi5qXzkbMjbDLiwjc5wh5w+xuiI6QyJPPUC6IXofVCSBmXxpDKZCVMrKJowIXzzL0rQioVZ9QWcbeM2iSBWHCPvtClCVJcSCdIZfgyFq+i9FjyjiXDzhQhbbi+hpSBkEojc8+OJsWZlSQTOBDX3tLeEiHFFThMbiJMLmUgG2aXzotzafq8Old0KdyDRLhRFysJ8ypdekwdiPt1aU7FOMgV4MBqmF2aXYptRbE4siEqVnQpFoMilEk3sVePiA8IqTQdMVmSu8WCmEyxu1QOn4V9YcP4KrJhdKk49IqzxxWIKhpeK4CUgZDiZYMSHV2KjVSxOLIhzEjRpTgDFEVZkwmYZ4DE0gVBW5LgtSBoS+JiFwRtEzlER3LshuixIhsml2ITm4geS6BbELSNqFMQPRZPt8yjQzzHwhQdXYoNWrE4siEWjqJLcXQoQpmMOs8ed6BIxV0suKleSIbRpdGlyaXYERXZEGtIsRkikzdxunXSspmoRsu6ObJlJqoVyZBdyi7tLu3FkRVHBik7NsOYHJcjSzMmUyTD7NLs0uLSUhzZkLJjM6zJ0Stu0ZHUZR3YDbk4smFPjsvppRiioynToG1icTRlMWXD6TkmvMmznF6aqWPFasjBsTiyYfdi3YrhzFro0ricXpr5YsXiyIbI+ihWw+LFiisjl5Irm54uCSJmEK+YcAe90KV9Ob2UZi/w6lIIjsWRDaedTfRiyYslMswuzd0QGx4BseEpNkNseIrVEBueItwvBnZDOL2KJi2hOLoUG55iM0zJsRpiw1O0ipFMVsQmJu+qEO6iR4oWiG6KEeA2ekwTkBdSyI5og0wLzZYRXgjDBDAQEyCmrCEMcC6yidVw2u9E0dDxChkSH3IlPrAaYg0pkiEWjqJU3KVDMymp2AyLSxGITUQ4qehShJNytU54w0qxuRS3VxMRTio2QxitommYmUjJrdDMRE5EDKnYDBHaK5KjF8uuLLu0uLLiysiVId6UnA3N69mJCO0VXYrQXpEN2WYI55tiD45lYbdQmfrsZgWyITICE5ERUEQjZQ3hHayFxZENkVdWrIbVi1VX1lzaXFlzZezK2JV1L9a9WF/F6kw/Sj6qzqMOiLvIJGdLnYHNRPhnijjcsyACXcWDtBvCI1V0KbmUXFpd2pohNiZFqyJhs5EZGtcX+CzhvctkUjhPjJcw4TzJ5jiwGpJLZxuAsw0TXTqbA4SbJLtGxW6v2F063SR523JGPrI/1Bn5iHHVGfnIiq0z8pFFVmfkg17MyGfiHF8g9qgOvdi2A/TOSGJiceyG2BwDakNICywIaRVdGl0aXZpcmlwKr01ejxnYDDHUiuTYDcmLkReDk4O+4Q5w3BMLzg5N5NWhudsrmpRmhyZCgxgBXjBe6FJ4pIGA5GhjRjk7ehXFpQjiJ5JXTC5FEK9Ijl5Fc2U8NXz9+u5pvef+819fPnyQ19wPL77/+M/Tn++/fPj819MPn//+9Ond0/+9//Q3PvTfP99/xvOv91/Gb4fSD59/G8+h8PePnz4IfX3npcN50XEYr9JjgqMpGH7hVRXDOWiqYmC/oyIhswAVw387b0XetGLEoXU1Y8SOzZS0y4Mx8iZLhVyw3+pJk/Btqmg9n6qo5yq4rxkZoZYpGBm5ywokXFIFfKqAzxWM/BetNsQR3PiEjMz4MyV9MyF4qWHOR6RDR8bAXrWsSsssRgqWTgdTsk7nc8pmWsNhdR3xGx1pMx4c6hrSwe3UtuLOQIcTukxDroviqZJdbziuhsiN6HlvaLfYuJuScUK5ibT8XEl9jSFpbzwkw4GPqkO8dlNB8bmKjakOf0GyXmokw/88G5G0MdbhYfmI9HZoyTedSXE3IlWSjzoi9XwX23fnsJ2OwCuedme7n66ZGU7CYVTvzQvT2bykjaU2SUtCw3E4S7rehmbLZURT7bQNGxsdycCloo101umkbrbTcQVblo7B/Z6ZH7tyOCK/NfOdCq5rTiX2OVOR48OjkdNbj4Z3pYbY7oxGxRvBU8UIp09HY2OfhPuOOaDHZSbqnunYbqTVNo3DYV3bdQ1kTktI5xo2Btp85xqmdTiqc3+uY3fcU7L9wtfq8COuj2Z08xzZ99PRLHE3mpzsVDr6ov2eYaTzTaNsNs+RsbI5GYmr02bIVeupZ16DeeYjYD3XsRnSHHpeB9vggxf2zVr7jpJ0UNLCqZLdUd+6nWuc88EbpOs6fPORy+6bOjxKGBcV5zq2M0NrPMY1Vz2fma2FNDuia4inOmizk440p20/lM7bQfkVLITKTknyLT2MLMmpkp2ZUfWWDOfhXMl2SMyhJOp8b2pqNve41nA+rLyb3m5R3JjfcHrI0W5LTZ3cGdwtvG1vbOGN282bxsqcLeq4q6P7ltipnOqoGx1ceA0ql8PuPtyI5zrK7oRo7qXHcqqj7BdNsNA2nFtI3Zzakp9ap8xIP5/r2GxmvReL0oN3JZV8WUUMxXXUeq6jP+4+tPCo+7Ad0Gq7YR3529MBbTvfdCSR7XhI+TyG+46S1F0J3XJwR/BUrDfl1Dttmw21lGxjOlKvp12pu1RBtIWf2mGx0HPraG2no1tGLB/zUd/kgS53pZ7PylaFrbehop+p4J2NjoS77cfyPt6NFOO4VF22IS/Anaa0eGdghK/B6EkZz4/b3QFVbM0OH7edzspVFVxOVWzNvNHSUdthQL8xc66vkLzh9grJG+ZXSN7su3MxedPDGyZvns0Ln24/Pb1h8qZytBify2m6opeH0xWd3jhd8awr95I31X3B2s/TFTsVLeTVihG28OmA9sczHjGER1MeexWXch4xpMe9lhjyo27LdkQvZj1ioLdNexytI4ZzAwvbhD77ARnOnfwY+PGwNob+CnFtjOEVAtu4G9nLke13huVaaLufoFyib2Z5YyjlFYLbuLuGuhzdfqdDzW99dxa3vYfKnuAaWg5bQXmBEiK7Bqd2U4m8K22ppYPtv0wJm6UUPhwV/1KyHdhCh+v0jbml9HgOM6bXSFF9T8u1LGbc3UhdTWPulVzMY35HybVE5nfm51om8zuWYt7mMJrNJOfweDok7m6nLuZDtjquJkRizq/gW+TyqG+xH9WLOZG4u1+6nBT5npbHsyJjY7Xj69kZ+O3rD7ubqtRztuNrbC3n/SnbZEBOfpTmUh7tTz1mA+L1UK0lM9g2TuZTv22bnL0aQ8fdvcjlIDpur5suvwKx79HFMDqW9oZx9LPJOQ+5YulvGEi3ZO/4NdnGzhpB8RUCP0oPB35bFdcCv91t1eXNeX9bdWlz3g7p1ciP2htHfkf74PMdZHtXxX5GMG/cxRpeI7Co8TUCi22Hurmuw79Kmw7lVwhla3kN/7fSa4Syu0uW66HsflguhrKXJyifj+3u5efAbKuYzl87ji08fr+xawe+yTzbkTKftmOnAn8RSlWUXVfyK1ws7BpSk4d8h1unfzdk9+JfshPPD7x8tQkpWiZL/gje6e68V2H+0Fic91T0aHdnhxeP/3VGtG2+dc0q5XBThb2dXw+H3Us6gj8noB05XEW+REVl39cPb8W/REXzd/Nbvjep+Kr9us28pyIHuxDNMd5rhb+QnsOt4Sx+nTByPcez6aqGGC0EGqk+vtOI6HuF/J3pWyqy2ebAe60g226G09fuqbCtMxL3ex2xYCOOHPg9FZ53yHSvI9XsO9Z2rxWtLfsem8ot44zdx+LoOL1ARbNr9lbqHQXd4rZO98YhWAw6skDnxo1vs73dMu1hrY+e7g2ErdHe6MGRvKcgelIuhYNv820yerdjeio6HV/dkO+rXVbhhzHldFOFnR5U6i0VZMHaCHXutaIGG4tayk0V5h5V4nsq2F+R7O2WimY+b2qFb6pwl+CQk3iRCu9I6/dawdEmlUu8qcKsk49flXuJCrZlxgcP6yUqur/s1ctdFTYWne6tke5rpN9bIzlV/1YZ3xpO+euGdqeRbi2zEUBZfErPLhWvx6cXr2e2PoHdj44o9nxS0+47UGw6nplWf4FbYSFEbDVtWtHfshWdPP9Yb9nFMxUt3VRBngW9ZRfyB2M9lxNjvxGnj3J+bTe43tKRLIwQvqnDb/BHXuqmDvuu4QM6ruXH0v5bUBfzY9vEQWmevji/Ht7GZh5MxMNXGL79Djj+HuL5ervyNfJtK+x8HtjuqcgeZB4P1xd15NIX6lPZvq2f7Xa63FRhHuhxK3+ZCnYV7Z6KlpqFVvnOjOSRe7cc4eBbL0GP88D2ntgK3dORwuM6bKkNpnpPR6gHHef7xv46qRVzOKhxudMStkM282E80vXMafav1WZu5Y6KQjakhfiW51T8rYVSM99TYSmE4UTddL4O7y7RvY4cxqLe8+tLtVz4cAHvtaIFu+U4fgPsZa2wGWkpPDoWLcV7HcnekdbvqWB/v67fbYV3pNPDY9HvzQj7i4J8Lw8wyrGnp+62wqyT70Xgx7Hgmu61wr5LO9I89+yiJxvOnuPNVrCrqI+ORc+30iqUbLHT8bLmBSrGdmHvrIRD+Bz5soZoxtniIdv2jYa0+5JT9Ddn5D+HvNUKeyF3YL+lwf5QTrvbhmZjGQ/B3gs0JDsMB7Z7veiugR/VEG+1IVk+vaUcHp2L4x8qe0Eb/AsOie71IpfH7OFaHBEejSLCozHEToHdlh3vmF6gYBOC/DR+fP/rxy/P/vv3r6Lqy8f3v3z6oD/+/vfnXw+//ev//1y/Wf99/J9f/vj1w29/f/kgmvz/kB///Bjlfx8YWwr/9O4pys95+DbyH7eOn7P8LO99jciV5PdSoFJ8V6nKj/J5SaiNnv/0VZr7Pw=="
     },
     {
       "name": "sync_private_state",
@@ -3611,7 +3611,7 @@
     },
     "73": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/contract_self.nr",
-      "source": "use crate::{\n    context::{\n        calls::{PrivateCall, PrivateStaticCall, PublicCall, PublicStaticCall},\n        private_context::PrivateContext,\n        public_context::PublicContext,\n        utility_context::UtilityContext,\n    },\n    event::{\n        event_emission::{emit_event_in_private, emit_event_in_public},\n        event_interface::EventInterface,\n        event_message::EventMessage,\n    },\n};\nuse protocol_types::{\n    address::AztecAddress,\n    constants::NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    traits::{Deserialize, Serialize},\n};\n\n/// `ContractSelf` is the core interface for interacting with an Aztec contract's own state and context.\n///\n/// This struct is automatically injected into every #[external(...)] contract function by the Aztec macro system and is\n/// accessible through the `self` variable.\n///\n/// # Usage in Contract Functions\n///\n/// Once injected, you can use `self` to:\n/// - Access storage: `self.storage.balances.at(owner).read()`\n/// - Call contracts: `self.call(Token::at(address).transfer(recipient, amount))`\n/// - Emit events: `self.emit(event).deliver_to(recipient, delivery_mode)` (private) or `self.emit(event)` (public)\n/// - Get the contract address: `self.address`\n/// - Get the caller: `self.msg_sender()`\n/// - Access low-level Aztec.nr APIs through the context: `self.context`\n///\n/// # Example\n///\n/// ```noir\n/// #[external(\"private\")]\n/// fn withdraw(amount: u128, recipient: AztecAddress) {\n///     // Get the caller of this function\n///     let sender = self.msg_sender().unwrap();\n///\n///     // Access storage\n///     let token = self.storage.donation_token.get_note().get_address();\n///\n///     // Call contracts\n///     self.call(Token::at(token).transfer(recipient, amount));\n/// }\n/// ```\n///\n/// # Type Parameters\n///\n/// - `Context`: The execution context type - either `&mut PrivateContext`, `PublicContext`, or `UtilityContext`\n/// - `Storage`: The contract's storage struct (defined with `#[storage]`), or `()` if the contract has no storage\n/// - `CallSelf`: Macro-generated type for calling contract's own non-view functions\n/// - `EnqueueSelf`: Macro-generated type for enqueuing calls to the contract's own non-view functions\n/// - `CallSelfStatic`: Macro-generated type for calling contract's own view functions\n/// - `EnqueueSelfStatic`: Macro-generated type for enqueuing calls to the contract's own view functions\npub struct ContractSelf<Context, Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> {\n    /// The address of this contract\n    pub address: AztecAddress,\n    /// The contract's storage instance, representing the struct to which the `#[storage]` macro was applied in your\n    /// contract. If the contract has no storage, the type of this will be `()`.\n    ///\n    /// This storage instance is specialized for the current execution context (private, public, or utility) and\n    /// provides access to the contract's state variables. Each state variable accepts the context as a generic\n    /// parameter, which determines its available functionality. For example, a PublicImmutable variable can be read\n    /// from any context (public, private, or utility) but can only be written to from public contexts.\n    ///\n    /// # Developer Note\n    /// If you've arrived here while trying to access your contract's storage while the `Storage` generic type is set to\n    /// unit type `()`, it means you haven't yet defined a Storage struct using the #[storage] macro in your contract.\n    /// For guidance on setting this up, please refer to our docs:\n    /// https://docs.aztec.network/developers/docs/guides/smart_contracts/storage\n    pub storage: Storage,\n    /// The execution context whose type is determined by the #[external(...)] attribute of the contract function based\n    /// on the external function type (private, public, or utility).\n    pub context: Context,\n\n    /// Provides type-safe methods for calling this contract's own non-view functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.call_self.some_private_function(args)\n    /// ```\n    pub call_self: CallSelf,\n    /// Provides type-safe methods for enqueuing calls to this contract's own non-view functions.\n    ///\n    /// In private context this will be a struct with appropriate methods;\n    /// in public and utility contexts it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.enqueue_self.some_public_function(args)\n    /// ```\n    pub enqueue_self: EnqueueSelf,\n    /// Provides type-safe methods for calling this contract's own view functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.call_self_static.some_view_function(args)\n    /// ```\n    pub call_self_static: CallSelfStatic,\n    /// Provides type-safe methods for enqueuing calls to this contract's own view functions.\n    ///\n    /// In private context this will be a struct with appropriate methods;\n    /// in public and utility contexts it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.enqueue_self_static.some_public_view_function(args)\n    /// ```\n    pub enqueue_self_static: EnqueueSelfStatic,\n    /// Provides type-safe methods for calling internal functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.internal.some_internal_function(args)\n    /// ```\n    pub internal: CallInternal,\n}\n\n/// Implementation for `ContractSelf` in private execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"private\")]`.\n/// Private functions execute client-side and generate zero-knowledge proofs of their execution.\nimpl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> ContractSelf<&mut PrivateContext, Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> {\n    /// Creates a new `ContractSelf` instance for a private function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_private(\n        context: &mut PrivateContext,\n        storage: Storage,\n        call_self: CallSelf,\n        enqueue_self: EnqueueSelf,\n        call_self_static: CallSelfStatic,\n        enqueue_self_static: EnqueueSelfStatic,\n        internal: CallInternal,\n    ) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self,\n            enqueue_self,\n            call_self_static,\n            enqueue_self_static,\n            internal,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call. This is similar to `msg.sender` in Solidity.\n    ///\n    /// Important Note: Since Aztec doesn't have a concept of an EoA ( Externally-owned Account), the msg_sender is\n    /// \"null\" for the first function call of every transaction. The first function call of a tx is likely to be a call\n    /// to the user's account contract, so this quirk will most often be handled by account contract developers.\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract or\n    ///   a user's account contract). Returns `Option<AztecAddress>::none` for the first function call of the tx. No\n    ///   other _private_ function calls in the tx will have a `none` msg_sender, but _public_ function calls might (see\n    ///   the PublicContext).\n    ///\n    pub fn msg_sender(self) -> Option<AztecAddress> {\n        let maybe_msg_sender = self.context.msg_sender_unsafe();\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Emits an event privately.\n    ///\n    /// Unlike public events, private events do not reveal their contents publicly. They instead create an\n    /// [EventMessage] containing the private event information, which **MUST** be delivered to a recipient via\n    /// [EventMessage::deliver_to] in order for them to learn about the event. Multiple recipients can have the same\n    /// message be delivered to them.\n    ///\n    /// # Example\n    /// ```noir\n    /// #[event]\n    /// struct Transfer { from: AztecAddress, to: AztecAddress, amount: u128 }\n    ///\n    /// #[external(\"private\")]\n    /// fn transfer(to: AztecAddress, amount: u128) {\n    ///     let from = self.msg_sender().unwrap();\n    ///\n    ///     let message: EventMessage = self.emit(Transfer { from, to, amount });\n    ///     message.deliver_to(from, MessageDelivery.UNCONSTRAINED_OFFCHAIN);\n    ///     message.deliver_to(to, MessageDelivery.CONSTRAINED_ONCHAIN);\n    /// }\n    /// ```\n    ///\n    /// # Cost\n    ///\n    /// Private event emission always results in the creation of a nullifer, which acts as a commitment to the event and\n    /// is used by third parties to verify its authenticity. See [EventMessage::deliver_to] for the costs associated to\n    /// delivery.\n    ///\n    /// # Privacy\n    ///\n    /// The nullifier created when emitting a private event leaks nothing about the content of the event - it's a\n    /// commitment that includes a random value, so even with full knowledge of the event preimage determining if an\n    /// event was emitted or not requires brute-forcing the entire `Field` space.\n    pub fn emit<Event>(&mut self, event: Event) -> EventMessage<Event>\n    where\n        Event: EventInterface + Serialize,\n    {\n        emit_event_in_private(self.context, event)\n    }\n\n    /// Makes a call to the private function defined by the `call` parameter.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the private function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.call(Token::at(address).transfer_in_private(recipient, amount));\n    /// ```\n    ///\n    /// This enables contracts to interact with each other while maintaining\n    /// privacy. This \"composability\" of private contract functions is a key\n    /// feature of the Aztec network.\n    ///\n    /// If a user's transaction includes multiple private function calls, then\n    /// by the design of Aztec, the following information will remain private[1]:\n    /// - The function selectors and contract addresses of all private function\n    ///   calls will remain private, so an observer of the public mempool will\n    ///   not be able to look at a tx and deduce which private functions have\n    ///   been executed.\n    /// - The arguments and return values of all private function calls will\n    ///   remain private.\n    /// - The person who initiated the tx will remain private.\n    /// - The notes and nullifiers and private logs that are emitted by all\n    ///   private function calls will (if designed well) not leak any user\n    ///   secrets, nor leak which functions have been executed.\n    ///\n    /// [1] Caveats: Some of these privacy guarantees depend on how app\n    /// developers design their smart contracts. Some actions _can_ leak\n    /// information, such as:\n    /// - Calling an internal public function.\n    /// - Calling a public function and not setting msg_sender to Option::none\n    ///   (see https://github.com/AztecProtocol/aztec-packages/pull/16433)\n    /// - Calling any public function will always leak details about the nature\n    ///   of the transaction, so devs should be careful in their contract\n    ///   designs. If it can be done in a private function, then that will give\n    ///   the best privacy.\n    /// - Not padding the side-effects of a tx to some standardized, uniform\n    ///   size. The kernel circuits can take hints to pad side-effects, so a\n    ///   wallet should be able to request for a particular amount of padding.\n    ///   Wallets should ideally agree on some standard.\n    ///   - Padding should include:\n    ///     - Padding the lengths of note & nullifier arrays\n    ///     - Padding private logs with random fields, up to some standardized\n    ///       size.\n    /// See also: https://docs.aztec.network/developers/resources/considerations/privacy_considerations\n    ///\n    /// # Advanced\n    /// * The call is added to the private call stack and executed by kernel\n    ///   circuits after this function completes\n    /// * The called function can modify its own contract's private state\n    /// * Side effects from the called function are included in this transaction\n    /// * The call inherits the current transaction's context and gas limits\n    ///\n    pub fn call<let M: u32, let N: u32, T>(&mut self, call: PrivateCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.call(self.context)\n    }\n\n    /// Makes a read-only call to the private function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state, emit L2->L1 messages, nor emit events. Any nested\n    /// calls are constrained to also be static calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only private function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.view(Token::at(address).balance_of_private(recipient));\n    /// ```\n    pub fn view<let M: u32, let N: u32, T>(&mut self, call: PrivateStaticCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.view(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// to be executed later.\n    ///\n    /// Unlike private functions which execute immediately on the user's device,\n    /// public function calls are \"enqueued\" and executed some time later by a\n    /// block proposer.\n    ///\n    /// This means a public function cannot return any values back to a private\n    /// function, because by the time the public function is being executed,\n    /// the private function which called it has already completed execution.\n    /// (In fact, the private function has been executed and proven, along with\n    /// all other private function calls of the user's tx. A single proof of the\n    /// tx has been submitted to the Aztec network, and some time later a\n    /// proposer has picked the tx up from the mempool and begun executing all\n    /// of the enqueued public functions).\n    ///\n    /// # Privacy warning\n    /// Enqueueing a public function call is an inherently leaky action.\n    /// Many interesting applications will require some interaction with public\n    /// state, but smart contract developers should try to use public function\n    /// calls sparingly, and carefully.\n    /// _Internal_ public function calls are especially leaky, because they\n    /// completely leak which private contract made the call.\n    /// See also: https://docs.aztec.network/developers/resources/considerations/privacy_considerations\n    ///\n    /// # Arguments\n    /// * `call` - The interface representing the public function to enqueue.\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCall type seems to be defined\n    /// incorrectly.\n    pub fn enqueue<let M: u32, let N: u32, T>(&mut self, call: PublicCall<M, N, T>)\n    where\n        T: Deserialize,\n    {\n        call.enqueue(self.context)\n    }\n\n    /// Enqueues a read-only call to the public function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state, emit L2->L1 messages, nor emit events. Any nested\n    /// calls are constrained to also be static calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_view(MyContract::at(address).assert_timestamp_less_than(timestamp));\n    /// ```\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCall type seems to be defined\n    /// incorrectly.\n    pub fn enqueue_view<let M: u32, let N: u32, T>(&mut self, call: PublicStaticCall<M, N, T>)\n    where\n        T: Deserialize,\n    {\n        call.enqueue_view(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// to be executed later.\n    ///\n    /// As per `enqueue`, but hides this calling contract's address from the\n    /// target public function.\n    /// This means the origin of the call (msg_sender) will not be publicly\n    /// visible to any blockchain observers, nor to the target public function.\n    /// When the target public function reads `context.msg_sender()` it will\n    /// receive an `Option<AztecAddress>::none`.\n    ///\n    /// NOTES:\n    /// - Not all public functions will accept a msg_sender of \"none\". Many\n    ///   public functions will require that msg_sender is \"some\" and will\n    ///   revert otherwise. Therefore, if using `enqueue_incognito`, you must\n    ///   understand whether the function you're calling will accept a\n    ///   msg_sender of \"none\".\n    ///   Lots of public bookkeeping patterns rely on knowing which address made\n    ///   the call, so as to ascribe state against the caller's address.\n    ///   (There are patterns whereby bookkeeping could instead be done in\n    ///   private-land).\n    /// - If you are enqueueing a call to an _internal_ public function (i.e.\n    ///   a public function that will only accept calls from other functions\n    ///   of its own contract), then by definition a call to it cannot possibly\n    ///   be \"incognito\": the msg_sender must be its own address, and indeed the\n    ///   called public function will assert this. Tl;dr this is not usable for\n    ///   enqueued internal public calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_incognito(Token::at(address).increase_total_supply_by(amount));\n    /// ```\n    ///\n    /// Advanced:\n    /// - The kernel circuits will permit _any_ private function to set the\n    ///   msg_sender field of any enqueued public function call to\n    ///   NULL_MSG_SENDER_CONTRACT_ADDRESS.\n    /// - When the called public function calls `PublicContext::msg_sender()`,\n    ///   aztec-nr will translate NULL_MSG_SENDER_CONTRACT_ADDRESS into\n    ///   `Option<AztecAddress>::none` for familiarity to devs.\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCall type seems to be defined\n    /// incorrectly.\n    pub fn enqueue_incognito<let M: u32, let N: u32, T>(&mut self, call: PublicCall<M, N, T>)\n    where\n        T: Deserialize,\n    {\n        call.enqueue_incognito(self.context)\n    }\n\n    /// Enqueues a read-only call to the public function defined by the `call` parameter.\n    ///\n    /// As per `enqueue_view`, but hides this calling contract's address from\n    /// the target public function.\n    ///\n    /// See `enqueue_incognito` for more details relating to hiding msg_sender.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_view_incognito(MyContract::at(address).assert_timestamp_less_than(timestamp));\n    /// ```\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCall type seems to be defined\n    /// incorrectly.\n    pub fn enqueue_view_incognito<let M: u32, let N: u32, T>(\n        &mut self,\n        call: PublicStaticCall<M, N, T>,\n    )\n    where\n        T: Deserialize,\n    {\n        call.enqueue_view_incognito(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// and designates it to be the teardown function for this tx. Only one teardown\n    /// function call can be made by a tx.\n    ///\n    /// Niche function: Only wallet developers and paymaster contract developers\n    /// (aka Fee-payment contracts) will need to make use of this function.\n    ///\n    /// Aztec supports a three-phase execution model: setup, app logic, teardown.\n    /// The phases exist to enable a fee payer to take on the risk of paying\n    /// a transaction fee, safe in the knowledge that their payment (in whatever\n    /// token or method the user chooses) will succeed, regardless of whether\n    /// the app logic will succeed. The \"setup\" phase ensures the fee payer\n    /// has sufficient balance to pay the proposer their fees.\n    /// The teardown phase is primarily intended to: calculate exactly\n    /// how much the user owes, based on gas consumption, and refund the user\n    /// any change.\n    ///\n    /// Note: in some cases, the cost of refunding the user (i.e. DA costs of\n    /// tx side-effects) might exceed the refund amount. For app logic with\n    /// fairly stable and predictable gas consumption, a material refund amount\n    /// is unlikely. For app logic with unpredictable gas consumption, a\n    /// refund might be important to the user (e.g. if a hefty function reverts\n    /// very early). Wallet/FPC/Paymaster developers should be mindful of this.\n    ///\n    /// See `enqueue` for more information about enqueuing public function calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to designate as teardown.\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCall type seems to be defined\n    /// incorrectly.\n    pub fn set_as_teardown<let M: u32, let N: u32, T>(&mut self, call: PublicCall<M, N, T>)\n    where\n        T: Deserialize,\n    {\n        call.set_as_teardown(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// and designates it to be the teardown function for this tx. Only one teardown\n    /// function call can be made by a tx.\n    ///\n    /// As per `set_as_teardown`, but hides this calling contract's address from\n    /// the target public function.\n    ///\n    /// See `enqueue_incognito` for more details relating to hiding msg_sender.\n    ///\n    /// TODO(F-131): We should drop T from here because it is strange as there\n    /// is no return value. The PublicCall type seems to be defined\n    /// incorrectly.\n    pub fn set_as_teardown_incognito<let M: u32, let N: u32, T>(\n        &mut self,\n        call: PublicCall<M, N, T>,\n    )\n    where\n        T: Deserialize,\n    {\n        call.set_as_teardown_incognito(self.context)\n    }\n}\n\n/// Implementation for `ContractSelf` in public execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"public\")]`.\n/// Public functions are executed by the sequencer in the Aztec Virtual Machine (AVM) and can work only with public\n/// state.\nimpl<Storage, CallSelf, CallSelfStatic, CallInternal> ContractSelf<PublicContext, Storage, CallSelf, (), CallSelfStatic, (), CallInternal> {\n    /// Creates a new `ContractSelf` instance for a public function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_public(\n        context: PublicContext,\n        storage: Storage,\n        call_self: CallSelf,\n        call_self_static: CallSelfStatic,\n        internal: CallInternal,\n    ) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self,\n            enqueue_self: (),\n            call_self_static,\n            enqueue_self_static: (),\n            internal,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    ///\n    /// This is similar to `msg.sender` in Solidity (hence the name).\n    ///\n    /// Important Note: If the calling function is a _private_ function, then it had the option of hiding its address\n    /// when enqueuing this public function call. In such cases, this `context.msg_sender()` method will return\n    /// `Option<AztecAddress>::none`. If the calling function is a _public_ function, it will always return an\n    /// `Option<AztecAddress>::some` (i.e. a non-null value).\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract or\n    ///   a user's account contract).\n    ///\n    /// # Advanced\n    /// * Value is provided by the AVM sender opcode\n    /// * In nested calls, this is the immediate caller, not the original transaction sender\n    ///\n    pub fn msg_sender(self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = self.context.msg_sender_unsafe();\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Emits an event publicly.\n    ///\n    /// Public events are emitted as plaintext and are therefore visible to everyone. This is is the same as Solidity\n    /// events on EVM chains.\n    ///\n    /// Unlike private events, they don't require delivery of an event message.\n    ///\n    /// # Example\n    /// ```noir\n    /// #[event]\n    /// struct Update { value: Field }\n    ///\n    /// #[external(\"public\")]\n    /// fn publish_update(value: Field) {\n    ///     self.emit(Update { value });\n    /// }\n    /// ```\n    ///\n    /// # Cost\n    ///\n    /// Public event emission is achieved by emitting public transaction logs. A total of `N+1` fields are emitted,\n    /// where `N` is the serialization length of the event.\n    pub fn emit<Event>(&mut self, event: Event)\n    where\n        Event: EventInterface + Serialize,\n    {\n        emit_event_in_public(self.context, event);\n    }\n\n    /// Makes the call to the public function defined by the `call` parameter.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.call(Token::at(address).transfer_in_public(recipient, amount));\n    /// ```\n    ///\n    pub unconstrained fn call<let M: u32, let N: u32, T>(self, call: PublicCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.call(self.context)\n    }\n\n    /// Makes the read-only call to the public function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state or emit events. Any nested calls are constrained to\n    /// also be static calls.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.view(Token::at(address).balance_of_public(recipient));\n    /// ```\n    ///\n    pub unconstrained fn view<let M: u32, let N: u32, T>(self, call: PublicStaticCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.view(self.context)\n    }\n}\n\n/// Implementation for `ContractSelf` in utility execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"utility\")]`.\n/// Utility functions are unconstrained functions that can read private state for offchain queries.\n/// They are typically used for view functions that need to access private notes (e.g. a Token's balance_of function).\nimpl<Storage> ContractSelf<UtilityContext, Storage, (), (), (), (), ()> {\n    /// Creates a new `ContractSelf` instance for a utility function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_utility(context: UtilityContext, storage: Storage) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self: (),\n            enqueue_self: (),\n            call_self_static: (),\n            enqueue_self_static: (),\n            internal: (),\n        }\n    }\n}\n"
+      "source": "use crate::{\n    context::{\n        calls::{PrivateCall, PrivateStaticCall, PublicCall, PublicStaticCall},\n        private_context::PrivateContext,\n        public_context::PublicContext,\n        utility_context::UtilityContext,\n    },\n    event::{\n        event_emission::{emit_event_in_private, emit_event_in_public},\n        event_interface::EventInterface,\n        event_message::EventMessage,\n    },\n};\nuse protocol_types::{\n    address::AztecAddress,\n    constants::NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    traits::{Deserialize, Serialize},\n};\n\n/// `ContractSelf` is the core interface for interacting with an Aztec contract's own state and context.\n///\n/// This struct is automatically injected into every #[external(...)] contract function by the Aztec macro system and is\n/// accessible through the `self` variable.\n///\n/// # Usage in Contract Functions\n///\n/// Once injected, you can use `self` to:\n/// - Access storage: `self.storage.balances.at(owner).read()`\n/// - Call contracts: `self.call(Token::at(address).transfer(recipient, amount))`\n/// - Emit events: `self.emit(event).deliver_to(recipient, delivery_mode)` (private) or `self.emit(event)` (public)\n/// - Get the contract address: `self.address`\n/// - Get the caller: `self.msg_sender()`\n/// - Access low-level Aztec.nr APIs through the context: `self.context`\n///\n/// # Example\n///\n/// ```noir\n/// #[external(\"private\")]\n/// fn withdraw(amount: u128, recipient: AztecAddress) {\n///     // Get the caller of this function\n///     let sender = self.msg_sender().unwrap();\n///\n///     // Access storage\n///     let token = self.storage.donation_token.get_note().get_address();\n///\n///     // Call contracts\n///     self.call(Token::at(token).transfer(recipient, amount));\n/// }\n/// ```\n///\n/// # Type Parameters\n///\n/// - `Context`: The execution context type - either `&mut PrivateContext`, `PublicContext`, or `UtilityContext`\n/// - `Storage`: The contract's storage struct (defined with `#[storage]`), or `()` if the contract has no storage\n/// - `CallSelf`: Macro-generated type for calling contract's own non-view functions\n/// - `EnqueueSelf`: Macro-generated type for enqueuing calls to the contract's own non-view functions\n/// - `CallSelfStatic`: Macro-generated type for calling contract's own view functions\n/// - `EnqueueSelfStatic`: Macro-generated type for enqueuing calls to the contract's own view functions\npub struct ContractSelf<Context, Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> {\n    /// The address of this contract\n    pub address: AztecAddress,\n    /// The contract's storage instance, representing the struct to which the `#[storage]` macro was applied in your\n    /// contract. If the contract has no storage, the type of this will be `()`.\n    ///\n    /// This storage instance is specialized for the current execution context (private, public, or utility) and\n    /// provides access to the contract's state variables. Each state variable accepts the context as a generic\n    /// parameter, which determines its available functionality. For example, a PublicImmutable variable can be read\n    /// from any context (public, private, or utility) but can only be written to from public contexts.\n    ///\n    /// # Developer Note\n    /// If you've arrived here while trying to access your contract's storage while the `Storage` generic type is set to\n    /// unit type `()`, it means you haven't yet defined a Storage struct using the #[storage] macro in your contract.\n    /// For guidance on setting this up, please refer to our docs:\n    /// https://docs.aztec.network/developers/docs/guides/smart_contracts/storage\n    pub storage: Storage,\n    /// The execution context whose type is determined by the #[external(...)] attribute of the contract function based\n    /// on the external function type (private, public, or utility).\n    pub context: Context,\n\n    /// Provides type-safe methods for calling this contract's own non-view functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.call_self.some_private_function(args)\n    /// ```\n    pub call_self: CallSelf,\n    /// Provides type-safe methods for enqueuing calls to this contract's own non-view functions.\n    ///\n    /// In private context this will be a struct with appropriate methods;\n    /// in public and utility contexts it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.enqueue_self.some_public_function(args)\n    /// ```\n    pub enqueue_self: EnqueueSelf,\n    /// Provides type-safe methods for calling this contract's own view functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.call_self_static.some_view_function(args)\n    /// ```\n    pub call_self_static: CallSelfStatic,\n    /// Provides type-safe methods for enqueuing calls to this contract's own view functions.\n    ///\n    /// In private context this will be a struct with appropriate methods;\n    /// in public and utility contexts it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.enqueue_self_static.some_public_view_function(args)\n    /// ```\n    pub enqueue_self_static: EnqueueSelfStatic,\n    /// Provides type-safe methods for calling internal functions.\n    ///\n    /// In private and public contexts this will be a struct with appropriate methods;\n    /// in utility context it will be the unit type `()`.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.internal.some_internal_function(args)\n    /// ```\n    pub internal: CallInternal,\n}\n\n/// Implementation for `ContractSelf` in private execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"private\")]`.\n/// Private functions execute client-side and generate zero-knowledge proofs of their execution.\nimpl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> ContractSelf<&mut PrivateContext, Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> {\n    /// Creates a new `ContractSelf` instance for a private function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_private(\n        context: &mut PrivateContext,\n        storage: Storage,\n        call_self: CallSelf,\n        enqueue_self: EnqueueSelf,\n        call_self_static: CallSelfStatic,\n        enqueue_self_static: EnqueueSelfStatic,\n        internal: CallInternal,\n    ) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self,\n            enqueue_self,\n            call_self_static,\n            enqueue_self_static,\n            internal,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call. This is similar to `msg.sender` in Solidity.\n    ///\n    /// Important Note: Since Aztec doesn't have a concept of an EoA ( Externally-owned Account), the msg_sender is\n    /// \"null\" for the first function call of every transaction. The first function call of a tx is likely to be a call\n    /// to the user's account contract, so this quirk will most often be handled by account contract developers.\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract or\n    ///   a user's account contract). Returns `Option<AztecAddress>::none` for the first function call of the tx. No\n    ///   other _private_ function calls in the tx will have a `none` msg_sender, but _public_ function calls might (see\n    ///   the PublicContext).\n    ///\n    pub fn msg_sender(self) -> Option<AztecAddress> {\n        let maybe_msg_sender = self.context.msg_sender_unsafe();\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Emits an event privately.\n    ///\n    /// Unlike public events, private events do not reveal their contents publicly. They instead create an\n    /// [EventMessage] containing the private event information, which **MUST** be delivered to a recipient via\n    /// [EventMessage::deliver_to] in order for them to learn about the event. Multiple recipients can have the same\n    /// message be delivered to them.\n    ///\n    /// # Example\n    /// ```noir\n    /// #[event]\n    /// struct Transfer { from: AztecAddress, to: AztecAddress, amount: u128 }\n    ///\n    /// #[external(\"private\")]\n    /// fn transfer(to: AztecAddress, amount: u128) {\n    ///     let from = self.msg_sender().unwrap();\n    ///\n    ///     let message: EventMessage = self.emit(Transfer { from, to, amount });\n    ///     message.deliver_to(from, MessageDelivery.UNCONSTRAINED_OFFCHAIN);\n    ///     message.deliver_to(to, MessageDelivery.CONSTRAINED_ONCHAIN);\n    /// }\n    /// ```\n    ///\n    /// # Cost\n    ///\n    /// Private event emission always results in the creation of a nullifer, which acts as a commitment to the event and\n    /// is used by third parties to verify its authenticity. See [EventMessage::deliver_to] for the costs associated to\n    /// delivery.\n    ///\n    /// # Privacy\n    ///\n    /// The nullifier created when emitting a private event leaks nothing about the content of the event - it's a\n    /// commitment that includes a random value, so even with full knowledge of the event preimage determining if an\n    /// event was emitted or not requires brute-forcing the entire `Field` space.\n    pub fn emit<Event>(&mut self, event: Event) -> EventMessage<Event>\n    where\n        Event: EventInterface + Serialize,\n    {\n        emit_event_in_private(self.context, event)\n    }\n\n    /// Makes a call to the private function defined by the `call` parameter.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the private function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.call(Token::at(address).transfer_in_private(recipient, amount));\n    /// ```\n    ///\n    /// This enables contracts to interact with each other while maintaining\n    /// privacy. This \"composability\" of private contract functions is a key\n    /// feature of the Aztec network.\n    ///\n    /// If a user's transaction includes multiple private function calls, then\n    /// by the design of Aztec, the following information will remain private[1]:\n    /// - The function selectors and contract addresses of all private function\n    ///   calls will remain private, so an observer of the public mempool will\n    ///   not be able to look at a tx and deduce which private functions have\n    ///   been executed.\n    /// - The arguments and return values of all private function calls will\n    ///   remain private.\n    /// - The person who initiated the tx will remain private.\n    /// - The notes and nullifiers and private logs that are emitted by all\n    ///   private function calls will (if designed well) not leak any user\n    ///   secrets, nor leak which functions have been executed.\n    ///\n    /// [1] Caveats: Some of these privacy guarantees depend on how app\n    /// developers design their smart contracts. Some actions _can_ leak\n    /// information, such as:\n    /// - Calling an internal public function.\n    /// - Calling a public function and not setting msg_sender to Option::none\n    ///   (see https://github.com/AztecProtocol/aztec-packages/pull/16433)\n    /// - Calling any public function will always leak details about the nature\n    ///   of the transaction, so devs should be careful in their contract\n    ///   designs. If it can be done in a private function, then that will give\n    ///   the best privacy.\n    /// - Not padding the side-effects of a tx to some standardized, uniform\n    ///   size. The kernel circuits can take hints to pad side-effects, so a\n    ///   wallet should be able to request for a particular amount of padding.\n    ///   Wallets should ideally agree on some standard.\n    ///   - Padding should include:\n    ///     - Padding the lengths of note & nullifier arrays\n    ///     - Padding private logs with random fields, up to some standardized\n    ///       size.\n    /// See also: https://docs.aztec.network/developers/resources/considerations/privacy_considerations\n    ///\n    /// # Advanced\n    /// * The call is added to the private call stack and executed by kernel\n    ///   circuits after this function completes\n    /// * The called function can modify its own contract's private state\n    /// * Side effects from the called function are included in this transaction\n    /// * The call inherits the current transaction's context and gas limits\n    ///\n    pub fn call<let M: u32, let N: u32, T>(&mut self, call: PrivateCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.call(self.context)\n    }\n\n    /// Makes a read-only call to the private function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state, emit L2->L1 messages, nor emit events. Any nested\n    /// calls are constrained to also be static calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only private function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.view(Token::at(address).balance_of_private(recipient));\n    /// ```\n    pub fn view<let M: u32, let N: u32, T>(&mut self, call: PrivateStaticCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.view(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// to be executed later.\n    ///\n    /// Unlike private functions which execute immediately on the user's device,\n    /// public function calls are \"enqueued\" and executed some time later by a\n    /// block proposer.\n    ///\n    /// This means a public function cannot return any values back to a private\n    /// function, because by the time the public function is being executed,\n    /// the private function which called it has already completed execution.\n    /// (In fact, the private function has been executed and proven, along with\n    /// all other private function calls of the user's tx. A single proof of the\n    /// tx has been submitted to the Aztec network, and some time later a\n    /// proposer has picked the tx up from the mempool and begun executing all\n    /// of the enqueued public functions).\n    ///\n    /// # Privacy warning\n    /// Enqueueing a public function call is an inherently leaky action.\n    /// Many interesting applications will require some interaction with public\n    /// state, but smart contract developers should try to use public function\n    /// calls sparingly, and carefully.\n    /// _Internal_ public function calls are especially leaky, because they\n    /// completely leak which private contract made the call.\n    /// See also: https://docs.aztec.network/developers/resources/considerations/privacy_considerations\n    ///\n    /// # Arguments\n    /// * `call` - The interface representing the public function to enqueue.\n    pub fn enqueue<let M: u32, let N: u32, T>(&mut self, call: PublicCall<M, N, T>) {\n        call.enqueue(self.context)\n    }\n\n    /// Enqueues a read-only call to the public function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state, emit L2->L1 messages, nor emit events. Any nested\n    /// calls are constrained to also be static calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_view(MyContract::at(address).assert_timestamp_less_than(timestamp));\n    /// ```\n    pub fn enqueue_view<let M: u32, let N: u32, T>(&mut self, call: PublicStaticCall<M, N, T>) {\n        call.enqueue_view(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// to be executed later.\n    ///\n    /// As per `enqueue`, but hides this calling contract's address from the\n    /// target public function.\n    /// This means the origin of the call (msg_sender) will not be publicly\n    /// visible to any blockchain observers, nor to the target public function.\n    /// When the target public function reads `context.msg_sender()` it will\n    /// receive an `Option<AztecAddress>::none`.\n    ///\n    /// NOTES:\n    /// - Not all public functions will accept a msg_sender of \"none\". Many\n    ///   public functions will require that msg_sender is \"some\" and will\n    ///   revert otherwise. Therefore, if using `enqueue_incognito`, you must\n    ///   understand whether the function you're calling will accept a\n    ///   msg_sender of \"none\".\n    ///   Lots of public bookkeeping patterns rely on knowing which address made\n    ///   the call, so as to ascribe state against the caller's address.\n    ///   (There are patterns whereby bookkeeping could instead be done in\n    ///   private-land).\n    /// - If you are enqueueing a call to an _internal_ public function (i.e.\n    ///   a public function that will only accept calls from other functions\n    ///   of its own contract), then by definition a call to it cannot possibly\n    ///   be \"incognito\": the msg_sender must be its own address, and indeed the\n    ///   called public function will assert this. Tl;dr this is not usable for\n    ///   enqueued internal public calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_incognito(Token::at(address).increase_total_supply_by(amount));\n    /// ```\n    ///\n    /// Advanced:\n    /// - The kernel circuits will permit _any_ private function to set the\n    ///   msg_sender field of any enqueued public function call to\n    ///   NULL_MSG_SENDER_CONTRACT_ADDRESS.\n    /// - When the called public function calls `PublicContext::msg_sender()`,\n    ///   aztec-nr will translate NULL_MSG_SENDER_CONTRACT_ADDRESS into\n    ///   `Option<AztecAddress>::none` for familiarity to devs.\n    ///\n    pub fn enqueue_incognito<let M: u32, let N: u32, T>(&mut self, call: PublicCall<M, N, T>) {\n        call.enqueue_incognito(self.context)\n    }\n\n    /// Enqueues a read-only call to the public function defined by the `call` parameter.\n    ///\n    /// As per `enqueue_view`, but hides this calling contract's address from\n    /// the target public function.\n    ///\n    /// See `enqueue_incognito` for more details relating to hiding msg_sender.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to enqueue.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.enqueue_view_incognito(MyContract::at(address).assert_timestamp_less_than(timestamp));\n    /// ```\n    ///\n    pub fn enqueue_view_incognito<let M: u32, let N: u32, T>(\n        &mut self,\n        call: PublicStaticCall<M, N, T>,\n    ) {\n        call.enqueue_view_incognito(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// and designates it to be the teardown function for this tx. Only one teardown\n    /// function call can be made by a tx.\n    ///\n    /// Niche function: Only wallet developers and paymaster contract developers\n    /// (aka Fee-payment contracts) will need to make use of this function.\n    ///\n    /// Aztec supports a three-phase execution model: setup, app logic, teardown.\n    /// The phases exist to enable a fee payer to take on the risk of paying\n    /// a transaction fee, safe in the knowledge that their payment (in whatever\n    /// token or method the user chooses) will succeed, regardless of whether\n    /// the app logic will succeed. The \"setup\" phase ensures the fee payer\n    /// has sufficient balance to pay the proposer their fees.\n    /// The teardown phase is primarily intended to: calculate exactly\n    /// how much the user owes, based on gas consumption, and refund the user\n    /// any change.\n    ///\n    /// Note: in some cases, the cost of refunding the user (i.e. DA costs of\n    /// tx side-effects) might exceed the refund amount. For app logic with\n    /// fairly stable and predictable gas consumption, a material refund amount\n    /// is unlikely. For app logic with unpredictable gas consumption, a\n    /// refund might be important to the user (e.g. if a hefty function reverts\n    /// very early). Wallet/FPC/Paymaster developers should be mindful of this.\n    ///\n    /// See `enqueue` for more information about enqueuing public function calls.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to designate as teardown.\n    ///\n    pub fn set_as_teardown<let M: u32, let N: u32, T>(&mut self, call: PublicCall<M, N, T>) {\n        call.set_as_teardown(self.context)\n    }\n\n    /// Enqueues a call to the public function defined by the `call` parameter,\n    /// and designates it to be the teardown function for this tx. Only one teardown\n    /// function call can be made by a tx.\n    ///\n    /// As per `set_as_teardown`, but hides this calling contract's address from\n    /// the target public function.\n    ///\n    /// See `enqueue_incognito` for more details relating to hiding msg_sender.\n    ///\n    pub fn set_as_teardown_incognito<let M: u32, let N: u32, T>(\n        &mut self,\n        call: PublicCall<M, N, T>,\n    ) {\n        call.set_as_teardown_incognito(self.context)\n    }\n}\n\n/// Implementation for `ContractSelf` in public execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"public\")]`.\n/// Public functions are executed by the sequencer in the Aztec Virtual Machine (AVM) and can work only with public\n/// state.\nimpl<Storage, CallSelf, CallSelfStatic, CallInternal> ContractSelf<PublicContext, Storage, CallSelf, (), CallSelfStatic, (), CallInternal> {\n    /// Creates a new `ContractSelf` instance for a public function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_public(\n        context: PublicContext,\n        storage: Storage,\n        call_self: CallSelf,\n        call_self_static: CallSelfStatic,\n        internal: CallInternal,\n    ) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self,\n            enqueue_self: (),\n            call_self_static,\n            enqueue_self_static: (),\n            internal,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    ///\n    /// This is similar to `msg.sender` in Solidity (hence the name).\n    ///\n    /// Important Note: If the calling function is a _private_ function, then it had the option of hiding its address\n    /// when enqueuing this public function call. In such cases, this `context.msg_sender()` method will return\n    /// `Option<AztecAddress>::none`. If the calling function is a _public_ function, it will always return an\n    /// `Option<AztecAddress>::some` (i.e. a non-null value).\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract or\n    ///   a user's account contract).\n    ///\n    /// # Advanced\n    /// * Value is provided by the AVM sender opcode\n    /// * In nested calls, this is the immediate caller, not the original transaction sender\n    ///\n    pub fn msg_sender(self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = self.context.msg_sender_unsafe();\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Emits an event publicly.\n    ///\n    /// Public events are emitted as plaintext and are therefore visible to everyone. This is is the same as Solidity\n    /// events on EVM chains.\n    ///\n    /// Unlike private events, they don't require delivery of an event message.\n    ///\n    /// # Example\n    /// ```noir\n    /// #[event]\n    /// struct Update { value: Field }\n    ///\n    /// #[external(\"public\")]\n    /// fn publish_update(value: Field) {\n    ///     self.emit(Update { value });\n    /// }\n    /// ```\n    ///\n    /// # Cost\n    ///\n    /// Public event emission is achieved by emitting public transaction logs. A total of `N+1` fields are emitted,\n    /// where `N` is the serialization length of the event.\n    pub fn emit<Event>(&mut self, event: Event)\n    where\n        Event: EventInterface + Serialize,\n    {\n        emit_event_in_public(self.context, event);\n    }\n\n    /// Makes the call to the public function defined by the `call` parameter.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.call(Token::at(address).transfer_in_public(recipient, amount));\n    /// ```\n    ///\n    pub unconstrained fn call<let M: u32, let N: u32, T>(self, call: PublicCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.call(self.context)\n    }\n\n    /// Makes the read-only call to the public function defined by the `call` parameter.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function\n    /// cannot modify state or emit events. Any nested calls are constrained to\n    /// also be static calls.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.view(Token::at(address).balance_of_public(recipient));\n    /// ```\n    ///\n    pub unconstrained fn view<let M: u32, let N: u32, T>(self, call: PublicStaticCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.view(self.context)\n    }\n}\n\n/// Implementation for `ContractSelf` in utility execution contexts.\n///\n/// This implementation is used when a contract function is marked with `#[external(\"utility\")]`.\n/// Utility functions are unconstrained functions that can read private state for offchain queries.\n/// They are typically used for view functions that need to access private notes (e.g. a Token's balance_of function).\nimpl<Storage> ContractSelf<UtilityContext, Storage, (), (), (), (), ()> {\n    /// Creates a new `ContractSelf` instance for a utility function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new_utility(context: UtilityContext, storage: Storage) -> Self {\n        Self {\n            context,\n            storage,\n            address: context.this_address(),\n            call_self: (),\n            enqueue_self: (),\n            call_self_static: (),\n            enqueue_self_static: (),\n            internal: (),\n        }\n    }\n}\n"
     },
     "77": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/event/event_selector.nr",