@aztec/protocol-contracts 2.0.3 → 2.1.0-rc.2
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.
|
@@ -36,7 +36,7 @@
|
|
|
36
36
|
}
|
|
37
37
|
},
|
|
38
38
|
"bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHwoAAQACgEQlAAAARSUAAABNLgIAAYBEKAIAAgSARCcCAwQBOw4AAwACKACAQwQAAyYlAAADqx4CAAIJJwIDAQEkAgACAAAAaSUAAAPUHgIAAgEnAgQAACsCAAUAAAAAAAAAAAIAAAAAAAAAAC0IAQYnAgcEBQAIAQcBJwMGBAEAIgYCBy0KBwgtDgQIACIIAggtDgQIACIIAggtDgQIACIIAggtDgUILQgBBQAAAQIBLQgBBwAAAQIBLQgBCAAAAQIBLQgBCQAAAQIBJwIKAAEtCAELJwIMBAQACAEMAScDCwQBACILAgwtCgwNLQ4KDQAiDQINLQ4CDQAiDQINLQ4EDS0OCwUtDgYHJwICBAItDgIIJwICAQAtDgIJJwIGBAAnAgoEAS0KBgEjAAABSw0iAAGAQwAGJAIABgAAAx8jAAABYC0LBwYtCwYLACILAgstDgsGLQgBCycCDAQFAAgBDAEnAwsEAQAiBgIMJwINBAQAIgsCDj8PAAwADi0LBQYtCwgMLQ4GBS0OCwctDgwILQ4DCQAqCwoFLQsFAwoqAwQFCioFAgQkAgAEAAAB0SUAAAPmHgIAAgYvCgADAAQcCgQFBBwKBQMAAioEAwUsAgADAC1eCYuCuje0O5mhMWEY/SDUL1FmyenxP7XqZaltHgptBCoFAwQcCgQGBBwKBgUAAioEBQYEKgYDBBwKBAcBHAoHBgAcCgYHAQIqBAYILAIABAAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqCAQJHAoJCgQcCgoIAAIqCQgKBCoKAwkcCgkKARwKCgMAHAoDCgECKgkDCwQqCwQJHAoJCwQcCgsEABwKBAkFFgoKBBwKAwoFHAoEAwUEKgoJBBwKCAkFFgoHCBwKBgcFHAoIBgUEKgcJCBwKBQkFDCoCCQUpAgACBQABUYAkAgAFAAADBiMAAALuBCoHCAMEKgYCBAAqAwQCLQoCASMAAAMeBCoKBAUEKgMCBAAqBQQCLQoCASMAAAMeJi0LCAYMKgEGCyQCAAsAAAM1IwAAA50tCwcLACILAg0AKg0BDi0LDgwtCwUNACINAg8AKg8BEC0LEA4AKgwODy0LCQwuAgALgAMoAIAEBAAFJQAAA/guCIAFAA4AIg4CEAAqEAERLQ4PES0ODQUtDg4HLQ4GCC0ODAkjAAADnQAqAQoGLQoGASMAAAFLKACABAR4AA0AAACABIADJACAAwAAA9MqAQABBfeh86+lrdTKPAQCASYqAQABBZ1scJlb3/zTPAQCASYqAQABBQLcbieAdhKdPAQCASYuAYADgAYLAIAGAAKAByQAgAcAAAQTIwAABB4uAIADgAUjAAAEhS4AAAGABQEAAAGABAABAQCAA4AEgAkuAIADgAouAIAFgAsLAIAKgAmADCQAgAwAAARxLgGACoAILgSACIALAQCACgACgAoBAIALAAKACyMAAARAKAGABQQAAQMAgAYAAoAGIwAABIUm",
|
|
39
|
-
"debug_symbols": "
|
|
39
|
+
"debug_symbols": "pZjbbuM4DIbfxde90IGUyL7KoCjSNh0ECNIi0y6wKPLuS9qi7HQhodHcxJ/p+DdJ06Tsr+ll//T5+/Fwen37M93/+pqezofj8fD78fj2vPs4vJ3E+jU5/aEw3ce7ifJ0D3cTh3njnStbnO6zbL3sezV4LBBTAbBDYIfQLGiWZJYEBlQgR4NcQD1awC7B3kAFowIvEBwYUAEfDXKBEAxSgaiCSSEVmKOYAQugWdAsySxzFDNQgTmKGXKBOYoZ9BKSw8DOAAx4geiiARVQD4MTQNEJXiEVUDcWQAPRCRJXVDcWoAJkFjILm4WLBVw0UJ0goDlcQMNhgeAN0IALRP0zKFABUJ+zQi6AZpmdn0F0ojgPWSwxKUiAkQTIG6hFL6EFAJINDFRALwpegQqAWoKCWiQcRLWAAhVIZtEbByigGQO5etIKX0AcA/EwBWegFvEnRbWwglhQ3EhaNguYRcsGvYJaxJ+kIWNUwAIaMoKCnZW5WAgMzKLVgqjAi/NZ75daslbLDN4sXi0SRQ5qEZ+znqWFRPNZ4jzprVyg1A9FZ1AtXECzmvR0zeoMaBaUm5v0PykYlBKlHAxMR+Oage1aXK7FzhmAARXwwaAo8+Lz5XI3WSt7/Djv99rJNr1NOt777rw/fUz3p8/j8W76Z3f8nP/05313mrcfu7MclTj2pxfZiuDr4bhXutytZ7v2qT5ISsvpwgGrhHTNKxHfFpGmQCYizFxFEl9phLZGjC5D0RDm3NK4IZjcDKYjkoPLRSOHTT7wOqfYcYMxBnODEVwrlNRJR4gZLR0hshtIR/aZaiQutSKhtoI0BAtEWkJY05nzlQR3kqEP8lIZG4EIcF1cvTCkN1sYQGsiok/XGp0KjTUO8GsiZJReK3TqM8j8tkCC47ZGbGsgW2VJfx7zIhCbF3GTz/9p9MoTgzUMj5AHNRJXDeKxWLKvpZGja2t0ClQKsT7wmTv54F59hVpeaUiBwR5VRhpS8C7UjuFSuzZCJ58AySoUgFc/PP88ndK8a+MK7XT2WgbmWuQpQrNlhE51pRzNDSkMv+nidK3RaaCypobaeNJGI6eh/gnN/hk62YiMFomsVNtehE5tBFwrVBhjaxRE15sn2a3zRBZWzRHdjYbtaQO36WDfo4mdKkVkuy+YPLc1On00ukRWZLJscNTMCPREnPNVxLWndMTeXIlYRWQVD02RXkoSUE0Jt4sk5k6RwDpnIa1plZXUDRrriJMVzKiGqxqbZ+YmDaS13nnQj+RqPhLAqAZWjU1jv02DqGpsFrU3aWSf66AEGtVYh+2mHd6mscaSedAP8vXeEvhRjVqnhDioQXU8EMcxDfbrWw8Ma9R8MA4+L7w+Lzz4vESp8DoeaCynEerbV4Qw9sxJO3W1n2568neNH4+p0B4xmHsrIV6XD3FT6z78fFlYXyQ5DC4sk91Yzvi3S9PvCg+yu3s+nK8+p15U6nzYPR33Zff18/S8Ofrx77sdsc+x7+e35/3L53mvSus3Wfn55WVOy0fNB/0Iq7vyTuvJ6a6fj4LspoeLOvMf"
|
|
40
40
|
},
|
|
41
41
|
{
|
|
42
42
|
"name": "process_message",
|
|
@@ -359,7 +359,7 @@
|
|
|
359
359
|
}
|
|
360
360
|
},
|
|
361
361
|
"bytecode": "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",
|
|
362
|
-
"debug_symbols": "
|
|
362
|
+
"debug_symbols": "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"
|
|
363
363
|
},
|
|
364
364
|
{
|
|
365
365
|
"name": "publish_for_public_execution",
|
|
@@ -2380,7 +2380,7 @@
|
|
|
2380
2380
|
}
|
|
2381
2381
|
},
|
|
2382
2382
|
"bytecode": "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",
|
|
2383
|
-
"debug_symbols": "
|
|
2383
|
+
"debug_symbols": "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"
|
|
2384
2384
|
},
|
|
2385
2385
|
{
|
|
2386
2386
|
"name": "sync_private_state",
|
|
@@ -2602,7 +2602,7 @@
|
|
|
2602
2602
|
}
|
|
2603
2603
|
},
|
|
2604
2604
|
"bytecode": "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",
|
|
2605
|
-
"debug_symbols": "
|
|
2605
|
+
"debug_symbols": "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"
|
|
2606
2606
|
}
|
|
2607
2607
|
],
|
|
2608
2608
|
"outputs": {
|
|
@@ -3434,7 +3434,7 @@
|
|
|
3434
3434
|
},
|
|
3435
3435
|
"176": {
|
|
3436
3436
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/delayed_public_mutable.nr",
|
|
3437
|
-
"source": "use dep::protocol_types::{\n delayed_public_mutable::{\n delayed_public_mutable_values::{unpack_delay_change, unpack_value_change},\n DelayedPublicMutableValues,\n ScheduledDelayChange,\n ScheduledValueChange,\n },\n traits::Packable,\n};\n\nuse crate::{\n context::{PrivateContext, PublicContext, UtilityContext},\n state_vars::storage::HasStorageSlot,\n utils::with_hash::WithHash,\n};\n\nmod test;\n\npub struct DelayedPublicMutable<T, let InitialDelay: u64, Context> {\n context: Context,\n storage_slot: Field,\n}\n\n// This will make the Aztec macros require that T implements the Packable and Eq traits, and allocate `M` storage\n// slots to this state variable.\nimpl<T, let InitialDelay: u64, Context, let M: u32> HasStorageSlot<M> for DelayedPublicMutable<T, InitialDelay, Context>\nwhere\n WithHash<DelayedPublicMutableValues<T, InitialDelay>, _>: Packable<N = M>,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\n// DelayedPublicMutable<T> stores a value of type T that is:\n// - publicly known (i.e. unencrypted)\n// - mutable in public\n// - readable in private with no contention (i.e. multiple parties can all read the same value without blocking one\n// another nor needing to coordinate)\n// This is famously a hard problem to solve. DelayedPublicMutable makes it work by introducing a delay to public mutation:\n// the value is not changed immediately but rather a value change is scheduled to happen in the future after some delay\n// measured in seconds. Reads in private are only valid as long as they are included in a block with a timestamp not\n// too far into the future, so that they can guarantee the value will not have possibly changed by then (because of the\n// delay). The delay for changing a value is initially equal to InitialDelay, but can be changed by calling\n// `schedule_delay_change`.\nimpl<T, let InitialDelay: u64, Context> DelayedPublicMutable<T, InitialDelay, Context> {\n pub fn new(context: Context, storage_slot: Field) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Self { context, storage_slot }\n }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, &mut PublicContext>\nwhere\n T: Eq,\n{\n\n pub fn schedule_value_change(self, new_value: T)\n where\n T: Packable,\n {\n let _value_change = self.schedule_and_return_value_change(new_value);\n }\n\n pub fn schedule_and_return_value_change(self, new_value: T) -> ScheduledValueChange<T>\n where\n T: Packable,\n {\n let mut value_change = self.read_value_change();\n let delay_change = self.read_delay_change();\n\n let current_timestamp = self.context.timestamp();\n let current_delay = delay_change.get_current(current_timestamp);\n\n // TODO: make this configurable\n // https://github.com/AztecProtocol/aztec-packages/issues/5501\n let timestamp_of_change = current_timestamp + current_delay;\n value_change.schedule_change(\n new_value,\n current_timestamp,\n current_delay,\n timestamp_of_change,\n );\n\n self.write(value_change, delay_change);\n\n value_change\n }\n\n pub fn schedule_delay_change(self, new_delay: u64)\n where\n T: Packable,\n {\n let mut delay_change = self.read_delay_change();\n\n let current_timestamp = self.context.timestamp();\n\n delay_change.schedule_change(new_delay, current_timestamp);\n\n self.write(self.read_value_change(), delay_change);\n }\n\n pub fn get_current_value(self) -> T\n where\n T: Packable,\n {\n let current_timestamp = self.context.timestamp();\n let value_change = self.read_value_change();\n\n value_change.get_current_at(current_timestamp)\n }\n\n pub fn get_current_delay(self) -> u64\n where\n T: Packable,\n {\n let current_timestamp = self.context.timestamp();\n self.read_delay_change().get_current(current_timestamp)\n }\n\n pub fn get_scheduled_value(self) -> (T, u64)\n where\n T: Packable,\n {\n self.read_value_change().get_scheduled()\n }\n\n pub fn get_scheduled_delay(self) -> (u64, u64)\n where\n T: Packable,\n {\n self.read_delay_change().get_scheduled()\n }\n\n fn read_value_change(self) -> ScheduledValueChange<T>\n where\n T: Packable,\n {\n // We don't read ScheduledValueChange directly by having it implement Packable because ScheduledValueChange\n // and ScheduledDelayChange are packed together (sdc and svc.timestamp_of_change are stored in the same slot).\n let packed = self.context.storage_read(self.storage_slot);\n unpack_value_change::<T, <T as Packable>::N>(packed)\n }\n\n fn read_delay_change(self) -> ScheduledDelayChange<InitialDelay>\n where\n T: Packable,\n {\n // Since all ScheduledDelayChange member are packed into a single field, we can read a single storage slot\n // here and skip the ones that correspond to ScheduledValueChange members. We are abusing the fact that\n // the field containing the ScheduledDelayChange data is the first one in the storage layout - otherwise we'd\n // need to offset the storage slot to get the position where it'd land.\n // We don't read ScheduledDelayChange directly by having it implement Packable because ScheduledValueChange\n // and ScheduledDelayChange are packed together (sdc and svc.timestamp_of_change are stored in the same slot).\n let packed = self.context.storage_read(self.storage_slot);\n unpack_delay_change::<InitialDelay>(packed)\n }\n\n fn write(\n self,\n value_change: ScheduledValueChange<T>,\n delay_change: ScheduledDelayChange<InitialDelay>,\n )\n where\n T: Packable,\n {\n // Whenever we write to public storage, we write both the value change and delay change to storage at once.\n // We do so by wrapping them in a single struct (`DelayedPublicMutableValues`). Then we wrap the resulting struct in\n // `WithHash`.\n // Wrapping in `WithHash` makes for more costly writes but it also makes private proofs much simpler because\n // they only need to produce a historical proof for the hash, which results in a single inclusion proof (as\n // opposed to 4 in the best case scenario in which T is a single field). Private delayed public mutable reads are\n // assumed to be much more frequent than public writes, so this tradeoff makes sense.\n let values = WithHash::new(DelayedPublicMutableValues::new(value_change, delay_change));\n\n self.context.storage_write(self.storage_slot, values);\n }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, &mut PrivateContext>\nwhere\n T: Eq,\n{\n pub fn get_current_value(self) -> T\n where\n T: Packable,\n {\n // When reading the current value in private we construct a historical state proof for the public value.\n // However, since this value might change, we must constrain the maximum transaction timestamp as this proof\n // will only be valid for the time we can ensure the value will not change, which will depend on the\n // current delay and any scheduled delay changes.\n let (value_change, delay_change, historical_timestamp) =\n self.historical_read_from_public_storage();\n\n // We use the effective minimum delay as opposed to the current delay at the historical timestamp (timestamp of\n // the historical block against which we are executing the private part of the tx) as this one also takes into\n // consideration any scheduled delay changes.\n // For example, consider a scenario in which at timestamp `x` the current delay was 86400 seconds (1 day). We\n // may naively think that the earliest we could change the value would be at timestamp `x + 86400` by scheduling\n // immediately after the historical timestamp, i.e. at timestamp `x + 1`. But if there was a delay change scheduled\n // for timestamp `y` to reduce the delay to 43200 seconds (12 hours), then if a value change was scheduled at\n // timestamp `y` it would go into effect at timestamp `y + 43200`, which is earlier than what we'd expect if we\n // only considered the current delay.\n let effective_minimum_delay =\n delay_change.get_effective_minimum_delay_at(historical_timestamp);\n let time_horizon =\n value_change.get_time_horizon(historical_timestamp, effective_minimum_delay);\n\n // We prevent this transaction from being included in any timestamp after the time horizon, ensuring that the\n // historical public value matches the current one, since it can only change after the horizon.\n self.context.set_include_by_timestamp(time_horizon);\n\n value_change.get_current_at(historical_timestamp)\n }\n\n fn historical_read_from_public_storage(\n self,\n ) -> (ScheduledValueChange<T>, ScheduledDelayChange<InitialDelay>, u64)\n where\n T: Packable,\n {\n let header = self.context.get_block_header();\n let address = self.context.this_address();\n\n let historical_timestamp = header.global_variables.timestamp;\n\n let values: DelayedPublicMutableValues<T, InitialDelay> =\n WithHash::historical_public_storage_read(header, address, self.storage_slot);\n\n (values.svc, values.sdc, historical_timestamp)\n }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, UtilityContext>\nwhere\n T: Eq,\n{\n pub unconstrained fn get_current_value(self) -> T\n where\n T: Packable,\n {\n let dpmv: DelayedPublicMutableValues<T, InitialDelay> =\n WithHash::utility_public_storage_read(self.context, self.storage_slot);\n\n let current_timestamp = self.context.timestamp();\n dpmv.svc.get_current_at(current_timestamp)\n }\n}\n"
|
|
3437
|
+
"source": "use dep::protocol_types::{\n delayed_public_mutable::{\n delayed_public_mutable_values::{unpack_delay_change, unpack_value_change},\n DelayedPublicMutableValues,\n ScheduledDelayChange,\n ScheduledValueChange,\n },\n traits::Packable,\n};\n\nuse crate::{\n context::{PrivateContext, PublicContext, UtilityContext},\n state_vars::storage::HasStorageSlot,\n utils::with_hash::WithHash,\n};\n\nmod test;\n\npub struct DelayedPublicMutable<T, let InitialDelay: u64, Context> {\n context: Context,\n storage_slot: Field,\n}\n\n// This will make the Aztec macros require that T implements the Packable and Eq traits, and allocate `M + 1` storage\n// slots to this state variable.\nimpl<T, let InitialDelay: u64, Context, let M: u32> HasStorageSlot<M + 1> for DelayedPublicMutable<T, InitialDelay, Context>\nwhere\n DelayedPublicMutableValues<T, InitialDelay>: Packable<N = M>,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\n// DelayedPublicMutable<T> stores a value of type T that is:\n// - publicly known (i.e. unencrypted)\n// - mutable in public\n// - readable in private with no contention (i.e. multiple parties can all read the same value without blocking one\n// another nor needing to coordinate)\n// This is famously a hard problem to solve. DelayedPublicMutable makes it work by introducing a delay to public mutation:\n// the value is not changed immediately but rather a value change is scheduled to happen in the future after some delay\n// measured in seconds. Reads in private are only valid as long as they are included in a block with a timestamp not\n// too far into the future, so that they can guarantee the value will not have possibly changed by then (because of the\n// delay). The delay for changing a value is initially equal to InitialDelay, but can be changed by calling\n// `schedule_delay_change`.\nimpl<T, let InitialDelay: u64, Context> DelayedPublicMutable<T, InitialDelay, Context> {\n pub fn new(context: Context, storage_slot: Field) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Self { context, storage_slot }\n }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, &mut PublicContext>\nwhere\n T: Eq,\n{\n\n pub fn schedule_value_change(self, new_value: T)\n where\n T: Packable,\n {\n let _value_change = self.schedule_and_return_value_change(new_value);\n }\n\n pub fn schedule_and_return_value_change(self, new_value: T) -> ScheduledValueChange<T>\n where\n T: Packable,\n {\n let mut value_change = self.read_value_change();\n let delay_change = self.read_delay_change();\n\n let current_timestamp = self.context.timestamp();\n let current_delay = delay_change.get_current(current_timestamp);\n\n // TODO: make this configurable\n // https://github.com/AztecProtocol/aztec-packages/issues/5501\n let timestamp_of_change = current_timestamp + current_delay;\n value_change.schedule_change(\n new_value,\n current_timestamp,\n current_delay,\n timestamp_of_change,\n );\n\n self.write(value_change, delay_change);\n\n value_change\n }\n\n pub fn schedule_delay_change(self, new_delay: u64)\n where\n T: Packable,\n {\n let mut delay_change = self.read_delay_change();\n\n let current_timestamp = self.context.timestamp();\n\n delay_change.schedule_change(new_delay, current_timestamp);\n\n self.write(self.read_value_change(), delay_change);\n }\n\n pub fn get_current_value(self) -> T\n where\n T: Packable,\n {\n let current_timestamp = self.context.timestamp();\n let value_change = self.read_value_change();\n\n value_change.get_current_at(current_timestamp)\n }\n\n pub fn get_current_delay(self) -> u64\n where\n T: Packable,\n {\n let current_timestamp = self.context.timestamp();\n self.read_delay_change().get_current(current_timestamp)\n }\n\n pub fn get_scheduled_value(self) -> (T, u64)\n where\n T: Packable,\n {\n self.read_value_change().get_scheduled()\n }\n\n pub fn get_scheduled_delay(self) -> (u64, u64)\n where\n T: Packable,\n {\n self.read_delay_change().get_scheduled()\n }\n\n fn read_value_change(self) -> ScheduledValueChange<T>\n where\n T: Packable,\n {\n // We don't read ScheduledValueChange directly by having it implement Packable because ScheduledValueChange\n // and ScheduledDelayChange are packed together (sdc and svc.timestamp_of_change are stored in the same slot).\n let packed = self.context.storage_read(self.storage_slot);\n unpack_value_change::<T, <T as Packable>::N>(packed)\n }\n\n fn read_delay_change(self) -> ScheduledDelayChange<InitialDelay>\n where\n T: Packable,\n {\n // Since all ScheduledDelayChange member are packed into a single field, we can read a single storage slot\n // here and skip the ones that correspond to ScheduledValueChange members. We are abusing the fact that\n // the field containing the ScheduledDelayChange data is the first one in the storage layout - otherwise we'd\n // need to offset the storage slot to get the position where it'd land.\n // We don't read ScheduledDelayChange directly by having it implement Packable because ScheduledValueChange\n // and ScheduledDelayChange are packed together (sdc and svc.timestamp_of_change are stored in the same slot).\n let packed = self.context.storage_read(self.storage_slot);\n unpack_delay_change::<InitialDelay>(packed)\n }\n\n fn write(\n self,\n value_change: ScheduledValueChange<T>,\n delay_change: ScheduledDelayChange<InitialDelay>,\n )\n where\n T: Packable,\n {\n // Whenever we write to public storage, we write both the value change and delay change to storage at once.\n // We do so by wrapping them in a single struct (`DelayedPublicMutableValues`). Then we wrap the resulting struct in\n // `WithHash`.\n // Wrapping in `WithHash` makes for more costly writes but it also makes private proofs much simpler because\n // they only need to produce a historical proof for the hash, which results in a single inclusion proof (as\n // opposed to 4 in the best case scenario in which T is a single field). Private delayed public mutable reads are\n // assumed to be much more frequent than public writes, so this tradeoff makes sense.\n let values = WithHash::new(DelayedPublicMutableValues::new(value_change, delay_change));\n\n self.context.storage_write(self.storage_slot, values);\n }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, &mut PrivateContext>\nwhere\n T: Eq,\n{\n pub fn get_current_value(self) -> T\n where\n T: Packable,\n {\n // When reading the current value in private we construct a historical state proof for the public value.\n // However, since this value might change, we must constrain the maximum transaction timestamp as this proof\n // will only be valid for the time we can ensure the value will not change, which will depend on the\n // current delay and any scheduled delay changes.\n let (value_change, delay_change, historical_timestamp) =\n self.historical_read_from_public_storage();\n\n // We use the effective minimum delay as opposed to the current delay at the historical timestamp (timestamp of\n // the historical block against which we are executing the private part of the tx) as this one also takes into\n // consideration any scheduled delay changes.\n // For example, consider a scenario in which at timestamp `x` the current delay was 86400 seconds (1 day). We\n // may naively think that the earliest we could change the value would be at timestamp `x + 86400` by scheduling\n // immediately after the historical timestamp, i.e. at timestamp `x + 1`. But if there was a delay change scheduled\n // for timestamp `y` to reduce the delay to 43200 seconds (12 hours), then if a value change was scheduled at\n // timestamp `y` it would go into effect at timestamp `y + 43200`, which is earlier than what we'd expect if we\n // only considered the current delay.\n let effective_minimum_delay =\n delay_change.get_effective_minimum_delay_at(historical_timestamp);\n let time_horizon =\n value_change.get_time_horizon(historical_timestamp, effective_minimum_delay);\n\n // We prevent this transaction from being included in any timestamp after the time horizon, ensuring that the\n // historical public value matches the current one, since it can only change after the horizon.\n self.context.set_include_by_timestamp(time_horizon);\n\n value_change.get_current_at(historical_timestamp)\n }\n\n fn historical_read_from_public_storage(\n self,\n ) -> (ScheduledValueChange<T>, ScheduledDelayChange<InitialDelay>, u64)\n where\n T: Packable,\n {\n let header = self.context.get_block_header();\n let address = self.context.this_address();\n\n let historical_timestamp = header.global_variables.timestamp;\n\n let values: DelayedPublicMutableValues<T, InitialDelay> =\n WithHash::historical_public_storage_read(header, address, self.storage_slot);\n\n (values.svc, values.sdc, historical_timestamp)\n }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, UtilityContext>\nwhere\n T: Eq,\n{\n pub unconstrained fn get_current_value(self) -> T\n where\n T: Packable,\n {\n let dpmv: DelayedPublicMutableValues<T, InitialDelay> =\n WithHash::utility_public_storage_read(self.context, self.storage_slot);\n\n let current_timestamp = self.context.timestamp();\n dpmv.svc.get_current_at(current_timestamp)\n }\n}\n"
|
|
3438
3438
|
},
|
|
3439
3439
|
"177": {
|
|
3440
3440
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
|
package/package.json
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
"name": "@aztec/protocol-contracts",
|
|
3
3
|
"homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/protocol-contracts",
|
|
4
4
|
"description": "Canonical Noir contracts for the Aztec Network",
|
|
5
|
-
"version": "2.0.
|
|
5
|
+
"version": "2.1.0-rc.2",
|
|
6
6
|
"type": "module",
|
|
7
7
|
"exports": {
|
|
8
8
|
".": "./dest/index.js",
|
|
@@ -73,9 +73,9 @@
|
|
|
73
73
|
]
|
|
74
74
|
},
|
|
75
75
|
"dependencies": {
|
|
76
|
-
"@aztec/constants": "2.0.
|
|
77
|
-
"@aztec/foundation": "2.0.
|
|
78
|
-
"@aztec/stdlib": "2.0.
|
|
76
|
+
"@aztec/constants": "2.1.0-rc.2",
|
|
77
|
+
"@aztec/foundation": "2.1.0-rc.2",
|
|
78
|
+
"@aztec/stdlib": "2.1.0-rc.2",
|
|
79
79
|
"lodash.chunk": "^4.2.0",
|
|
80
80
|
"lodash.omit": "^4.5.0",
|
|
81
81
|
"tslib": "^2.4.0"
|
|
@@ -88,7 +88,7 @@
|
|
|
88
88
|
"@types/node": "^22.15.17",
|
|
89
89
|
"jest": "^30.0.0",
|
|
90
90
|
"jest-mock-extended": "^4.0.0",
|
|
91
|
-
"ts-loader": "^9.
|
|
91
|
+
"ts-loader": "^9.5.4",
|
|
92
92
|
"ts-node": "^10.9.1",
|
|
93
93
|
"typescript": "^5.3.3"
|
|
94
94
|
},
|