Merge pull request #540 from ProvableHQ/update/11-7-25

AleoAlexander · web-flow · commit 5726e87922c6 · 2025-11-28T09:49:24.000-05:00
Leo v3.3.0
diff --git a/documentation/cli/00_overview.md b/documentation/cli/00_overview.md
@@ -43,12 +43,12 @@ You can print the list of commands by running `leo --help`
 ## Universal Flags
 These flags are available to use alongside all commands in the Leo CLI.
 
-#### `-h`
 #### `--help`
+#### `-h`
 Prints available commands and flags.
 
-#### `-V`
 #### `--version`
+#### `-V`
 Prints the currently installed version of Leo.
 
 #### `-q`
diff --git a/documentation/cli/02_add.md b/documentation/cli/02_add.md
@@ -52,9 +52,8 @@ Do not use this feature unless you know what you are doing!
 Specifies that the imported program is a development dependency and should not be used in production
 
 
-
-#### `-c`
 #### `--clear`
+#### `-c`
 Clears all previous dependencies.
 
 :::warning
diff --git a/documentation/cli/06_deploy.md b/documentation/cli/06_deploy.md
@@ -119,8 +119,8 @@ Saves the transaction to the directory located at the `<SAVE>` path.
 #### `--skip <SUBSTRING_0> <SUBSTRING_1> ...`
 Skips deployment of any program that contains one of the given substrings, delimited by a space.
 
-#### `-y`
 #### `--yes`
+#### `-y`
 The CLI will ask for manual confirmation on several steps throughout the deployment process.  Setting this flag automatically agrees to all confirmations.
 
 :::warning
@@ -135,9 +135,8 @@ Specifes the priority fee for the deployment transaction(s) delimited by `|` and
 :::
 
 
-#### `-f <FEE_RECORDS>`
 #### `--fee-records <FEE_RECORDS>`
-
+#### `-f <FEE_RECORDS>`
 Specifes the record(s) to pay for fees privately, delimited by `|` and used in order. The fees must either be valid plaintext, ciphertext, or `default`.  If not specified, then transaction fees will be public.
 
 
diff --git a/documentation/cli/08_execute.md b/documentation/cli/08_execute.md
@@ -116,8 +116,8 @@ Broadcasts the transaction to the network upon successful execution.  Without pa
 #### `--save <SAVE>`
 Saves the transaction to the directory located at the `<SAVE>` path.
 
-#### `-y`
 #### `--yes`
+#### `-y`
 The CLI will ask for manual confirmation on several steps throughout the deployment process.  Setting this flag automatically agrees to all confirmations.
 
 :::warning
@@ -131,10 +131,8 @@ Specifes the priority fee for the deployment transaction(s) delimited by `|` and
 1 Credit == 1,000,000 Microcreditss
 :::
 
-
-#### `-f <FEE_RECORDS>`
 #### `--fee-records <FEE_RECORDS>`
-
+#### `-f <FEE_RECORDS>`
 Specifes the record(s) to pay for fees privately, delimited by `|` and used in order. The fees must either be valid plaintext, ciphertext, or `default`.  If not specified, then transaction fees will be public.
 
 
