Struct Restrictions

pub struct Restrictions<N: Network> { /* private fields */ }

A registry of program execution restrictions for the Aleo network.

The Restrictions struct maintains lists of programs, functions, and arguments that are restricted from execution on the network, either permanently or within specific block height ranges.

Structure

• Programs: Entire programs can be restricted by their program ID.
• Functions: Specific functions within programs can be restricted by their locator (program ID + function name).
• Arguments: Specific argument values to functions can be restricted based on input/output values.

Block Ranges

All restrictions are associated with block ranges that define when the restriction is active:

• .. - All blocks (permanent restriction).
• 10.. - From block 10 onwards.
• ..10 - Up to block 10.
• 10..20 - From block 10 to block 20.

How to update the restrictions list and snarkVM

1. Identify your favorite ${NETWORK}.
2. Update the content of fn test_restrictions_list_comparison to reflect the restrictions list.
3. Run cd synthesizer/src/restrictions && cargo test test_restrictions_list_comparison.
4. Update the restrictions.json in parameters/src/${NETWORK}/resources/restrictions.json.
5. Run cargo test test_restrictions_list_comparison.
6. Update the restrictions id printed by the test in the test and in parameters/src/${NETWORK}/resources/restrictions.json.
7. Run cargo test test_restrictions_list_comparison again to verify.

Example: Restricting a program

In the test_restrictions_list_comparison function of synthesizer/src/restrictions/mod.rs:

// Set the network.
type Network = console::network::MainnetV0;
// Initialize the restrictions.
let mut restrictions = Restrictions::<Network>::new_blank().unwrap();
// Add a program ID.
restrictions.restrictions_id =
    Field::from_str("5990626497004338480795078796922903812962674412239021866159347614258503263942field")
        .unwrap();
let program_id = ProgramID::from_str("hello.aleo").unwrap();
let range = BlockRange::RangeFrom(10..);
restrictions.programs.insert(program_id, range);
// Check the restrictions.
check_restrictions!(restrictions, Network);

In parameters/src/mainnet/resources/restrictions.json:

{
  "restrictions_id": "5990626497004338480795078796922903812962674412239021866159347614258503263942field",
  "programs": {
    "hello.aleo": {
      "RangeFrom": 10
    }
  },
  "functions": {},
  "arguments": {}
}

Example: Restricting an address

In the import section of the tests of synthesizer/src/restrictions/mod.rs:

Make sure to import console::types::Address, e.g., by replacing use console::types::I8; with use console::types::{Address, I8};.

In the test_restrictions_list_comparison function of synthesizer/src/restrictions/mod.rs:

// Set the network.
type Network = console::network::MainnetV0;
// Initialize the restrictions.
let mut restrictions = Restrictions::<Network>::new_blank().unwrap();
// Add a program ID.
restrictions.restrictions_id =
    Field::from_str("565692246249929386853861250603407577977410496268514614186112026084930301564field")
        .unwrap();
let program_id = ProgramID::from_str("credits.aleo").unwrap();
let function_id = Identifier::from_str("transfer_public").unwrap();
let literal = Literal::Address(
    Address::from_str("aleo10unn23a4z4jh2ea4g2n9fa7vz5mxzd2jf5nxpmv7f2f2sh3ur5rstqnpcg").unwrap(),
);
let index = 0;
let range = BlockRange::RangeFrom(150..);
restrictions.arguments.insert(
    Locator::new(program_id, function_id),
    indexmap!( ArgumentLocator::new(true, index) => indexmap!( literal.clone() => range )),
);
// Check the restrictions.
check_restrictions!(restrictions, Network);

In parameters/src/mainnet/resources/restrictions.json:

{
  "restrictions_id": "565692246249929386853861250603407577977410496268514614186112026084930301564field",
  "programs": {},
  "functions": {},
  "arguments": {
    "credits.aleo/transfer_public": {
      "true/0": {
        "aleo10unn23a4z4jh2ea4g2n9fa7vz5mxzd2jf5nxpmv7f2f2sh3ur5rstqnpcg": {
          "RangeFrom": 150
        }
      }
    }
  }
}

Implementations

impl<N: Network> Restrictions<N>

pub fn load() -> Result<Self>

Initializes the Restrictions instance for the current network.

pub fn new_blank() -> Result<Self>

Initializes a new Restrictions instance.

impl<N: Network> Restrictions<N>

pub const fn restrictions_id(&self) -> Field<N>

Returns the restrictions ID, for the current state of the Restrictions list.

pub const fn programs(&self) -> &IndexMap<ProgramID<N>, BlockRange>

Returns the set of program IDs that are restricted from being executed.

pub const fn functions(&self) -> &IndexMap<Locator<N>, BlockRange>

Returns the set of (program ID, function ID) pairs that are restricted from being executed.

pub const fn arguments( &self, ) -> &IndexMap<Locator<N>, IndexMap<ArgumentLocator, IndexMap<Literal<N>, BlockRange>>>

Returns the set of (program ID, function ID, argument) triples that are restricted from being executed.

impl<N: Network> Restrictions<N>

pub fn is_program_restricted( &self, program_id: &ProgramID<N>, block_height: u32, ) -> bool

Returns true if the given program ID is restricted from being executed.

pub fn is_function_restricted( &self, program_id: &ProgramID<N>, function_name: &Identifier<N>, block_height: u32, ) -> bool

Returns true if the given (program ID, function name) pair is restricted from being executed.

pub fn is_argument_restricted( &self, transition: &Transition<N>, block_height: u32, ) -> bool

Returns true if the given (program ID, function ID, argument) triple is restricted from being executed.

impl<N: Network> Restrictions<N>

pub fn contains_restricted_transitions( &self, execution: &Execution<N>, block_height: u32, ) -> bool

Returns true if the given execution contains any restricted transitions for the given block height.

impl<N: Network> Restrictions<N>

pub fn compute_restrictions_id( programs: &IndexMap<ProgramID<N>, BlockRange>, functions: &IndexMap<Locator<N>, BlockRange>, arguments: &IndexMap<Locator<N>, IndexMap<ArgumentLocator, IndexMap<Literal<N>, BlockRange>>>, ) -> Result<Field<N>>

Returns the restrictions ID.

Trait Implementations

impl<N: Clone + Network> Clone for Restrictions<N>

fn clone(&self) -> Restrictions<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N: Network> Debug for Restrictions<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Prints the restrictions as a JSON-string.

impl<'de, N: Network> Deserialize<'de> for Restrictions<N>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserializes the restrictions from a JSON-string.

impl<N: Network> Display for Restrictions<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Displays the restrictions as a JSON-string.

impl<N: Network> FromStr for Restrictions<N>

fn from_str(restrictions: &str) -> Result<Self, Self::Err>

Initializes the restrictions from a JSON-string.

type Err = Error

The associated error which can be returned from parsing.

impl<N: PartialEq + Network> PartialEq for Restrictions<N>

fn eq(&self, other: &Restrictions<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N: Network + Serialize> Serialize for Restrictions<N>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<N: Eq + Network> Eq for Restrictions<N>

impl<N: Network> StructuralPartialEq for Restrictions<N>