mirror of
https://github.com/ProvableHQ/leo.git
synced 2024-12-18 07:11:53 +03:00
initial commit
This commit is contained in:
collin
parent
34078a7739
commit
da73662edf
781
README.md
781
README.md
@ -3,782 +3,21 @@
|
||||
|
||||
[](https://codecov.io/gh/AleoHQ/leo)
|
||||
|
||||
|
||||
# Overview
|
||||
Welcome to the Leo programming language. Leo is a functional, statically-typed programming language built for writing private applications.
|
||||
|
||||
## Compiler Architecture
|
||||
The syntax of Leo is influenced by JavaScript, Python, Scala, and Rust with a strong emphasis on readability and ease-of-use.
|
||||
|
||||
<!-- generated by mermaid compile action - START -->
|
||||
|
||||
<details>
|
||||
<summary>Mermaid markup</summary>
|
||||
Leo exists to provide a simple high-level language that compiles to a rank one constraint system (R1CS) circuit. With Leo, you can write circuits to support zero-knowledge tokens, private stable coins, and decentralized marketplaces.
|
||||
|
||||
```mermaid
|
||||
graph LR
|
||||
Pass1(Syntax Parser) -- ast --> Pass2(Type Resolver)
|
||||
|
||||
Pass2 -- imports --> Pass3(Import Resolver)
|
||||
Pass3 -- statements --> Pass4
|
||||
|
||||
Pass2 -- statements --> Pass4(Synthesizer)
|
||||
|
||||
Pass4 -- constraints --> Pass5(Program)
|
||||
```
|
||||
# Download
|
||||
Download the binary for your operating system [here](https://github.com/AleoHQ/leo/releases/tag/v0.1.9)
|
||||
|
||||
</details>
|
||||
<!-- generated by mermaid compile action - END -->
|
||||
# Build
|
||||
|
||||
## Language Specification
|
||||
WIP
|
||||
|
||||
* Programs should be formatted:
|
||||
1. Import definitions
|
||||
2. Circuit definitions
|
||||
3. Function definitions
|
||||
# Quick Start
|
||||
|
||||
## Defining Variables
|
||||
Leo supports `let` and `const` keywords for variable definition.
|
||||
|
||||
```let a = true;``` defines an **allocated** program variable `a` with boolean value `true`.
|
||||
|
||||
```const a = true;``` defines a **constant** program variable `a` with boolean value `true`.
|
||||
|
||||
**Allocated** variables define private variables in the constraint system. Their value is constrained in the circuit on initialization.
|
||||
|
||||
**Constant** variables do not define a variable in the constraint system. Their value is constrained in the circuit on computation with an **allocated** variable.
|
||||
**Constant** variables cannot be mutable. They have the same functionality as `const` variables in other languages.
|
||||
```js
|
||||
function add_one() -> {
|
||||
let a = 0u8; // allocated, value enforced on this line
|
||||
const b = 1u8; // constant, value not enforced yet
|
||||
|
||||
return a + b // allocated, computed value is enforced to be the sum of both values
|
||||
}
|
||||
```
|
||||
Computations are expressed in terms of arithmetic circuits, in particular rank-1 quadratic constraint systems. Thus computing on an allocated variable always results in another allocated variable.
|
||||
|
||||
## Mutability
|
||||
* All defined variables in Leo are immutable by default.
|
||||
* Variables can be made mutable with the `mut` keyword.
|
||||
|
||||
```js
|
||||
function main() {
|
||||
let a = 0u32;
|
||||
//a = 1 <- Will fail
|
||||
|
||||
let mut b = 0u32;
|
||||
b = 1; // <- Ok
|
||||
}
|
||||
```
|
||||
|
||||
## Addresses
|
||||
|
||||
Addresses are defined to enable compiler-optimized routines for parsing and operating over addresses. These semantics will be accompanied by a standard library in a future sprint.
|
||||
|
||||
```js
|
||||
function main(owner: address) {
|
||||
let sender = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);
|
||||
let receiver: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
|
||||
assert_eq!(owner, sender);
|
||||
assert_eq!(sender, receiver);
|
||||
}
|
||||
```
|
||||
|
||||
## Booleans
|
||||
|
||||
Explicit types are optional.
|
||||
```js
|
||||
function main() -> bool {
|
||||
let a: bool = true || false;
|
||||
let b = false && false;
|
||||
let c = 1u32 == 1u32;
|
||||
return a
|
||||
}
|
||||
```
|
||||
|
||||
## Numbers
|
||||
* The definition of a number must include an explicit type.
|
||||
* After assignment, you can choose to explicitly add the type or let the compiler interpret implicitly.
|
||||
* Type casting is not supported.
|
||||
* Comparators are not supported.
|
||||
|
||||
### Integers
|
||||
Supported integer types: `u8`, `u16`, `u32`, `u64`, `u128`
|
||||
```js
|
||||
function main() -> u32 {
|
||||
let a = 2u32; // explicit type
|
||||
let a: u32 = 1 + 1; // explicit type
|
||||
|
||||
let b = a - 1; // implicit type
|
||||
let c = b * 4;
|
||||
let d = c / 2;
|
||||
let e = d ** 3;
|
||||
return e
|
||||
}
|
||||
```
|
||||
|
||||
### Field Elements
|
||||
```js
|
||||
function main() -> field {
|
||||
let a = 1000field; // explicit type
|
||||
let a: field = 21888242871839275222246405745257275088548364400416034343698204186575808495617; // explicit type
|
||||
let b = a + 1; // implicit type
|
||||
let c = b - 1;
|
||||
let d = c * 4;
|
||||
let e = d / 2;
|
||||
return e
|
||||
}
|
||||
```
|
||||
|
||||
### Group Elements
|
||||
An affine point on the elliptic curve passed into the Leo compiler forms a group.
|
||||
Leo supports this set as a primitive data type.
|
||||
|
||||
```js
|
||||
function main() -> group {
|
||||
let a = 1000group; // explicit type
|
||||
let a = (21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617)group; // explicit type
|
||||
let b = a + 0; // implicit type
|
||||
let c = b - 0;
|
||||
return c
|
||||
}
|
||||
```
|
||||
|
||||
### Operator Assignment Statements
|
||||
```js
|
||||
function main() -> u32 {
|
||||
let mut a = 10;
|
||||
a += 5;
|
||||
a -= 10;
|
||||
a *= 5;
|
||||
a /= 5;
|
||||
a **= 2;
|
||||
|
||||
return a
|
||||
}
|
||||
```
|
||||
|
||||
## Arrays
|
||||
Leo supports static arrays with fixed length.
|
||||
```js
|
||||
function main() -> u32[2] {
|
||||
// initialize an integer array with integer values
|
||||
let mut a: u32[3] = [1, 2, 3];
|
||||
|
||||
// set a mutable member to a value
|
||||
a[2] = 4;
|
||||
|
||||
// initialize an array of 4 values all equal to 42
|
||||
let b = [42u8; 4];
|
||||
|
||||
// initialize an array of 5 values copying all elements of b using a spread
|
||||
let c = [1, ...b];
|
||||
|
||||
// initialize an array copying a slice from `c`
|
||||
let d = c[1..3];
|
||||
|
||||
// initialize a field array
|
||||
let e = [5field; 2];
|
||||
|
||||
// initialize a boolean array
|
||||
let f = [true, false || true, true];
|
||||
|
||||
return d
|
||||
}
|
||||
```
|
||||
|
||||
### Multidimensional Arrays
|
||||
```js
|
||||
function main() -> u32[3][2] {
|
||||
let m = [[0u32, 0u32], [0u32, 0u32]];
|
||||
|
||||
let m: u32[3][2] = [[0; 3]; 2];
|
||||
|
||||
return m
|
||||
}
|
||||
```
|
||||
|
||||
## Conditionals
|
||||
|
||||
Branching in Leo is different than traditional programming languages. Leo developers should keep in mind that every program compiles to a circuit which represents
|
||||
all possible evaluations.
|
||||
|
||||
### If Else Ternary Expression
|
||||
Ternary `if [cond] ? [first] : [second];` expressions are the cheapest form of conditional.
|
||||
Since `first` and `second` are expressions, we can resolve their values before proceeding execution.
|
||||
In the underlying circuit, this is a single bit multiplexer.
|
||||
|
||||
```js
|
||||
function main() -> u32 {
|
||||
let y = if 3==3 ? 1 : 5;
|
||||
return y
|
||||
}
|
||||
```
|
||||
|
||||
### If Else Conditional Statement
|
||||
Leo supports the traditional `if [cond] { [first] } else { [second] }` which can be chained using `else if`.
|
||||
Since `first` and `second` are one or more statements, they resolve to separate circuits which will all be evaluated.
|
||||
In the underlying circuit this can be thought of as a demultiplexer.
|
||||
```js
|
||||
function main(a: bool, b: bool) -> u32 {
|
||||
let mut res = 0u32;
|
||||
|
||||
if a {
|
||||
res = 1;
|
||||
} else if b {
|
||||
res = 2;
|
||||
} else {
|
||||
res = 3;
|
||||
}
|
||||
|
||||
return res
|
||||
}
|
||||
```
|
||||
|
||||
### For loop
|
||||
```js
|
||||
function main() -> fe {
|
||||
let mut a = 1field;
|
||||
for i in 0..4 {
|
||||
a = a + 1;
|
||||
}
|
||||
return a
|
||||
}
|
||||
```
|
||||
|
||||
## Functions
|
||||
```js
|
||||
function test1(a : u32) -> u32 {
|
||||
return a + 1
|
||||
}
|
||||
|
||||
function test2(b: fe) -> field {
|
||||
return b * 2field
|
||||
}
|
||||
|
||||
function test3(c: bool) -> bool {
|
||||
return c && true
|
||||
}
|
||||
|
||||
function main() -> u32 {
|
||||
return test1(5)
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
### Function Scope
|
||||
```js
|
||||
function foo() -> field {
|
||||
// return myGlobal <- not allowed
|
||||
return 42field
|
||||
}
|
||||
|
||||
function main() -> field {
|
||||
let myGlobal = 42field;
|
||||
return foo()
|
||||
}
|
||||
```
|
||||
|
||||
### Multiple returns
|
||||
Functions can return tuples whose types are specified in the function signature.
|
||||
```js
|
||||
function test() -> (u32, u32[2]) {
|
||||
return (1, [2, 3])
|
||||
}
|
||||
|
||||
function main() -> u32[3] {
|
||||
let (a, b) = test();
|
||||
// (a, u32[2] b) = test() <- explicit type also works
|
||||
return [a, ...b]
|
||||
}
|
||||
```
|
||||
|
||||
### Function inputs
|
||||
Main function inputs are allocated private variables in the program's constraint system.
|
||||
`a` is implicitly private.
|
||||
```js
|
||||
function main(a: field) -> field {
|
||||
return a
|
||||
}
|
||||
```
|
||||
Normal function inputs are passed by value.
|
||||
```js
|
||||
function test(mut a: u32) {
|
||||
a = 0;
|
||||
}
|
||||
|
||||
function main() -> u32 {
|
||||
let a = 1;
|
||||
test(a);
|
||||
|
||||
return a // <- returns 1
|
||||
}
|
||||
```
|
||||
|
||||
## Circuits
|
||||
Circuits in Leo are similar to classes in object oriented langauges. Circuits are defined above functions in a Leo program. Circuits can have one or more members.
|
||||
|
||||
#### Circuit member values
|
||||
Members can be defined as fields which hold primitive values.
|
||||
```js
|
||||
circuit Point {
|
||||
x: u32
|
||||
y: u32
|
||||
}
|
||||
function main() -> u32 {
|
||||
let p = Point {x: 1, y: 0};
|
||||
return p.x
|
||||
}
|
||||
```
|
||||
|
||||
#### Circuit member functions
|
||||
Members can also be defined as functions.
|
||||
```js
|
||||
circuit Foo {
|
||||
function echo(x: u32) -> u32 {
|
||||
return x
|
||||
}
|
||||
}
|
||||
|
||||
function main() -> u32 {
|
||||
let c = Foo { };
|
||||
return c.echo(1u32)
|
||||
}
|
||||
```
|
||||
|
||||
#### Circuit member static functions
|
||||
Circuit functions can be made static, enabling them to be called without instantiation.
|
||||
```js
|
||||
circuit Foo {
|
||||
static function echo(x: u32) -> u32 {
|
||||
return x
|
||||
}
|
||||
}
|
||||
|
||||
function main() -> u32 {
|
||||
return Foo::echo(1u32)
|
||||
}
|
||||
```
|
||||
|
||||
#### `Self` and `self`
|
||||
The `Self` keyword is supported in circuit functions.
|
||||
```js
|
||||
circuit Circ {
|
||||
b: bool
|
||||
|
||||
static function new() -> Self { // Self resolves to Foo
|
||||
return Self { b: true }
|
||||
}
|
||||
}
|
||||
|
||||
function main() -> bool {
|
||||
let c = Foo::new();
|
||||
return c.b
|
||||
}
|
||||
```
|
||||
|
||||
The `self` keyword references the circuit's members.
|
||||
```rust
|
||||
circuit Foo {
|
||||
b: bool
|
||||
|
||||
function bar() -> bool {
|
||||
return self.b
|
||||
}
|
||||
|
||||
function baz() -> bool {
|
||||
return self.bar()
|
||||
}
|
||||
}
|
||||
|
||||
function main() -> bool {
|
||||
let c = Foo { b: true };
|
||||
|
||||
return c.baz()
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
## Imports
|
||||
Leo supports importing functions
|
||||
}
|
||||
} and circuits by name into the current file with the following syntax:
|
||||
|
||||
```js
|
||||
import [package].[name];
|
||||
```
|
||||
|
||||
#### Import Aliases
|
||||
To import a name using an alias:
|
||||
```js
|
||||
import [package].[name] as [alias];
|
||||
```
|
||||
|
||||
#### Import Multiple
|
||||
To import multiple names from the same package:
|
||||
```js
|
||||
import [package].(
|
||||
[name_1],
|
||||
[name_2] as [alias],
|
||||
);
|
||||
```
|
||||
|
||||
#### Import Star
|
||||
To import all symbols from a package:
|
||||
Note that this will only import symbols from the package library `lib.leo` file.
|
||||
```js
|
||||
import [package].*;
|
||||
```
|
||||
|
||||
### Local
|
||||
You can import from a local file in the same package using its direct path.
|
||||
`src/` directory by using its `[file].leo` as the `[package]` name.
|
||||
|
||||
```js
|
||||
import [file].[name];
|
||||
```
|
||||
|
||||
#### Example:
|
||||
`src/bar.leo`
|
||||
```js
|
||||
circuit Bar {
|
||||
b: u32
|
||||
}
|
||||
|
||||
function baz() -> u32 {
|
||||
return 1u32
|
||||
}
|
||||
```
|
||||
|
||||
`src/main.leo`
|
||||
```js
|
||||
import bar.(
|
||||
Bar,
|
||||
baz
|
||||
);
|
||||
|
||||
function main() {
|
||||
const bar = Bar { b: 1u32};
|
||||
const z = baz();
|
||||
}
|
||||
```
|
||||
|
||||
### Foreign
|
||||
You can import from a foreign package in the `imports/` directory using its `[package]` name.
|
||||
```js
|
||||
import [package].[name];
|
||||
```
|
||||
|
||||
#### Example:
|
||||
`imports/bar/src/lib.leo`
|
||||
```js
|
||||
circuit Bar {
|
||||
b: u32
|
||||
}
|
||||
```
|
||||
|
||||
`src/main.leo`
|
||||
```js
|
||||
import bar.Bar;
|
||||
|
||||
function main() {
|
||||
const bar = Bar { b: 1u32 };
|
||||
}
|
||||
```
|
||||
|
||||
### Package Paths
|
||||
Leo treats directories as package names when importing.
|
||||
```js
|
||||
import [package].[directory].[file].[name]
|
||||
```
|
||||
|
||||
#### Example:
|
||||
We wish to import the `Baz` circuit from the `baz.leo` file in the `bar` directory in the `foo` package
|
||||
|
||||
|
||||
`imports/foo/src/bar/baz.leo`
|
||||
```js
|
||||
circuit Baz {
|
||||
b: u32
|
||||
}
|
||||
```
|
||||
|
||||
`src/main.leo`
|
||||
```js
|
||||
import foo.bar.baz.Baz;
|
||||
|
||||
function main() {
|
||||
const baz = Baz { b: 1u32 };
|
||||
}
|
||||
```
|
||||
|
||||
## Constraints
|
||||
|
||||
### Assert Equals
|
||||
This will enforce that the two values are equal in the constraint system.
|
||||
|
||||
```js
|
||||
function main() {
|
||||
assert_eq!(45, 45);
|
||||
|
||||
assert_eq!(2fe, 2fe);
|
||||
|
||||
assert_eq!(true, true);
|
||||
}
|
||||
```
|
||||
|
||||
## Testing
|
||||
|
||||
Use the `test` keyword to add tests to a leo program. Tests must have 0 function inputs and 0 function returns.
|
||||
|
||||
```js
|
||||
function main(a: u32) -> u32 {
|
||||
return a
|
||||
}
|
||||
|
||||
test function expect_pass() {
|
||||
let a = 1u32;
|
||||
|
||||
let res = main(a);
|
||||
|
||||
assert_eq!(res, 1u32);
|
||||
}
|
||||
|
||||
test function expect_fail() {
|
||||
assert_eq!(1u8, 0u8);
|
||||
}
|
||||
```
|
||||
|
||||
## Logging
|
||||
|
||||
Leo supports `print!`, `debug!`, and `error!` logging macros.
|
||||
|
||||
The first argument a macro receives is a format string. This must be a string literal. The power of the formatting string is in the `{}`s contained.
|
||||
|
||||
Additional parameters passed to a macro replace the `{}`s within the formatting string in the order given.
|
||||
|
||||
#### `print!`
|
||||
Directly calls the `println!` macro in rust.
|
||||
```js
|
||||
function main(a: u32) {
|
||||
print!("a is {}", a);
|
||||
}
|
||||
```
|
||||
|
||||
#### `debug!`
|
||||
Enabled by specifying the `-d` flag after a Leo command.
|
||||
```js
|
||||
function main(a: u32) {
|
||||
debug!("a is {}", a);
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
#### `error!`
|
||||
Prints the error to console.
|
||||
```js
|
||||
function main(a: u32) {
|
||||
error!("a is {}", a);
|
||||
}
|
||||
```
|
||||
|
||||
# Leo Inputs
|
||||
|
||||
Private inputs for a Leo program are specified in the `inputs/` directory. The syntax for an input file is a limited subset of the Leo program syntax. The default inputs file is `inputs/inputs.leo`.
|
||||
|
||||
## Sections
|
||||
A Leo input file is made up of sections. Sections are defined by a section header in brackets followed by one or more input definitions.
|
||||
|
||||
Section headers specify the target file which must have a main function with matching input names and types.
|
||||
|
||||
`inputs/inputs.leo`
|
||||
|
||||
```rust
|
||||
[main] // <- section header
|
||||
a: u32 = 1;
|
||||
b: u32 = 2;
|
||||
```
|
||||
|
||||
`src/main.leo`
|
||||
|
||||
```rust
|
||||
function main(a: u32, b: u32) -> u32 {
|
||||
let c: u32 = a + b;
|
||||
return c
|
||||
}
|
||||
```
|
||||
|
||||
## Input Definitions
|
||||
|
||||
### Supported types
|
||||
```rust
|
||||
[main]
|
||||
a: bool = true; // <- booleans
|
||||
b: u8 = 2; // <- integers
|
||||
c: field = 0; // <- fields
|
||||
d: group = (0, 1)group // <- group tuples
|
||||
```
|
||||
|
||||
### Arrays
|
||||
```rust
|
||||
[main]
|
||||
a: u8[4] = [0u8; 4]; // <- single
|
||||
b: u8[2][3] = [[0u8; 2]; 3]; // <- multi-dimensional
|
||||
```
|
||||
|
||||
# Leo CLI
|
||||
|
||||
## Develop
|
||||
|
||||
### `leo new`
|
||||
|
||||
To setup a new package, run:
|
||||
```
|
||||
leo new {$NAME}
|
||||
```
|
||||
This will create a new directory with a given package name. The new package will have a directory structure as follows:
|
||||
```
|
||||
- inputs # Your program inputs
|
||||
- inputs.leo # Your program inputs for main.leo
|
||||
- outputs # Your program outputs
|
||||
- src
|
||||
- main.leo # Your program
|
||||
- tests
|
||||
- test.leo # Your program tests
|
||||
- Leo.toml # Your program manifest
|
||||
```
|
||||
|
||||
#### Flags
|
||||
```rust
|
||||
leo new {$Name} --bin
|
||||
```
|
||||
This will create a new directory with a given package name. The new package will have a directory structure as above.
|
||||
|
||||
```rust
|
||||
leo new {$Name} --lib
|
||||
```
|
||||
This will create a new directory with a given package name. The new package will have a directory structure as follows:
|
||||
```
|
||||
- src
|
||||
- lib.leo # Your program library
|
||||
- Leo.toml # Your program manifest
|
||||
```
|
||||
|
||||
### `leo init`
|
||||
|
||||
To initialize an existing directory, run:
|
||||
```
|
||||
leo init
|
||||
```
|
||||
This will initialize the current directory with the same package directory setup.
|
||||
|
||||
#### Flags
|
||||
`leo init` supports the same flags as `leo new`
|
||||
```rust
|
||||
leo init --bin
|
||||
```
|
||||
```rust
|
||||
leo init --lib
|
||||
```
|
||||
|
||||
|
||||
### `leo build`
|
||||
|
||||
To compile your program and verify that it builds properly, run:
|
||||
```
|
||||
leo build
|
||||
```
|
||||
|
||||
### `leo test`
|
||||
|
||||
To execute unit tests on your program, run:
|
||||
```
|
||||
leo test
|
||||
```
|
||||
The results of test compilation and the constraint system will be printed:
|
||||
```
|
||||
INFO leo Running 2 tests
|
||||
INFO leo test language::expect_pass compiled. Constraint system satisfied: true
|
||||
ERROR leo test language::expect_fail errored: Assertion 1u8 == 0u8 failed
|
||||
```
|
||||
|
||||
## Run
|
||||
|
||||
### `leo setup`
|
||||
|
||||
To perform the program setup, producing a proving key and verification key, run:
|
||||
```
|
||||
leo setup
|
||||
```
|
||||
Leo uses cryptographic randomness from your machine to perform the setup. The proving key and verification key are stored in the `target` directory as `.leo.pk` and `.leo.vk`:
|
||||
|
||||
```
|
||||
{$LIBRARY}/target/{$PROGRAM}.leo.pk
|
||||
{$LIBRARY}/target/{$PROGRAM}.leo.vk
|
||||
```
|
||||
|
||||
### `leo prove`
|
||||
|
||||
To execute the program and produce an execution proof, run:
|
||||
```
|
||||
leo prove
|
||||
```
|
||||
Leo starts by checking the `target` directory for an existing `.leo.pk` file. If it doesn't exist, it will proceed to run `leo setup` and then continue.
|
||||
|
||||
Next any input files in the `inputs` directory are parsed and all input values are passed to the program.
|
||||
|
||||
Once again, Leo uses cryptographic randomness from your machine to produce the proof. The proof is stored in the `target` directory as `.leo.proof`:
|
||||
|
||||
```
|
||||
{$LIBRARY}/target/{$PROGRAM}.leo.proof
|
||||
```
|
||||
|
||||
### `leo verify`
|
||||
|
||||
To verify the program proof, run:
|
||||
```
|
||||
leo verify
|
||||
```
|
||||
Leo starts by checking the `target` directory for an existing `.leo.proof` file. If it doesn't exist, it will proceed to run `leo prove` and then continue.
|
||||
|
||||
After the verifier is run, Leo will output either `true` or `false` based on the verification.
|
||||
|
||||
## Remote
|
||||
|
||||
To use remote compilation features, start by authentication with:
|
||||
```
|
||||
leo login
|
||||
```
|
||||
You will proceed to authenticate using your username and password. Next, Leo will parse your `Leo.toml` file for `remote = True` to confirm whether remote compilation is enabled.
|
||||
|
||||
If remote compilation is enabled, Leo syncs your workspace so when you run `leo build`, `leo test`, `leo setup` and `leo prove`, your program will run the program setup and execution performantly on remote machines.
|
||||
|
||||
This speeds up the testing cycle and helps the developer to iterate significantly faster.
|
||||
|
||||
## Publish
|
||||
|
||||
To package your program as a gadget and publish it online, run:
|
||||
```
|
||||
leo publish
|
||||
```
|
||||
Leo will proceed to snapshot your directory and upload your directory to the circuit manager. Leo will verify that `leo build` succeeds and that `leo test` passes without error.
|
||||
|
||||
If your gadget name has already been taken, `leo publish` will fail.
|
||||
|
||||
## Deploy
|
||||
|
||||
To deploy your program to Aleo, run:
|
||||
```
|
||||
leo deploy
|
||||
```
|
||||
|
||||
# Install
|
||||
|
||||
To install Leo from source, in the root directory of the repository, run:
|
||||
```
|
||||
cargo install --path .
|
||||
```
|
||||
|
||||
## TODO
|
||||
|
||||
- Change `target` directory to some other directory to avoid collision.
|
||||
- Figure out how `leo prove` should take in assignments.
|
||||
- Come up with a serialization format for `.leo.pk`, `.leo.vk`, and `.leo.proof`.
|
||||
WIP
|
||||
Loading…
Reference in New Issue
Block a user