diff --git a/documentation/cli/14_update.md b/documentation/cli/14_update.md
@@ -30,11 +30,11 @@ leo update --name v3.0.0
 ```
 
 ### Flags:
-#### `-l`
 #### `--list`
+#### `-l`
 Lists all available versions of Leo.
 
-#### `-n`
 #### `--name`
+#### `-n`
 An optional release name if you wish to install a specific version of Leo.  By default, the command will look for the latest release.
 
diff --git a/documentation/cli/15_upgrade.md b/documentation/cli/15_upgrade.md
@@ -52,8 +52,8 @@ Broadcasts the transaction to the network upon successful execution.  Without pa
 #### `--save <SAVE>`
 Saves the transaction to the directory located at the `<SAVE>` path.
 
-#### `-y`
 #### `--yes`
+#### `-y`
 The CLI will ask for manual confirmation on several steps throughout the deployment process.  Setting this flag automatically agrees to all confirmations.
 
 :::warning
@@ -67,10 +67,8 @@ Specifes the priority fee for the deployment transaction(s) delimited by `|` and
 1 Credit == 1,000,000 Microcreditss
 :::
 
-
-#### `-f <FEE_RECORDS>`
 #### `--fee-records <FEE_RECORDS>`
-
+#### `-f <FEE_RECORDS>`
 Specifes the record(s) to pay for fees privately, delimited by `|` and used in order. The fees must either be valid plaintext, ciphertext, or `default`.  If not specified, then transaction fees will be public.
 
 
diff --git a/documentation/cli/16_synthesize.md b/documentation/cli/16_synthesize.md
@@ -0,0 +1,46 @@
+---
+id: cli_synthesize
+title: ""
+sidebar_label: Synthesize
+toc_min_heading_level: 2
+toc_max_heading_level: 2
+---
+[general tags]: # (cli, synthesize, proving, verifying, keys, circuit)
+
+# `leo synthesize`
+
+This command is used to generate proving and verifying keys for all transitions in a local or remote Leo program, along with circuit metadata.
+
+```bash
+leo synthesize <PROGRAM_NAME> --save <SAVE_DIRECTORY>
+```
+
+Each output of this command includes:
+- Number of public inputs
+- Number of variables
+- Number of constraints
+- Non-zero entries in matrices
+- Circuit ID
+- Proving and verifying keys saved to disk
+
+This enables better understanding of program size and key management.
+
+### Flags:
+
+#### `--network <NETWORK>`
+Specifies the network to deploy to. Overrides any `NETWORK` environment variable set manually or in a `.env` file.  Valid network names are `testnet`, `mainnet`, and `canary`.
+
+#### `--endpoint <ENDPOINT>`
+The endpoint to deploy to. Overrides any `ENDPOINT` environment variable set manually or in a `.env` file.
+
+#### `--local` 
+#### `-l`
+Specifies that the keys should be generated for the local Leo project in the current working directory.
+
+#### `--skip <SKIP>`
+#### `-s <SKIP>`
+Specifies to skip the key generation for any function names that contain the provided substrings
+
+
+#### `--save <SAVE_DIRECTORY>`
+The directory to save the key files to.  If the provided path does not exist, it will be created in your current working directory.
diff --git a/documentation/language/02_structure.md b/documentation/language/02_structure.md
@@ -125,16 +125,27 @@ program hello.aleo { }
 ### Mappings
 
 A mapping is declared as `mapping {name}: {key-type} => {value-type}`.
-Mappings contain key-value pairs.
-Mappings are stored on chain.
+Mappings contain key-value pairs and stored on chain.
 
-```leo showLineNumbers
+```leo
 // On-chain storage of an `account` mapping,
 // with `address` as the type of keys,
 // and `u64` as the type of values.
 mapping account: address => u64;
 ```
 
+### Storage
+A storage variable is declared as `storage {name}: {type}`.  Storage variables contain singleton values.  They are declared at program scope and are stored on chain, similar to mappings.
+```leo
+// On-chain storage of an `counter` storage variable of type u32,
+storage counter: u32;
+```
+A storage vector is declared as `storage {name}: [{type}]`.  Storage vectors contain dynamic lists of values of a given type.  They are declared at program scope and are stored on chain, similar to mappings.
+```leo
+// On-chain storage of an `accounts` storage vector of type address,
+storage accounts: [address];
+```
+
 ### Struct
 
 A struct data type is declared as `struct {name} {}`.
diff --git a/documentation/language/03_data_types.md b/documentation/language/03_data_types.md
@@ -5,31 +5,6 @@ sidebar_label: Data Types
 ---
 [general tags]: # (boolean, integer, field, group, scalar, address, signature, array, tuple, struct)
 
-## Type Inference
-As of v2.7.0, Leo supports type inference. The Leo compiler is able to infer the types of declared variables and expressions as long as the type can be **unambiguously determined** from the surrounding context.  
-
-If the compiler cannot infer the type, you must provide an explicit type annotation. 
-
-Here are some examples:
-```leo
-let a: u8 = 2u8; // explicit type - allowed
-let b = 2u8; // type inference - allowed
-let c : u8 = 2; // type inference - allowed
-
-let d = 2; // ambiguous type - not allowed
-```
-
-Type inference also applies to members within a struct:
-```leo
-struct Foo {
-    x: u8
-}
-
-let f = Foo {
-    x: 5, // inferred to be a `u8`
-};
-```
-
 
 ## Types
 
@@ -61,20 +36,19 @@ let n: u64 = 1_000_000u64;
 Higher bit length integers generate more constraints in the circuit, which can slow down computation time.
 :::
 
-#### A Note on Leo Integers
-
+:::info
 Leo does not assume a default integer type.  Every integer must either have an **explicit type annotation** or a type that can be **inferred by the compiler**. 
 
 ```leo
 let a: u8 = 2u8; // explicit type
 let b: u16 = a as u16; // type casting
 ```
+:::
 
 ### Field Elements
 
 Leo supports the `field` type for elements of the base field of the elliptic curve.
-These are unsigned integers less than the modulus of the base field. The following are the
-smallest and largest field elements.
+These are unsigned integers less than the modulus of the base field. The following are the smallest and largest field elements.
 
 ```leo
 let a: field = 0field;
@@ -260,3 +234,58 @@ struct Matrix::[N: u32, M: u32] {
 let m = Matrix::[2, 2] { data: [0, 1, 2, 3] };
 ```
 Note that generic structs cannot currently be imported outside a program, but can be declared and used in submodules. Acceptable types for const generic parameters include integer types, `bool`,  `scalar`, `group`, `field`, and `address`.
+
+## Option Types
+As of v3.3.0, Leo supports first-class option types using the `T?` syntax, where `T` is any of the types previously mentioned, excluding `address`, `signature`, and `tuple`.  A value of type `T?` can be initialized into two states: either a value of type `T`, or `none`:
+```leo
+let w: u8? = 42u8;
+let x: u8? = none;
+```
+A value of type `T?` can be converted to type `T` by calling the `.unwrap()` method on the value.  Note that if the value being unwrapped is `none`, then the program will fail to execute.  To unwrap the value with a fallback for this case, call the `.unwrap_or()` method:
+```leo
+let y = w.unwrap();        // Returns 42u8
+let z = x.unwrap_or(99u8); // Returns 99u8
+```
+Option types can also be stored in arrays and structs:
+```leo
+// Struct of options
+struct Point { 
+    x: u32?, 
+    y: u32? 
+}
+
+// Array of options
+let arr: [u16?; 2] = [1u16, none];
+let first_val = arr[0].unwrap();        // Returns 1u16
+let second_val = arr[1].unwrap_or(0u16); // Returns 0u16
+
+// Structs have option variant as well
+let p: Point? = none;
+let p_val = p.unwrap_or(Point { x: 0u32, y: none }); // Returns default 
+```
+
+## Type Inference
+As of v2.7.0, Leo supports type inference. The Leo compiler is able to infer the types of declared variables and expressions as long as the type can be **unambiguously determined** from the surrounding context.  
+
+If the compiler cannot infer the type, you must provide an explicit type annotation. 
+
+Here are some examples:
+```leo
+let a: u8 = 2u8; // explicit type - allowed
+let b = 2u8; // type inference - allowed
+let c : u8 = 2; // type inference - allowed
+
+let d = 2; // ambiguous type - not allowed
+```
+
+Type inference also applies to members within a struct:
+```leo
+struct Foo {
+    x: u8
+}
+
+let f = Foo {
+    x: 5, // inferred to be a `u8`
+};
+```
+
diff --git a/documentation/language/04_operators.md b/documentation/language/04_operators.md
diff --git a/documentation/language/06_programs.md b/documentation/language/06_programs.md
diff --git a/documentation/language/operators/cryptographic_operators.md b/documentation/language/operators/cryptographic_operators.md
diff --git a/documentation/language/operators/standard_operators.md b/documentation/language/operators/standard_operators.md
